Retrieval en Generatie
Op deze pagina
Van Vector naar Antwoord
U weet nu hoe u documenten indexeert en de exemplaren ophaalt die het dichtst bij een vraag staan. Er resteert nog één stap: het omzetten van een lijst chunks in een leesbaar antwoord. Dit betekent dat u de opgehaalde context in een prompt injecteert, zodat het LLM een respons formuleert op basis van uw data in plaats van zijn trainingsgeheugen. Het kost slechts een paar regels code, maar het maakt een doorslaggevend verschil voor de kwaliteit. Een goed gepresenteerde context en een duidelijke instructie zijn minstens zo belangrijk als de precisie van de retrieval.
De RAG-prompt Opbouwen
De structuur van de prompt is eenvoudig, maar elke keuze heeft gevolgen. Nummer de chunks en voorzie ze van een bronvermelding, zodat het model nauwkeurig kan citeren. Scheid ze met een zichtbaar scheidingsteken, ---, zodat het model twee tegenstrijdige documenten niet samenvoegt tot één bewering. Het allerbelangrijkste is dat de instructie het antwoord expliciet beperkt tot de verstrekte context en het model toestemming geeft om aan te geven dat het iets niet weet. Zonder die toestemming zal een LLM dat wordt ondervraagd over ontbrekende informatie het gat vullen met wat maar aannemelijk lijkt. Dat is precies het mechanisme achter hallucinaties.
def build_rag_prompt(question, retrieved_chunks):
"""Build the RAG prompt with retrieved context."""
# Format the context
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "unknown source")
context_parts.append(f"[Document {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""You are an expert assistant. Answer the question using
ONLY the context provided below. If the information is not in the
context, say so clearly.
## Context
{context}
## Question
{question}
## Answer"""
return prompt
Het Antwoord Genereren
De generatie-aanroep is rechttoe rechtaan: een systeembericht dat de rol herhaalt, en een gebruikersbericht dat de samengestelde prompt bevat. Let op de parameter temperature, hier ingesteld op 0.1. Bij creatief schrijven wilt u variatie; bij RAG wilt u het tegenovergestelde. U wilt dat het model zo dicht mogelijk bij de context blijft, en u wilt dat twee runs met dezelfde vraag hetzelfde antwoord produceren. Een hoge temperature zou het model aansporen om te herformuleren, te extrapoleren en af te dwalen van de bron.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generate a RAG answer with Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "You are a precise assistant that answers based on the provided context."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Low temperature for factual answers
)
return response.choices[0].message.content
# Example
question = "What are the main steps of RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
De Flow Kapselen in een Klasse
Verspreide functies werken voor exploratie, niet voor oplevering. De klasse RAGPipeline bundelt de state—de chunks, de embeddings-matrix en de FAISS-index die eenmaal bij instantiatie wordt gebouwd—en drie operaties: retrieve codeert de vraag en bevraagt de index, generate stelt de prompt samen en roept het model aan, en ask koppelt deze twee aan elkaar. Let op wat ask retourneert: geen string, maar een dictionary met het antwoord, de lijst van bronnen en het aantal gebruikte chunks. Deze traceerbaarheid is wat een controleerbare assistent onderscheidt van een black box. Op de dag dat een gebruiker een antwoord betwist, weet u op welke passages het is gebaseerd.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Complete RAG pipeline with Mistral and FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Create the FAISS index
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Step 1: retrieve relevant chunks."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Step 2: generate the answer with context."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Full pipeline: question -> sourced answer."""
# Retrieval
context = self.retrieve(question, k=k)
# Generation
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Usage
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("How does indexing work in FAISS?")
print(f"Question: {result['question']}")
print(f"Answer: {result['answer']}")
print(f"Sources: {result['sources']}")
Drie Prompt-varianten per Use Case
U kunt de basisprompt specialiseren afhankelijk van wat u van de assistent verwacht. Als uw gebruikers elke bewering moeten kunnen verifiëren, vraag dan expliciet om citaten tussen haakjes. Het model koppelt dan elke zin aan een genummerd document. Als het antwoord dient voor een interface of een rapport, dwingt een gestructureerd formaat stabiele secties af: een beknopt antwoord, details, bronnen en een betrouwbaarheidsniveau dat weerspiegelt hoe goed de context de vraag dekt. De derde variant speelt een andere rol: het leert het model onzekerheid te ontleden door onderscheid te maken tussen wat het kan beweren, wat er ontbreekt en waar het verder moet zoeken. Dit levert in de praktijk vaak de nuttigste assistenten op, omdat “Ik mis X” beter is dan een zelfverzekerd maar foutief antwoord.
# 1. Prompt with citation instruction
prompt_cite = """Answer by citing source documents in brackets.
Example: "RAG improves accuracy [Document 1]."
Context: {context}
Question: {question}"""
# 2. Prompt with structured format
prompt_structured = """Answer in the following format:
**Answer**: [your concise answer]
**Details**: [detailed explanation]
**Sources**: [list of documents used]
**Confidence**: [high/medium/low based on context coverage]
Context: {context}
Question: {question}"""
# 3. Prompt with missing-information handling
prompt_honest = """If the context does not contain enough information to
answer completely, state clearly:
- What you can assert with certainty
- What is missing from the context
- Suggestions for obtaining the missing information
Context: {context}
Question: {question}"""
Wat de aanroepparameters betreft, bepalen drie instellingen het gedrag van RAG. Een lage temperature vergrendelt feitelijke output, max_tokens voorkomt antwoorden die uitdijen tot essays, en een conservatieve top_p beperkt het gesamplede vocabulaire tot de meest waarschijnlijke vervolgen.
# For RAG, use a low temperature
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Factual, low creativity
max_tokens=1024, # Limit answer length
top_p=0.95, # Conservative nucleus sampling
)
Belangrijkste punten
- De RAG-prompt injecteert de opgehaalde context vóór de vraag
- Gebruik een lage temperature (0,1–0,3) voor feitelijke antwoorden
- Vraag het model om bronnen te citeren voor traceerbaarheid
- De klasse RAGPipeline kapselt de volledige flow in: retrieve, generate, ask
- Handel gevallen af waarin de context onvoldoende informatie bevat