Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Volledige RAG-architectuur

Les 11 van 22 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Wat is RAG?
  3. Fasen van de pipeline
  4. Volledige implementatie
  5. Gebruik
  6. Optimalisatiepunten
  7. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van de OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (API Responses) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Doelstellingen

  • De end-to-end RAG-architectuur begrijpen
  • Een functionele RAG-pipeline implementeren
  • Te optimaliseren componenten identificeren

Wat is RAG?

RAG (Retrieval-Augmented Generation) combineert documentzoekopdrachten met tekstgeneratie door een LLM. In plaats van uitsluitend te vertrouwen op interne kennis, ontvangt het model relevante documenten als context en stelt het vervolgens zijn antwoord op basis daarvan op. Alles wat u sinds het begin van deze cursus hebt gebouwd—embeddings, indexering, zoeken, evaluatie—vormt hier het eerste deel van een compleet systeem.

Waarom RAG?

Vier redenen rechtvaardigen dit, en ze versterken elkaar. Ten eerste eigen data: uw beleid voor thuiswerken, interne procedures en productcatalogus stonden nooit in de trainingsdata van het model, en geen enkele prompt zal ze daar krijgen. Ten tweede recente informatie: alles wat na de training dateert, is onzichtbaar voor het model, terwijl een index dezelfde dag nog wordt bijgewerkt. Verifieerbaarheid is minstens zo belangrijk, omdat elk antwoord verankerd is in identificeerbare bronnen die de gebruiker kan openen en controleren—dit transformeert het vertrouwen dat in het systeem wordt gesteld. Tot slot werkt kosten in het voordeel: kennis toevoegen via RAG kost veel minder dan fine-tuning, en correcties gebeuren door een document te verwijderen in plaats van een model opnieuw te trainen.

Fasen van de pipeline

Lees RAG als twee distincte fasen die u niet mag verwarren. Inname (Ingestion) gebeurt offline, eenmalig of telkens wanneer de corpus wordt bijgewerkt:

Documenten → Chunking → Embeddings → Vectoropslag

De query gebeurt online, voor elke gestelde vraag, en moet snel blijven:

Vraag → Embedding → Zoeken → Context + Vraag → LLM → Antwoord

Deze scheiding heeft een praktisch gevolg: de kosten voor inname worden eenmalig betaald en kunnen hoog zijn, terwijl de querykosten per oproep worden betaald en de gebruikerservaring bepalen. U kunt zich dus geavanceerde verwerking tijdens de inname veroorloven, maar moet aan de query-kant lean blijven.

Volledige implementatie

De volgende klasse materialiseert de drie fasen in drie afzonderlijke methoden, plus een vierde die ze aan elkaar koppelt. Deze scheiding is niet cosmetisch: hiermee kunt u zoeken testen zonder generatietokens te verbruiken, en generatie opnieuw uitvoeren op een vaste context om twee prompts te vergelijken.

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Innamefase ---

    def ingest(self, documents: list[dict]):
        """Neemt documenten {id, text, metadata} op."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Genereer embeddings in batches
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Inname voltooid: {len(self.chunks)} chunks geïndexeerd")

    # --- Ophaalfase ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Vindt de k meest relevante chunks."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Generatiefase ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Genereert een antwoord op basis van opgehaalde contexten."""
        # Bouw de prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Source: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "You are an assistant that answers questions "
                    "based solely on the provided documents. "
                    "If the information is not in the documents, "
                    "state this clearly. Cite your sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Reference documents:\n\n{formatted_context}\n\n"
                    f"---\n\nQuestion: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature requires effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Volledige pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Volledige RAG-pipeline: zoeken → generatie."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Drie details in de generatiefase bepalen het grootste deel van de kwaliteit. Het systeembericht verplicht om uitsluitend te antwoorden op basis van de verstrekte documenten en toe te geven wanneer informatie ontbreekt: zonder deze instructie zal het model hiaten invullen met zijn algemene kennis, wat leidt tot een plausibel maar verzonnen antwoord. Het voorvoegsel [Source: id] voor elk fragment geeft het model iets specifieks om te citeren, in plaats van een vaag “volgens de documenten”. Tot slot reduceert een temperature van 0,2 de variabiliteit: voor feitelijke vragen tegen een documentbasis wilt u consistentie, geen creativiteit.

Gebruik

Laten we de pipeline testen op een minimale businesscase—drie interne beleidsregels en een vraag die geen enkele exacte formulering ervan kopieert.

# Documenten voorbereiden
documents = [
    {
        "id": "leave-policy",
        "text": "Employees receive 25 days of paid leave "
                 "per year. Leave must be requested at least 2 weeks "
                 "in advance via the HR portal.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Remote work is authorized up to 3 days per week. "
                 "Tuesdays and Thursdays are mandatory office days. "
                 "Written agreement with the manager is required.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Expense reports must be submitted within 30 days "
                 "of the expense. Attach the original receipt. "
                 "Validation by the direct supervisor required for amounts over 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Pipeline aanmaken
rag = PipelineRAG()
rag.ingest(documents)

# Een vraag stellen
result = rag.answer("How many days of remote work per week?")
print(result["response"])
print("\nSources used:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Drijf de oefening verder door een vraag te stellen die geen enkel document beantwoordt, zoals een vraag over het zorgplan van het bedrijf. De pipeline zal nog steeds drie bronnen retourneren—zoeken retourneert altijd zijn k beste kandidaten—en het is het systeembericht dat moet voorkomen dat het model een antwoord verzint. Dit gedrag verifiëren voordat u naar productie gaat, is beter dan het via een klacht ontdekken.

Optimalisatiepunten

Elke stap in de pipeline kan onafhankelijk worden verbeterd, wat vooruitgang mogelijk maakt door kleine, meetbare aanpassingen.

StapMogelijke optimalisaties
ChunkingChunk-grootte, overlap, semantische chunking
EmbeddingModelkeuze, dimensies, tekstverrijking
ZoekenHybride, reranking, metadatafilters
PromptSysteeminstructies, contextformaat, few-shot
GeneratieModel, temperature, citaten

De volgende lessen detailleren elk van deze optimalisaties. Pak ze in deze volgorde aan: chunking bepaalt wat er kan worden opgehaald, en geen enkele reranking zal een slecht gechunkt document repareren.

Belangrijkste punten

  • RAG = Zoeken + Context + LLM-generatie
  • De pipeline splitst zich in inname (offline) en query (online)
  • Elk component (chunking, embedding, zoeken, prompt, generatie) kan onafhankelijk worden geoptimaliseerd
  • RAG is flexibeler en goedkoper dan fine-tuning voor het toevoegen van kennis