Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Volledige RAG-pipeline

Les 14 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Alles samenvoegen
  2. De volledige pipeline
  3. De pipeline uitvoeren
  4. Vijf richtingen voor verdere verbetering
  5. Belangrijkste punten

Alles samenvoegen

In eerdere lessen hebben we elke schakel in de keten apart behandeld: laden, chunken, encoderen, indexeren, ophalen en genereren. Nu is het tijd om deze onderdelen samen te smeden tot één volledig, end-to-end programma dat u direct kunt uitvoeren en vervolgens kunt aanpassen voor uw eigen documenten. Dit script past in één bestand en vereist slechts vier afhankelijkheden.

pip install mistralai faiss-cpu numpy requests

De volledige pipeline

Twee ontwerpkeuzes structureren deze code. Ten eerste groeperen we alle configuratie bovenaan het bestand: modellen, chunk-grootte, batch-grootte en TOP_K zijn benoemde constanten. Dit bespaart u het zoeken naar hard-coded waarden diep in functies wanneer u het gedrag wilt afstemmen. Ten tweede splitsen we de logica in zes onafhankelijke functies, die elk overeenkomen met één stap en hun voortgang afdrukken als [n/6]. Deze trace is niet louter decoratief: wanneer de pipeline faalt of een vreemd antwoord retourneert, weet u direct of het probleem bij het laden, chunken of ophalen ligt. Elke functie is ook geïsoleerd vervangbaar; u kunt bijvoorbeeld een PDF-loader inruilen voor load_data zonder de rest van de code aan te raken.

De functie main koppelt de stappen aan elkaar en stelt vervolgens drie vragen over het essay van Paul Graham dat als onze demo-dataset dient. Merk op dat ophalen en genereren binnen de lus plaatsvinden, terwijl indexeren slechts één keer vooraf gebeurt: het opnieuw encoderen van het volledige corpus voor elke vraag zou absurd zijn qua kosten en latentie.

import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral

# ============================================================
# Configuration
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3

client = Mistral(api_key=MISTRAL_API_KEY)


# ============================================================
# Step 1: Load Data
# ============================================================
def load_data(url):
    """Load a text document from a URL."""
    print("[1/6] Loading data...")
    response = requests.get(url)
    response.raise_for_status()
    text = response.text
    print(f"  -> {len(text)} characters loaded")
    return text


# ============================================================
# Step 2: Create Chunks
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
    """Split text into chunks."""
    print("[2/6] Creating chunks...")
    chunks = []
    paragraphs = text.split("\n\n")
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue
        if len(current) + len(para) + 2 <= chunk_size:
            current = current + "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current)
            current = para

    if current:
        chunks.append(current)

    print(f"  -> {len(chunks)} chunks created (avg size: {sum(len(c) for c in chunks) // len(chunks)} chars)")
    return chunks


# ============================================================
# Step 3: Generate Embeddings
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
    """Encode chunks into embeddings via mistral-embed."""
    print("[3/6] Generating embeddings...")
    all_embeddings = []

    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]
        response = client.embeddings.create(
            model=EMBED_MODEL,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"  -> Batch {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} encoded")

    embeddings = np.array(all_embeddings, dtype=np.float32)
    print(f"  -> Matrix: {embeddings.shape}")
    return embeddings


# ============================================================
# Step 4: Create FAISS Index
# ============================================================
def create_index(embeddings):
    """Create and populate a FAISS index."""
    print("[4/6] Creating FAISS index...")
    dimension = embeddings.shape[1]
    index = faiss.IndexFlatL2(dimension)
    index.add(embeddings)
    print(f"  -> Index: {index.ntotal} vectors, dimension {dimension}")
    return index


