RAG-architectuur uitgelegd

Waarom RAG?

Taalmodellen zijn getraind op een grote maar verouderde dataset. Ze weten niets over jouw interne documenten, recente gebeurtenissen of bedrijfsspecifieke informatie. Je kunt dit op drie manieren oplossen:

1. Fine-tuning: het model trainen op jouw data. Duur, traag en slecht voor feiten die veranderen.
2. Context stuffing: alle relevante documenten in de prompt stoppen. Werkt alleen voor kleine datasets.
3. RAG: dynamisch de meest relevante documenten opzoeken en meegeven. Goedkoop, actueel en schaalbaar.

RAG is de standaardaanpak voor kennisbank-chatbots, interne zoekmachines en documentvragen.

De twee fasen van RAG

Fase 1: indexering (offline)

Documenten -> Chunking -> Embedding -> Vectordatabase

1. Inlezen: laad documenten (PDF, Word, HTML, Markdown).
2. Chunken: splits in kleinere stukken met overlap.
3. Embedden: converteer elke chunk naar een vector (een array van getallen).
4. Opslaan: bewaar de vectoren in een vectordatabase met de originele tekst als metadata.

Fase 2: retrieval en generatie (online)

Vraag -> Embedding -> Vectorzoekopdracht -> Top-k chunks -> LLM -> Antwoord

1. Vraag embedden: converteer de gebruikersvraag naar een vector.
2. Zoeken: vind de meest gelijkende chunks via cosine similarity.
3. Context bouwen: combineer de top-k chunks tot een context-string.
4. Genereren: geef vraag plus context aan het LLM en ontvang een antwoord.

Eenvoudige RAG-implementatie

In dit voorbeeld gebruiken we een vectordatabase (Chroma), een embedding-model van OpenAI en Claude voor de generatie. De modelnaam pas je aan op de versie die jij gebruikt.

import Anthropic from "@anthropic-ai/sdk";
import { ChromaClient } from "chromadb";

const anthropic = new Anthropic();
const chroma = new ChromaClient();

async function indexDocuments(documents: { id: string; content: string; source: string }[]) {
  const collection = await chroma.getOrCreateCollection({ name: "knowledge_base" });

  const batchSize = 50;
  for (let i = 0; i < documents.length; i += batchSize) {
    const batch = documents.slice(i, i + batchSize);
    const embeddings = await Promise.all(
      batch.map(doc => embedText(doc.content))
    );

    await collection.add({
      ids: batch.map(d => d.id),
      embeddings,
      documents: batch.map(d => d.content),
      metadatas: batch.map(d => ({ source: d.source })),
    });
  }
}

async function embedText(text: string): Promise<number[]> {
  const response = await fetch("https://api.openai.com/v1/embeddings", {
    method: "POST",
    headers: { "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({ input: text, model: "text-embedding-3-small" }),
  });
  const data = await response.json();
  return data.data[0].embedding;
}

async function ragQuery(question: string): Promise<string> {
  const collection = await chroma.getCollection({ name: "knowledge_base" });

  const questionEmbedding = await embedText(question);
  const results = await collection.query({
    queryEmbeddings: [questionEmbedding],
    nResults: 5,
  });

  const context = results.documents[0]
    ?.map((doc, i) => `[Bron ${i + 1}: ${results.metadatas[0]?.[i]?.source}]
${doc}`)
    .join("

") ?? "";

  const response = await anthropic.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    system: `Je bent een behulpzame assistent. Beantwoord vragen alleen op basis van de verstrekte context.
Als de context de informatie niet bevat, zeg dat dan expliciet.`,
    messages: [{
      role: "user",
      content: `Context:
${context}

Vraag: ${question}`,
    }],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

RAG-varianten

Er zijn grofweg drie volwassenheidsniveaus, oplopend in kwaliteit en complexiteit:

• Naive RAG: een eenvoudige opzoek-en-genereer pipeline. Goed voor een eerste versie. De kwaliteit hangt sterk af van chunking en embedding-kwaliteit.
• Advanced RAG: voegt pre-retrieval (query rewriting, HyDE) en post-retrieval (reranking, filtering) toe. Hogere kwaliteit, meer configuratie.
• Modular RAG: componenten zijn uitwisselbaar, met een andere retriever, reranker of generator per use case. Maximale flexibiliteit voor productiesystemen.

Kwaliteitsindicatoren

Meet je RAG-systeem op zowel de retrieval-stap als het uiteindelijke antwoord:

RAG versus fine-tuning

In de praktijk combineer je beide vaak: fine-tuning voor toon en gedrag, RAG voor de actuele feiten.