What is RAGFlow and how do I use it for document QA?

RAGFlow is a framework for building retrieval-augmented generation pipelines. You ingest, chunk, embed, retrieve, and generate answers with citations to reduce hallucinations and improve accuracy.

How should I chunk documents in RAGFlow?

Use semantic or hybrid chunking with 600–1,000 token chunks and 50–100 token overlap. For code, chunk by function or class and include surrounding context.

Which vector database works best with RAGFlow?

Choose a store that supports hybrid search, metadata filters, and reranking—Qdrant, Weaviate, Pinecone, or a local option are all common choices.

How do I prevent hallucinations in a RAGFlow app?

Enforce a cite‑or‑silence policy, add an answerability check before generation, and keep prompts strict about using only retrieved context.

What metrics should I track to evaluate RAGFlow?

Monitor retrieval hit rate, answer faithfulness, latency, and cost per 100 queries, and maintain a small but representative evaluation set.

Slik bruker du RAGFlow: En praktisk veiledning for å bygge pålitelige RAG-apper

Hvis du har prøvd å bygge et retrieval-augmented generation (RAG)-system, har du sannsynligvis støtt på de klassiske problemene: hallusinasjoner, upålitelig henting, trege pipelines og rotete dokumentforbehandling. RAGFlow trår til som et end-to-end arbeidsflytverktøy som hjelper deg med å orkestrere dokumentinnhenting, oppdeling, vektorisering, henting og generering med mer kontroll og observerbarhet.

Denne veiledningen har en praktisk og løsningsorientert tilnærming. Vi vil gå gjennom et rent oppsett, vise deg hvordan du bruker RAGFlow for ekte dokumenter, og dele mønstre som faktisk reduserer hallusinasjoner og forbedrer svarekvaliteten.

Hva er RAGFlow og hvorfor bruke det?

RAGFlow er et system for å bygge Retrieval-Augmented Generation-pipelines. I et typisk RAG-oppsett gjør du følgende:

Henter dokumenter (PDF-er, nettsider, slides, kode osv.)

Deler innhold inn i hentbare enheter

Bygger inn chunks i vektorer for semantisk søk

Henter topp-k relevante chunks når spørsmålet stilles

Genererer et forankret svar ved hjelp av en LLM

RAGFlow legger til meningsfulle standardinnstillinger, arbeidsflytblokker og sikkerhetsmekanismer slik at du kan iterere raskere og lansere mer pålitelige apper. Det er spesielt nyttig hvis du ønsker:

Konsekvent chunking og metadata: Bedre henting starter med bedre chunks.

Utskiftbare embeddings og LLM-er: Bytt ut OpenAI, lokale modeller eller bedriftsendepunkter.

Evalueringer og sikkerhetsmekanismer: Mål kvaliteten på hentingen og reduser hallusinasjoner.

Distribuerbare pipelines: Gå fra notatbok til produksjon med færre omskrivninger.

Hurtigstart: Fra null til en fungerende RAGFlow-pipeline

Nedenfor er en minimal, end-to-end arbeidsflyt du kan tilpasse. Selv om miljøet ditt er annerledes, er sekvensen og sikkerhetsmekanismene overførbare.

1) Forbered miljøet ditt

Opprett en .env med nøklene dine:

OPENAI_API_KEY (eller en annen LLM-leverandør)

EMBEDDINGS_API_KEY (hvis du bruker en separat leverandør)

VECTOR_DB_URL (f.eks. Pinecone, Weaviate, Qdrant eller lokal)

Sett en prosjektkatalog, f.eks. ragflow-project/ med mapper:

data/raw/ (kildefiler)

data/processed/ (rensede chunks)

configs/ (YAML/JSON for pipelineinnstillinger)

eval/ (datasett og rapporter)

2) Hent dokumenter med rene metadata

Gode metadata = bedre henting. Normaliser titler, forfattere, datoer og kilder.

