Hoe AI je eigen documenten kan doorzoeken (RAG uitgelegd)

📖 Voor wie is dit artikel? Voor ontwikkelaars, technische productmanagers en IT-leads die willen weten hoe RAG werkt en welke keuzes ertoe doen. Dit is een deep-dive: code, databases, optimalisatie. Ben je mkb-ondernemer die wil weten of RAG iets voor je bedrijf is? Lees dan eerst de FAQ hierboven — die geeft het antwoord zonder technische details. Helemaal nieuw met AI? Start bij wat AI is in gewone taal.

Het probleem met standaard LLMs

Large Language Models (LLMs, de AI-modellen achter ChatGPT, Claude en Llama) weten ongelofelijk veel, maar ze hebben fundamentele beperkingen.

• Geen toegang tot jouw data: Ze kennen je interne bedrijfsdocumenten, Confluence-pagina’s of klantgegevens niet
• Verouderde kennis: Hun training heeft een einddatum — alles daarna is onbekend
• Hallucinaties: Zonder context verzinnen ze soms overtuigende maar foutieve antwoorden
• Geen domeinspecifieke kennis: Gespecialiseerde vakkennis (juridisch, medisch, technisch) is vaak onvolledig

RAG (Retrieval-Augmented Generation) lost dit op door relevante context uit jouw eigen databronnen toe te voegen aan elke query, waardoor het LLM antwoorden genereert die gebaseerd zijn op jouw documenten (Bron: Prompting Guide — RAG Research). RAG is ook de motor onder de meeste productiviteits-agents die met je interne documenten werken — voor concrete agent-toepassingen zonder de techniek erachter zie vijf taken die je deze week kunt automatiseren.

💡 Beginner-tip: Stel je voor dat je een examen maakt. Zonder RAG moet je alles uit je hoofd weten (en soms gokt het LLM fout). Mét RAG mag je je aantekeningen erbij pakken — het LLM zoekt eerst de juiste informatie op en geeft dan pas antwoord.

Hoe RAG werkt: drie fasen

RAG bestaat uit drie kernfasen: indexering, retrieval en generation (Bron: JishuLabs RAG Guide 2026).

Fase 1: Indexering (vooraf, eenmalig)

Je documenten worden verwerkt en doorzoekbaar gemaakt:

Documenten → Laden → Chunking → Embeddings → Vector Database

Stap 1 — Documenten laden: Verzamel je bronnen: PDF’s, Word-bestanden, webpagina’s, Confluence, Notion, databases.

Stap 2 — Chunking (opsplitsen): Grote documenten worden opgesplitst in kleinere stukken. Dit is cruciaal voor de kwaliteit van je RAG-systeem.

Chunking strategie	Chunk size	Overlap	Wanneer gebruiken
Fixed-size	500–1000 tokens	10–20%	Eenvoudige documenten
Recursive	400–1000 tokens	50–200 tokens	Gestructureerde tekst
Semantic chunking	Variabel	N.v.t.	Complexe documenten
Parent-child	Parent: 2000, child: 400	50 tokens	Beste retrieval

(Bron: JishuLabs RAG Guide / LangChain Docs)

💡 Beginner-tip: “Chunking” is het opsplitsen van een lang document in kleinere stukjes. Vergelijk het met een boek: je kunt het hele boek niet in één keer aan de AI geven, dus knip je het op in paragrafen. De kunst is om de stukjes groot genoeg te houden voor context, maar klein genoeg om precies te zijn.

⚡ Gevorderden: Semantic chunking (op basis van betekenis in plaats van vaste grootte) is in 2026 de aanbevolen aanpak voor complexe documenten. Parent-child chunking combineert het beste van beide werelden: zoek op kleine chunks, maar lever de grotere parent-context aan het LLM (Bron: Techment RAG Best Practices 2026).

Stap 3 — Embeddings: Elk chunk wordt omgezet naar een numerieke vector (een reeks getallen) die de semantische betekenis vastlegt. Modellen hiervoor: OpenAI text-embedding-3-large, Cohere Embed, of open-source alternatieven als bge-large.

Stap 4 — Opslag in Vector Database: Vectors worden opgeslagen in een gespecialiseerde database. De populairste opties in 2026:

Database	Type	Latency	Beste voor
Pinecone	Fully managed cloud	20–80ms	Zero-ops, snelle start
Weaviate	Hybrid (cloud + on-prem)	30–70ms	Hybrid search, data sovereignty
Chroma	Open-source, embedded	50–100ms	Prototyping, kleine projecten
Qdrant	Open-source, Rust	15–30ms	High-performance, gefilterd zoeken
Milvus	Enterprise, distributed	25–50ms	Miljarden vectoren, enterprise

(Bron: Reintech Vector DB Comparison 2026 / SparkCo Deep Dive)

Fase 2: Retrieval (bij elke query)

Wanneer een gebruiker een vraag stelt:

Query → Embedding → Similarity Search → Reranking → Top K Chunks

1. De vraag wordt omgezet naar een embedding (dezelfde vectorruimte als de documenten)
2. Via similarity search (meestal cosine similarity) worden de meest vergelijkbare chunks gevonden
3. Reranking (2026 best practice): Een tweede model (cross-encoder of LLM-based ranker) herordent de resultaten voor betere relevantie

