Retrieval-augmented prompting
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(Responses API) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Retrieval-augmented prompting
Retrieval-Augmented Prompting (RAP) combineert documentzoekopdrachten met prompting om het model van relevante, actuele context te voorzien. Het is de natuurlijke evolutie van grounding: in plaats van context handmatig toe te voegen, automatiseert u de zoektocht naar relevante passages vóór elke LLM-aanroep.
Het verschil wordt duidelijk op schaal. Handmatig drie nuttige alinea’s uit uw documentatie plakken werkt voor een demo; maar zodra uw documentatiebasis enkele honderden pagina’s beslaat en vragen continu binnenstromen, weet niemand meer welke passages geplakt moeten worden. RAP delegeert deze keuze aan een automatische component, die vóór elke generatie wordt aangeroepen en als enige taak heeft om te bepalen wat in de prompt moet komen.
Architectuur van een RAP-systeem
Een RAP-pipeline bestaat uit drie stappen die op verschillende snelheden en kosten opereren. Indexering transformeert uw documenten in vector-embeddings; dit gebeurt eenmalig offline, waarbij elk document wordt omgezet in een numerieke vector die de betekenis codeert, opgeslagen naast de originele tekst. Retrieval daarentegen draait bij elke vraag: u transformeert de vraag met hetzelfde embedding-model in een vector en zoekt vervolgens naar de dichtstbijzijnde documentvectoren. Tot slot is augmentatie gewoon standaard prompting: u bouwt een systeemprompt met de opgehaalde passages en instrueert het model om niet buiten dit kader te treden.
Onthoud deze verdeling: alles wat duur is, gebeurt tijdens de indexering, waar u veeleisend kunt zijn, terwijl alles wat voor elke vraag herhaald wordt, snel moet blijven. De onderstaande code implementeert de eerste twee stappen met cosinusgelijkenis als nabijheidsmaatstaf.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Step 1: Generate document embeddings
def embed_texts(texts: list[str]) -> list[list[float]]:
"""Generates embeddings for a list of texts."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=texts
)
return [item.embedding for item in response.data]
# Step 2: Search by cosine similarity
def cosine_similarity(a: list[float], b: list[float]) -> float:
"""Calculates cosine similarity between two vectors."""
a, b = np.array(a), np.array(b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def retrieve(query: str, documents: list[str],
doc_embeddings: list[list[float]],
top_k: int = 3) -> list[str]:
"""Returns the top_k most relevant documents."""
query_emb = embed_texts([query])[0]
scores = [
(i, cosine_similarity(query_emb, doc_emb))
for i, doc_emb in enumerate(doc_embeddings)
]
scores.sort(key=lambda x: x[1], reverse=True)
return [documents[i] for i, _ in scores[:top_k]]
Volledige pipeline
Het samenvoegen van deze bouwstenen levert een klasse op die in ongeveer dertig regels past. De meeste beslissingen vinden plaats in de gegenereerde systeemprompt; het loont de moeite om deze regel voor regel te lezen. Het model ontvangt eerst de opdracht om ALLEEN te antwoorden op basis van de verstrekte passages, wat gehallucineerde antwoorden beperkt wanneer de documentatie geen antwoord biedt. Vervolgens krijgt het de instructie om voor elke bewering het passagenummer te citeren; dit maakt verificatie mogelijk: een reviewer kan in één oogopslag teruggaan naar de bron. Een temperature van 0,1 maakt de opstelling compleet: bij een antwoord dat in documenten verankerd is, is creativiteit een bug.
class RAGPipeline:
"""Minimalist RAP pipeline."""
def __init__(self, documents: list[str]):
self.documents = documents
self.embeddings = embed_texts(documents)
def query(self, question: str, top_k: int = 3) -> str:
"""Answers a question based on the documents."""
# Retrieval
relevant_docs = retrieve(
question, self.documents,
self.embeddings, top_k
)
# Prompt augmentation
context = "\n\n---\n\n".join(
f"[Passage {i+1}]\n{doc}"
for i, doc in enumerate(relevant_docs)
)
system = f"""You are a technical assistant.
Answer ONLY based on the provided passages.
If the passages do not contain the answer, say so.
Cite the passage number for every claim.
RELEVANT PASSAGES:
{context}"""
# Generation
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=question,
temperature=0.1
)
return response.output_text
Chunking: documenten splitsen
Het splitsen van documenten in chunks is cruciaal voor de kwaliteit van de retrieval. Als chunks te groot zijn, verdrinken ze relevante informatie; als ze te klein zijn, verliezen ze context. Een API-handleiding die in blokken van tien pagina’s is gesplitst, zal altijd hetzelfde generieke blok retourneren, ongeacht de gestelde vraag. Gesplitst in geïsoleerde zinnen, zal het een zin retourneren die begint met “deze methode”, zonder dat het model weet welke methode bedoeld wordt. Overlap mitigeert dit risico specifiek: elke chunk herhaalt het einde van de vorige, zodat informatie die over een grens heen loopt, vanaf ten minste één kant leesbaar blijft.
Wanneer uw documenten een kopstructuur hebben, is chunking op basis van secties bijna altijd superieur aan chunking met vaste grootte: een sectie “Authenticatie” blijft intact, met zijn introductie en voorbeelden.
def chunk_document(text: str, chunk_size: int = 500,
overlap: int = 50) -> list[str]:
"""Splits text into chunks with overlap."""
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size - overlap):
chunk = " ".join(words[i:i + chunk_size])
if chunk.strip():
chunks.append(chunk)
return chunks
def chunk_by_sections(text: str) -> list[str]:
"""Splits by sections (Markdown headings)."""
sections = []
current = []
for line in text.split("\n"):
if line.startswith("## ") and current:
sections.append("\n".join(current))
current = [line]
else:
current.append(line)
if current:
sections.append("\n".join(current))
return sections
Geavanceerde retrieval-strategieën
Reranking
Gebruik na de initiële retrieval de LLM om de resultaten opnieuw te ordenen. De logica is die van een trechter: vectorzoekopdrachten zijn snel maar benaderend en halen een dozijn plausibele kandidaten op; het model, langzamer maar genuanceerder, leest deze kandidaten opnieuw met kennis van de vraag en rangschikt ze. U houdt vervolgens alleen de top van de lijst over voor generatie. De winst is het meest zichtbaar bij vragen waar meerdere passages over hetzelfde onderwerp gaan, maar slechts één er daadwerkelijk antwoord op geeft: drie secties noemen het woord “quota”, maar slechts één legt uit hoe u deze kunt verhogen.
def rerank(question: str, passages: list[str]) -> list[str]:
"""Reorders passages by relevance using the LLM."""
prompt = f"""Question: {question}
Here are candidate passages. Rank them from most relevant
to least relevant for answering the question.
Return only the numbers in order (e.g., 3, 1, 2).
{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.0
)
# Parse returned order and reorganize
return response.output_text
Hypothetical Document Embedding (HyDE)
Genereer een ideaal hypothetisch document en zoek vervolgens naar vergelijkbare documenten. Het probleem dat deze techniek oplost, is vocabulaire-mismatch: een vraag die in alledaagse taal is gesteld, ziet er vectorieel niet uit als een alinea technische documentatie. Door het model eerst te vragen het antwoord te schrijven dat het zich voorstelt, krijgt u een tekst die in het register van uw documenten is geschreven, en deze tekst gebruikt u als query. Het maakt niet uit of de hypothetische alinea benaderingen bevat: deze dient nooit als antwoord, alleen als sonde.
def hyde_retrieve(question: str, documents: list[str],
doc_embeddings: list[list[float]]) -> list[str]:
"""Retrieval via HyDE."""
# Generate a hypothetical passage
hypo_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
input=f"Write a short technical paragraph that would perfectly "
f"answer this question: {question}",
temperature=0.5
)
hypothetical_doc = hypo_response.output_text
# Search for documents similar to the hypothetical passage
return retrieve(hypothetical_doc, documents,
doc_embeddings, top_k=3)
Gebruik van OpenAI’s native File Search
Voor snelle implementatie biedt de API geïntegreerde retrieval. U uploadt het bestand, maakt een vectorstore, koppelt het bestand eraan en declareert het hulpmiddel file_search in de aanroep: chunking, embedding en zoeken worden server-side afgehandeld. Dit is de juiste keuze wanneer uw documenten standaard zijn en het u niet uitmaakt waar de data leeft. De zelfgebouwde pipeline behoudt het voordeel zodra u chunking moet beheersen, de index zelf wilt hosten of specifieke reranking wilt integreren.
# Upload file
file = client.files.create(
file=open("documentation.pdf", "rb"),
purpose="assistants"
)
# Create a vector store
vector_store = client.vector_stores.create(
name="Technical Documentation"
)
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file.id
)
# Query with File Search
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Answer based on the provided documentation.",
input="How do I configure authentication?",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store.id]
}]
)
Stel een basislijn vast
Neem vijf tot tien pagina’s technische documentatie en implementeer de volledige pipeline, van chunking tot generatie. Schrijf tien vragen waarvan de antwoorden in de documenten staan, voer de pipeline voor elk uit en herhaal dit vervolgens met ingeschakelde reranking: door te observeren bij welke vragen de rangschikking verandert, begrijpt u wat vectorzoekopdrachten alleen missen. Sluit af door het percentage correct verankerde antwoorden te meten, dat wil zeggen antwoorden waarbij elke bewering effectief verwijst naar een verstrekte passage. Dit cijfer is uw startpunt; alle daaropvolgende optimalisaties worden hieraan getoetst, niet aan de indruk die twee of drie willekeurig gelezen antwoorden achterlaten.
Belangrijkste punten
- RAP automatiseert de injectie van relevante context in de prompt
- Chunking is kritiek: experimenteer met verschillende groottes
- Reranking met de LLM verbetert de relevantie aanzienlijk
- HyDE is nuttig wanneer de vraag sterk afwijkt van het vocabulaire van de documenten
- OpenAI File Search vereenvoudigt de implementatie voor standaardgevallen