Wat is RAG? Retrieval-Augmented Generation Uitgelegd (2026)

Voorkennis & Setup

U heeft basiskennis Python nodig (functies, virtuele omgevingen, pip), het vermogen om een HTTP-aanroep te doen, en een API-sleutel voor OpenAI of Azure OpenAI. Meer niet.

python -m venv .venv
source .venv/bin/activate     # Windows: .venv\Scripts\activate
pip install openai chromadb sentence-transformers cohere langchain numpy

Zet uw API-sleutels in omgevingsvariabelen. Haal een OpenAI-sleutel (of gebruik Azure OpenAI in EU-regio voor productie). Optioneel: een Cohere-sleutel voor re-ranking.

Waarom RAG bestaat (het verhaal)

In 2019, als u een taalmodel vroeg "wat is ons retourbeleid?", had u drie slechte opties:

• Het model fine-tunen op uw beleid. Duur (€1.000+), langzaam (dagen), en elke beleidsupdate betekende opnieuw trainen.
• Het hele beleid in elke prompt plakken. Werkte voor één document. Viel uit elkaar bij de eerste kennisbank van duizend pagina's.
• Leven met hallucinaties. Het model verzon retourbeleid dat niet bestond.

In mei 2020 publiceerden Lewis et al. bij Facebook AI "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks". Het idee was elegant: monteer een zoekmachine op een taalmodel. Zoek voor elke vraag eerst in een kennisbank, voer dan de topresultaten samen met de vraag aan het model.

In 2024 gebruikte elk serieus LLM-product RAG: ChatGPT for Business, Microsoft Copilot, Perplexity, Notion AI, Glean, Klarna's klantenservice, Stripe's docs-assistent. In 2026 is het de standaardarchitectuur voor LLM-apps met privédata.

Het mentale model

Vijf termen die u moet internaliseren:

Anatomie: volg één vraag

Laten we één vraag van begin tot eind volgen. De gebruiker vraagt: "Wat is het retourbeleid van IITS?"

Niveau 1 — Speelgoedvoorbeeld

De minimaal levensvatbare RAG. Twintig regels. In-memory. Geen vector database. Draait nu direct op uw laptop.

import os, numpy as np
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

DOCS = [
    "Ons retourbeleid staat retouren toe binnen 30 dagen na aankoop.",
    "Verzending is gratis voor bestellingen boven 50 euro binnen Nederland.",
    "Klantenservice is beschikbaar maandag tot vrijdag, 9:00 tot 17:00 CET.",
    "Wij accepteren iDEAL, creditcard en SEPA bankoverschrijvingen.",
]

def embed(text):
    return client.embeddings.create(input=text, model="text-embedding-3-small").data[0].embedding

doc_vecs = np.array([embed(d) for d in DOCS])
question = "Kan ik iets retourneren dat ik vorige week heb gekocht?"
q_vec = np.array(embed(question))

scores = doc_vecs @ q_vec / (np.linalg.norm(doc_vecs, axis=1) * np.linalg.norm(q_vec))
top_doc = DOCS[int(np.argmax(scores))]

prompt = f"Context: {top_doc}\n\nVraag: {question}\n\nBeantwoord uitsluitend met de context hierboven."
answer = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}])
print(answer.choices[0].message.content)

Niveau 2 — Realistisch

Niveau 1 valt om bij vier problemen: (a) de documenten passen niet in het geheugen, (b) er is geen chunking, (c) er is geen re-ranking, (d) de prompt forceert geen grounding. Niveau 2 lost alle vier op met ChromaDB en Cohere Rerank.

import os, chromadb, cohere
from openai import OpenAI
from langchain_text_splitters import RecursiveCharacterTextSplitter

openai = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
co = cohere.Client(os.environ["COHERE_API_KEY"])
db = chromadb.PersistentClient(path="./rag_db").get_or_create_collection("docs")

# 1. Chunk een echt document (recursive splitter respecteert paragrafen en zinnen)
with open("beleid.md") as f:
    text = f.read()
splitter = RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=64)
chunks = splitter.split_text(text)

# 2. Embed en sla op
vectors = [openai.embeddings.create(input=c, model="text-embedding-3-small").data[0].embedding for c in chunks]
db.add(ids=[str(i) for i in range(len(chunks))], embeddings=vectors, documents=chunks)