⚡ Gevorderden: Reranking is één van de hoogste ROI-upgrades in RAG. Een typische pipeline: retrieve 20–50 chunks goedkoop via vector similarity → rerank met cross-encoder → feed top 3–8 aan het LLM (Bron: Dev.to RAG Blueprint 2026).

Fase 3: Generation (antwoord genereren)

Het LLM ontvangt een samengestelde prompt:

Prompt = System Instruction + Retrieved Context + User Query

Het model genereert een antwoord op basis van de meegegeven context, niet uit het hoofd. Dit reduceert hallucinaties drastisch.

Code voorbeeld: RAG met LangChain en Python

Hier is een werkend voorbeeld met LangChain en Chroma — ideaal om lokaal mee te experimenteren (Bron: LangChain RAG Tutorial):

# Installeer dependencies:
# pip install langchain langchain-openai langchain-chroma

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_chroma import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import DirectoryLoader

# === STAP 1: Documenten laden en chunken ===
loader = DirectoryLoader("./documenten", glob="**/*.txt")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,     # Maximale chunk grootte in karakters
    chunk_overlap=200,   # Overlap tussen chunks voor context
    separators=["\n\n", "\n", ". ", " "]
)
chunks = splitter.split_documents(docs)

# === STAP 2: Embeddings maken en opslaan ===
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"  # Lokaal opslaan
)

# === STAP 3: Query uitvoeren ===
llm = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}  # Top 5 relevante chunks
)

# Zoek relevante documenten
query = "Wat is ons retourbeleid?"
relevant_docs = retriever.invoke(query)

# Bouw de prompt met context
context = "\n\n".join([doc.page_content for doc in relevant_docs])
messages = [
    {"role": "system", "content": f"""Beantwoord de vraag op basis van
    de onderstaande context. Als het antwoord niet in de context staat,
    zeg dat eerlijk.

    Context:
    {context}"""},
    {"role": "user", "content": query}
]

response = llm.invoke(messages)
print(response.content)

💡 Beginner-tip: Dit script doet drie dingen: (1) het leest je documenten in en knipt ze op, (2) het maakt ze doorzoekbaar met embeddings, en (3) het beantwoordt vragen op basis van die documenten. Je hebt een OpenAI API-key nodig om dit te draaien.

⚡ Gevorderden: Voor productie gebruik je beter LangChain’s create_agent met tools in plaats van een simpele chain. Dit geeft het model de mogelijkheid om zelf te beslissen wanneer het de retriever aanroept en meerdere queries uit te voeren. Overweeg ook LangSmith voor monitoring en tracing.

Best practices voor productie-RAG (2026)

De best practices zijn in 2026 geconvergeerd rond deze kernprincipes (Bron: Techment RAG Best Practices / Dev.to RAG Blueprint):

1. Hybrid search: Combineer vector search (semantisch) + keyword search (BM25). Dit vangt zowel betekenis als exacte termen
2. Cross-encoder reranking: Gebruik een tweede model om de top-resultaten te herordenen — dit is de hoogste ROI-upgrade
3. Chunk overlap van 10–20%: Voorkom dat context verloren gaat op chunk-grenzen
4. Metadata filtering: Filter op bron, datum, afdeling of document-type vóór de similarity search
5. Retrieval evaluatie als metric: Meet je retrieval-kwaliteit apart van de generatie-kwaliteit
6. Frequente index refreshes: Houd je index up-to-date met nieuwe documenten
7. Human-in-the-loop: Voor hoog-risico outputs (juridisch, medisch) altijd menselijke controle

Wanneer RAG gebruiken (en wanneer niet)?

✅ Ideale use cases:

• Interne kennisbanken en documentatie doorzoeken
• Klantenservice bots met bedrijfsspecifieke kennis
• Juridische en compliance document-analyse
• Technische documentatie en handleidingen
• HR-beleid en onboarding informatie

❌ Niet geschikt voor:

• Creatief schrijven (RAG beperkt de creativiteit)
• Algemene conversatie (geen specifieke context nodig)
• Real-time data (gebruik function calling / tool use)
• Rekenkundige taken (gebruik code-executie)
• Taken waar het LLM al voldoende kennis heeft

Volgende stappen

Wil je zelf aan de slag?

1. Beginners: Start met Chroma lokaal + LangChain. Laad een paar PDF’s en stel vragen
2. Gevorderden: Implementeer hybrid search + reranking met Weaviate of Qdrant
3. Enterprise: Evalueer Pinecone of Milvus voor schaalbare, beheerde oplossingen

Niet zeker welk model past bij RAG? Onze deep dive over open-source AI in 2026 vergelijkt Llama, Mistral en DeepSeek op context window, kosten en lokale inzet — de drie factoren die voor RAG-kwaliteit het meeste uitmaken.

RAG is bovendien vaak de ruggengraat van moderne enterprise-agents: een agent die zelfstandig je kennisbank doorzoekt voordat hij handelt, leunt onder de motorkap doorgaans op een RAG-pijplijn zoals hier beschreven. Voor het bredere beeld van wat agents zijn en waar ze in de praktijk wel en niet werken, lees AI-agents in 2026: wat zijn ze en wat kun je ermee.

Bronnen

• Prompting Guide — RAG Research
• JishuLabs RAG Guide 2026
• JishuLabs RAG Guide / LangChain Docs
• Techment RAG Best Practices 2026
• Dev.to RAG Blueprint 2026