Konverter PDF-er og slides til tekst med en robust parser

Bevar struktur: overskrifter, lister, kodeblokker og tabeller

Legg ved metadata til hver chunk: source, section, page, timestamp, version

Tips: Behold en doc_id og chunk_id for å støtte sitater og re-ingestion.

3) Velg en chunking-strategi som passer innholdet ditt

Chunking påvirker hentingskvaliteten og latensen sterkt.

For narrative dokumenter: semantisk chunking (del opp etter overskrifter/paragrafer)

For tekniske dokumenter: bruk hybrid chunking (semantisk + fast vindu)

For kode: chunk etter funksjon/klasse med et lite glidende vindu

Anbefalte innstillinger for å starte:

chunk_size: 600–1000 tokens

chunk_overlap: 50–100 tokens

max_depth: begrens nestede seksjoner til 2–3 nivåer for å unngå fragmentering

4) Velg embeddings og en vektorlagring

Start med en sterk generell embedding-modell (f.eks. text-embedding-3-large eller en moderne lokal modell). Hvis personvern er viktig, bør du vurdere selvhostede embeddings.

Bruk en vektor-DB som støtter:

Hybrid søk (tett + nøkkelord)

Filtre (metadatakonstrainter)

Batch upserts og indeksmetrikker

Indeksinnstillinger for å teste:

top_k = 5–10 for innledende henting

similarity_metric = cosine (eller dot for visse modeller)

Aktiver max marginal relevance (MMR) for å redusere redundans

5) Orkestrering av henting

Implementer en to-trinns retriever:

Rask kandidat-recall

Hybrid søk (BM25 + tett)

Stor top_k (f.eks. 30–50)

Reranking

Cross-encoder reranker eller LLM-basert scoring

Reduser til endelig top_k (f.eks. 5–8)

Legg til metadatafiltre: source:"handbook" AND section:"benefits" AND version:"v2" for å begrense svarene til pålitelige dokumenter.

6) Forankret generering med struktur

Prompten din bør håndheve sitater og avslag når bevisene er svake.

Eksempel på systemprompt:

Du er en nøye assistent. Svar KUN med informasjon som støttes av den angitte konteksten.
- Sitér kilder inline som [doc_id:chunk_id].
- Hvis konteksten er utilstrekkelig, si "Ikke nok informasjon i de medfølgende dokumentene."
- Ikke oppfinn fakta.

Bruk prompt-mal:

Spørsmål: {query}
Kontekst:
{top_chunks}
Instruksjoner:
- Gi et kortfattet svar først, deretter detaljer.
- Inkluder sitater etter hver faktiske påstand.

7) Legg til sikkerhetsmekanismer for å redusere hallusinasjoner

Svarbarhetssjekk: Før generering, spør en liten modell: «Er det direkte bevis i de hentede chunks?» Hvis nei, returner et avklarende spørsmål.

Sitér-eller-vær-stille-policy: Blokkér utdata som mangler sitater.

Toksisitets-/PII-filtre for bedriftsinnhold.

8) Evaluering og kontinuerlig forbedring

Opprett et eval/ sett med:

50–200 ekte brukerspørsmål

Fasitsvar (eller pålitelige referanser)

Forventede kilder (dokument-ID-er) der det er aktuelt

Mål:

Retrieval hit rate (vises gullkilden i topp-k?)

Svartro (sitasjonsstøttede uttalelser)

Latency (p95 end-to-end)

Cost (per 100 spørringer)

Iterer på:

Chunk-størrelse og overlapping

Valg av embedding-modell

Reranker vs. høyere topp-k

Prompt-struktur og begrensninger

En fullstendig RAGFlow-pipeline: Eksempelkonfigurasjon

Nedenfor er en konseptuell konfigurasjon du kan tilpasse til verktøykjeden din. Erstatt leverandørnavn etter behov.