def vraag(vraag_tekst):
    # 3. Haal top-20 kandidaten op
    q_vec = openai.embeddings.create(input=vraag_tekst, model="text-embedding-3-small").data[0].embedding
    results = db.query(query_embeddings=[q_vec], n_results=20)
    candidates = results["documents"][0]

    # 4. Herrangschik naar top-3
    reranked = co.rerank(query=vraag_tekst, documents=candidates, top_n=3, model="rerank-multilingual-v3.0")
    top_chunks = [candidates[r.index] for r in reranked.results]

    # 5. Augmented prompt met grounding-instructie
    context = "\n\n---\n\n".join(top_chunks)
    prompt = (
        "Beantwoord de vraag UITSLUITEND met de context hieronder. "
        "Als het antwoord niet in de context staat, zeg dan 'Die informatie heb ik niet.' "
        f"Verwijs naar het relevante chunknummer.\n\nContext:\n{context}\n\nVraag: {vraag_tekst}"
    )
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
    )
    return response.choices[0].message.content

print(vraag("Wat is ons retourbeleid voor digitale producten?"))

Niveau 3 — Productiepatroon

In productie scheidt u verantwoordelijkheden, voegt u observability toe, evalueert u kwaliteit en voegt u hybride (vector + trefwoord) zoeken toe. Schets van een productie-vormige module:

# rag/pipeline.py
from dataclasses import dataclass
from typing import Sequence
import logging, time

@dataclass
class RetrievedChunk:
    text: str
    score: float
    source: str
    chunk_id: str
    metadata: dict

class RAGPipeline:
    def __init__(self, embedder, vector_store, keyword_store, reranker, llm, *, top_k=20, top_n=4):
        self.embedder = embedder
        self.vector_store = vector_store      # bijv. Azure AI Search, pgvector
        self.keyword_store = keyword_store    # bijv. BM25 over dezelfde corpus
        self.reranker = reranker
        self.llm = llm
        self.top_k = top_k
        self.top_n = top_n
        self.log = logging.getLogger("rag")

    def ask(self, vraag: str, *, tenant_id: str, trace_id: str) -> dict:
        t0 = time.perf_counter()

        # 1. Hybride retrieval — vector + trefwoord parallel
        q_vec = self.embedder.embed(vraag)
        vec_hits = self.vector_store.search(q_vec, top_k=self.top_k, filter={"tenant": tenant_id})
        kw_hits = self.keyword_store.search(vraag, top_k=self.top_k, filter={"tenant": tenant_id})
        merged = self._reciprocal_rank_fusion(vec_hits, kw_hits)

        # 2. Herrangschik
        reranked = self.reranker.rerank(vraag, merged, top_n=self.top_n)

        # 3. Fallback als niets relevant is
        if not reranked or reranked[0].score < 0.3:
            self.log.info("low_confidence_retrieval", extra={"trace_id": trace_id})
            return {"answer": "Die informatie heb ik niet.", "sources": [], "trace_id": trace_id}

        # 4. Augmented prompt
        context = self._format_context(reranked)
        prompt = self._build_prompt(vraag, context)
        answer = self.llm.generate(prompt, temperature=0, max_tokens=600)

        # 5. Observability
        self.log.info(
            "rag_query",
            extra={
                "trace_id": trace_id,
                "tenant_id": tenant_id,
                "latency_ms": int((time.perf_counter() - t0) * 1000),
                "n_retrieved": len(merged),
                "n_used": len(reranked),
                "top_score": reranked[0].score,
            },
        )

        return {
            "answer": answer,
            "sources": [{"id": c.chunk_id, "source": c.source, "score": c.score} for c in reranked],
            "trace_id": trace_id,
        }

Voeg een evaluatieharnas toe met RAGAS dat faithfulness meet (is het antwoord gegrond in de context?), answer relevancy, en context precision/recall. Draai het bij elke wijziging aan chunking, embeddings of prompt.

Acht valkuilen (productielessen)

RAG vs Fine-tuning vs Long Context vs Cache-Augmented

Kosten & Prestaties

Verder gaan

Geselecteerde bronnen

• Lewis et al. (2020) — Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (de originele paper)
• Anthropic — Contextual Retrieval (een 2024-techniek die retrieval-fouten 49% verlaagt)
• Eugene Yan — Patterns for Building LLM-based Systems & Products (de meest geciteerde praktische gids)
• RAGAS — RAG-evaluatiebibliotheek
• LlamaIndex docs (het meest RAG-gerichte framework)
• Azure AI Search RAG-overzicht (productiepatronen voor Microsoft-stack)

Zelfcheck: heeft u het geleerd?

chunks = db.query(query_embeddings=[q], n_results=50)
context = "\n".join(chunks)
prompt = f"Beantwoord: {vraag}\nContext: {context}"

Veelgestelde vragen