# ============================================================
# Step 5: Retrieve Relevant Chunks
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
    """Retrieve the most relevant chunks."""
    print(f"[5/6] Searching for: '{question[:50]}...'")
    response = client.embeddings.create(
        model=EMBED_MODEL,
        inputs=[question],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    distances, indices = index.search(query_vector, k)

    results = []
    for dist, idx in zip(distances[0], indices[0]):
        if idx >= 0:
            results.append({
                "text": chunks[idx],
                "distance": float(dist),
            })

    print(f"  -> {len(results)} chunks retrieved")
    return results


# ============================================================
# Step 6: Generate Answer
# ============================================================
def generate(question, context_chunks):
    """Generate the answer using retrieved context."""
    print("[6/6] Generating answer...")

    context = "\n\n---\n\n".join([c["text"] for c in context_chunks])

    prompt = f"""Informative context:

{context}

---

Based ONLY on the context above, answer the following question precisely and completely.

Question: {question}"""

    response = client.chat.complete(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": "You are an assistant that answers based on the provided context."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.1,
    )

    answer = response.choices[0].message.content
    print(f"  -> Answer generated ({len(answer)} characters)")
    return answer


# ============================================================
# Main Pipeline
# ============================================================
def main():
    """Run the complete RAG pipeline."""
    # 1. Load
    url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
    text = load_data(url)

    # 2. Chunk
    chunks = create_chunks(text)

    # 3. Encode
    embeddings = create_embeddings(chunks)

    # 4. Index
    index = create_index(embeddings)

    # 5+6. Question -> Answer
    questions = [
        "What were the two main things the author worked on before college?",
        "What did the author do during their time at Y Combinator?",
        "What programming language did the author learn first?",
    ]

    for question in questions:
        print(f"\n{'='*60}")
        context = retrieve(question, index, chunks)
        answer = generate(question, context)
        print(f"\nQ: {question}")
        print(f"A: {answer}")


if __name__ == "__main__":
    main()

De pipeline uitvoeren

Sla deze code op als rag_pipeline.py, exporteer uw API-sleutel in de omgeving (hard-code deze nooit in het bestand, want dat belandt uiteindelijk in een repository) en voer het script uit. De uitvoer doorloopt de zes stappen en verwerkt vervolgens de drie vragen met hun antwoorden. Als een antwoord off-topic lijkt, vergelijk het dan met de chunks die in stap 5 worden weergegeven voordat u het generatiemodel de schuld geeft.

export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py

Vijf richtingen voor verdere verbetering

Deze pipeline is een fundament, geen eindproduct, en elke beperking wijst op een volgende stap. De meest directe is persistentie: in de huidige vorm encodeert het script het volledige corpus bij elke uitvoering opnieuw, terwijl het opslaan van de FAISS-index en de chunks daaropvolgende uitvoeringen nagenoeg direct zou maken. Re-ranking is het volgende niveau: hierbij worden FAISS-resultaten door een cross-encoder geleid die de relevantie veel fijner beoordeelt dan alleen vectorafstand. Metadata-filtering adresseert een andere behoefte: het beperken van zoekopdrachten op datum, categorie of auteur, naast similariteit. Twee laatste verbeteringen richten zich op de gebruikerservaring: streaming, waarbij het antwoord wordt weergegeven terwijl het wordt gegenereerd in plaats van na enkele seconden stilte, en conversatiegeschiedenis, waarmee gebruikers vervolg vragen kunnen stellen zoals “hoe zit het met versie 2?” zonder hun hele vraag te herhalen.

# 1. Save the index to avoid recalculating
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))

# 2. Add re-ranking
# After FAISS retrieval, use a cross-encoder model
# to re-order results by fine-grained relevance

# 3. Metadata filtering
# Add filters (date, category, author) in addition
# to vector similarity

# 4. Response streaming
# Use client.chat.stream() to display the answer
# as it generates

# 5. Conversation history
# Add previous exchanges to the prompt
# for a contextual RAG chatbot

Belangrijkste punten

  • De volledige RAG-pipeline bestaat uit 6 stappen: laden, chunken, encoderen, indexeren, ophalen, genereren
  • Elke stap is een onafhankelijke functie, eenvoudig te testen en te vervangen
  • Gebruik temperature=0.1 voor feitelijke antwoorden
  • Sla de FAISS-index en embeddings op om herberekening bij elke uitvoering te voorkomen
  • Deze pipeline is een solide startpunt om naar behoefte uit te breiden