project: product-handbook-rag
io:
input_path: data/raw/
output_index: product-handbook-index
parsing:
pdf:
strategy: auto
keep_layout: true
extract_tables: true
markdown:
preserve_headings: true
chunking:
method: semantic_hybrid
target_tokens: 800
overlap_tokens: 80
windowing: 2
metadata:
fields: [doc_id, title, section, page, version, source]
embeddings:
provider: openai
model: text-embedding-3-large
vectorstore:
type: qdrant
url: ${VECTOR_DB_URL}
similarity: cosine
retrieval:
hybrid: true
lexical_weight: 0.35
semantic_weight: 0.65
candidate_top_k: 40
rerank:
enabled: true
model: bge-reranker-large
final_top_k: 7
generation:
llm: gpt-4o
temperature: 0.2
cite_or_silence: true
guardrails:
answerability_check: true
pii_filter: true
toxicity_filter: moderate
monitoring:
log_traces: true
latency_budget_ms: 3500
cost_budget_per_100: 1.25

Slik bruker du RAGFlow for forskjellige innholdstyper

Produktmanualer og håndbøker

Foretrekk semantisk chunking med klare seksjonsgrenser

Legg ved versjon og gyldighetsdato for å forhindre utdaterte svar

Bruk strenge filtre: krev alltid versjon = latest

Kunnskapsbaser og FAQ-er

Bruk mindre chunks (400–600 tokens) for presise svar

Øk kandidatutvalget og stol på reranking for å finne det eksakte utdraget

Autogenerer kanoniske Q/A-par for å øke recall via leksikalsk søk

Tekniske dokumenter og kode

Chunk etter funksjon/modul og inkluder importgrafer i metadata

Aktiver foreldre-barn-henting: returner funksjon + dens docstring-kontekst

Bruk en kodebevisst reranker for å prioritere relevante symboler

Juridisk og compliance

Krev siteringer på paragrafnivå

Legg til avvisningslogikk for ufullstendig kontekst

Oppbevar et gyldent sett med regulatorgodkjente kilder i en separat indeks

Prompt-mønstre som faktisk fungerer

Svar deretter siter: Kort svar øverst; sitater inline etter hver påstand

Kjede av henting: Be modellen om å oppsummere hver chunk først, deretter syntetisere

Omskriv spørringen: Utvid brukerspørringer med synonymer og domenetermer før henting

Kontrastive prompter: «Forklar hvorfor alternativ A er bedre enn B basert på konteksten.» Dette tvinger bruk av bevis

Eksempel på trinn for å omskrive spørringen:

Original: "hva er vår PTO carryover policy?"
Omskriv: "betalt fritid carryover policy; ferie rollover; maks timer; policy versjon latest"

Observerbarhet og feedback loops

Logg hvilke chunks som ble brukt, deres score, og hvilke som ble ignorert

Fang opp tommel opp/ned med en kort begrunnelse; mate det tilbake i retriever-tuning

Kjør ukentlige regresjonstester på eval-settet ditt før du distribuerer endringer i modellen

Jukseark for ytelsestuning

Hvis svarene føles generiske: øk candidate_top_k og legg til en sterkere reranker

Hvis svarene mangler detaljer: reduser chunk-størrelsen; øk den leksikalske vekten litt

Hvis sitater gjentar den samme chunk: aktiver MMR og øk mangfoldet

Hvis latensen er høy: cache embeddings, forhåndsberegn spørringsoverskrivninger, bruk mindre reranker

Hvis kostnadene skyter i været: senk genereringstemperaturen, forkort prompter, prøv en mindre LLM for første passering

Sikkerhets- og styringsviktige ting

Krypter lagrede vektorer og rediger sensitive felt i metadata

Bruk tilgangskontroll per indeks; segmenter etter team eller datafølsomhet

Oppretthold en dataavstamningsjournal: dokumentkilde-URL, sjekksum og innhentingstidsstempel

Snapshot av case study: Fra rotete PDF-er til pålitelige svar

Et supportteam hentet inn 1200 sider med PDF-er. Innledende henting var inkonsekvent; agenter stolte ikke på boten. Etter å ha byttet til semantisk-hybrid chunking (800 tokens, 80 overlapping), aktivert cross-encoder reranking og håndhevet siter-eller-vær-stille, steg topp-k hit rate fra 62 % til 89 %, og agentadopsjonen doblet seg. Nøkkelen var ikke en større LLM – det var renere chunks og strengere henting.

Verktøytips: Rask iterasjon med en AI-sidefelt

Verdt å merke seg: Hvis du eksperimenterer med prompter og hentingsutdrag på tvers av mange dokumenter, kan en AI-assistent som lar deg chatte over PDF-er, nettsider og kode rett fra nettleseren akselerere iterasjonen. Forresten, Sider.AI (https://sider.ai/) tilbyr en AI-sidefelt som lar deg trekke inn kontekst fra siden du er på, oppsummere og avgrense prompter raskt. Det er praktisk for prototyping av RAG-prompter og testing av chunk-kvalitet før du formaliserer pipelinen.

Feilsøking av RAGFlow: Raske løsninger

«Modellen er sikker, men feil.»

Aktiver svarbarhetssjekk; senk temperaturen; krev sitater

«Søk returnerer nesten-duplikater.»

Slå på MMR; legg til en reranker; reduser chunk-overlappingen

«Latency skyter i været ved peak.»

Batch embeddings; cache spørringsoverskrivninger; bruk streaming-generering

«Gamle retningslinjer fortsetter å dukke opp.»

Filtrer på version = latest; avskriv eller legg ned utdaterte dokumenter

Neste trinn: Gjør RAGFlow pålitelig i produksjon

Start med et lite, pålitelig korpus; perfeksjoner chunking og filtre først

Legg til en reranker før du oppgraderer LLM

Bygg et 100-spørsmåls eval-sett og spor hit rate ukentlig

Koble til brukerfeedback for kontinuerlig å tune henting

Viktige takeaways:

Hentingskvalitet slår modellstørrelse for RAG

Chunking, metadata og reranking er dine viktigste spaker

Sikkerhetsmekanismer som siter-eller-vær-stille øker tilliten dramatisk

Invester tidlig i observerbarhet og evaluering

Med disse fremgangsmåtene blir RAGFlow en pålitelig ryggrad for forankrede svar – enten du driver en hjelpebot, en utvikler-copilot eller en intern kunnskapsassistent.

FAQ

Q1: Hva er RAGFlow, og hvordan bruker jeg det til dokument-QA? RAGFlow er et rammeverk for å bygge pipelines for retrieval-augmented generation. Du henter, chunker, bygger inn, henter og genererer svar med sitater for å redusere hallusinasjoner og forbedre nøyaktigheten.

Q2: Hvordan bør jeg chunk dokumenter i RAGFlow? Bruk semantisk eller hybrid chunking med 600–1000 token chunks og 50–100 token overlapping. For kode, chunk etter funksjon eller klasse og inkluder omkringliggende kontekst.

Q3: Hvilken vektor database fungerer best med RAGFlow? Velg en lagringsplass som støtter hybrid søk, metadatafiltre og reranking—Qdrant, Weaviate, Pinecone eller et lokalt alternativ er alle vanlige valg.

Q4: Hvordan forhindrer jeg hallusinasjoner i en RAGFlow-app? Håndhev en siter-eller-vær-stille-policy, legg til en svarbarhetssjekk før generering, og hold prompter strenge med å bare bruke hentet kontekst.

Q5: Hvilke metrikker bør jeg spore for å evaluere RAGFlow? Overvåk retrieval hit rate, svartro, latens og kostnad per 100 spørringer, og vedlikehold et lite, men representativt evalueringssett.