Retrieval-augmented prompting
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Using GPT-6 · GPT-5.6 Terra.
Retrieval-augmented prompting
Retrieval-Augmented Prompting (RAP) kombinerer dokumentsøgning med prompting for at give modellen relevant og opdateret kontekst. Det er den naturlige udvikling af „grounding”: i stedet for manuelt at indsætte kontekst, automatiserer du søgningen efter relevante uddrag før hvert LLM-kald.
Forskellen bliver tydelig i stor skala. Det fungerer fint til en demo manuelt at kopiere tre nyttige afsnit fra din dokumentation; men når din dokumentationsbase vokser til flere hundrede sider, og spørgsmål strømmer ind kontinuerligt, ved ingen længere, hvilke uddrag der skal kopieres. RAP overlader dette valg til en automatisk komponent, der køres før hver generering, og hvis eneste rolle er at finde ud af, hvad der skal ind i prompten.
Arkitekturen i et RAP-system
En RAP-pipeline opdeles i tre trin, der opererer med forskellige hastigheder og omkostninger. Indeksering transformerer dine dokumenter til vektorembeddings; dette sker én gang offline og omdanner hvert dokument til en numerisk vektor, der kodifierer dets betydning, gemt sammen med originalteksten. Retrieval kører derimod ved hvert spørgsmål: du transformerer spørgsmålet til en vektor ved hjælp af samme embedding-model og søger derefter efter de tætteste dokumentvektorer. Til sidst er augmentation blot standard prompting – du bygger en systemprompt, der indeholder de hentede uddrag, og instruerer modellen i ikke at gå uden for dette omfang.
Husk denne opdeling: alt det dyre sker under indeksering, hvor du har råd til at være krævende, mens alt, der gentages for hvert spørgsmål, skal være hurtigt. Koden nedenfor implementerer de to første trin ved hjælp af cosinuslighed som nærhedsmål.
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]]
Komplet pipeline
Når du samler disse byggesten, får du en klasse, der fylder omkring tredive linjer. De fleste beslutninger træffes i den genererede systemprompt, og det er værd at læse den linje for linje. Modellen modtager først ordren om KUN at svare ud fra de leverede uddrag, hvilket begrænser hallucinerede svar, når dokumentationen tier stille. Derefter får den instruktionen om at citere uddragsnummeret for hver påstand, og det er dét, der gør verifikation mulig: en anmelder kan spore tilbage til kilden ved et enkelt blik. En temperature på 0,1 fuldender opsætningen – på et svar forankret i dokumenter er kreativitet en fejl.
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: Opdeling af dokumenter
Opdeling af dokumenter i chunks er afgørende for kvaliteten af retrieval. Hvis chunks er for store, drukner de relevante oplysninger; er de for små, mister de kontekst. En API-manual opdelt i blokke på ti sider vil altid returnere den samme generiske blok, uanset hvilket spørgsmål der stilles. Opdelt i isolerede sætninger vil den returnere en sætning, der starter med „denne metode”, uden at modellen ved, hvilken metode der menes. Overlap modvirker specifikt denne risiko: hver chunk gentager slutningen af den foregående, så informationer, der strækker sig over en grænse, forbliver læsbare fra mindst den ene side.
Når dine dokumenter har en overskriftsstruktur, er sections-baseret chunking næsten altid overlegen i forhold til chunking med fast størrelse: en sektion om „Autentificering” forbliver intakt med sin introduktion og sine eksempler.
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
Avancerede retrieval-strategier
Reranking
Efter den indledende retrieval bruger du LLM’en til at omarrangere resultaterne. Logikken er som en tragtsi: vektorsøgning er hurtig, men approksimativ, og finder et dusin plausible kandidater; modellen, som er langsommere, men mere nuanceret, genlæser disse kandidater med kendskab til spørgsmålet og rangerer dem. Derefter beholder du kun toppen af listen til generering. Gevinsten er mest synlig ved spørgsmål, hvor flere uddrag taler om samme emne, men kun ét faktisk svarer på det – tre sektioner nævner ordet „kvote”, men kun én forklarer, hvordan man hæver den.
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)
Generer et ideelt hypotetisk dokument, og søg derefter efter lignende dokumenter. Det problem, denne teknik løser, er uoverensstemmelse i ordforråd: et spørgsmål stillet på hverdagssprog ligner ikke vektormæssigt et afsnit i teknisk dokumentation. Ved først at bede modellen skrive det svar, den forestiller sig, får du en tekst skrevet i samme register som dine dokumenter, og det er denne tekst, du bruger som forespørgsel. Det betyder ikke noget, om det hypotetiske afsnit indeholder unøjagtigheder: det bruges aldrig som svar, kun som 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)
Brug af OpenAIs native File Search
Til hurtig implementering tilbyder API’en integreret retrieval. Du uploader filen, opretter et vector store, knytter filen til det og erklærer værktøjet file_search i kaldet: chunking, embedding og søgning håndteres server-side. Dette er det rigtige valg, når dine dokumenter er standard, og du er ligeglad med, hvor dataene befinder sig. Den hjemmelavede pipeline beholder fordelen, så snart du har brug for at mestre chunking, hoste indekset selv eller tilslutte specifik reranking.
# 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]
}]
)
Etabler en baseline
Tag fem til ti sider teknisk dokumentation og implementer hele pipeline’en, fra chunking til generering. Skriv ti spørgsmål, hvis svar findes i dokumenterne, kør pipeline’en på hvert af dem, og gentag derefter med aktiveret reranking: det er ved at observere, på hvilke spørgsmål rangeringen ændrer sig, at du forstår, hvad vektorsøgning alene går glip af. Afslut med at måle procentdelen af korrekt forankrede svar, dvs. de svar, hvor hver påstand effektivt refererer til et leveret uddrag. Dette tal er dit udgangspunkt; alle efterfølgende optimeringer vil blive bedømt i forhold til dette, ikke i forhold til det indtryk, to eller tre tilfældigt læste svar efterlader.
Vigtige pointer
- RAP automatiserer indsprøjtningen af relevant kontekst i prompten
- Chunking er kritisk: eksperimenter med forskellige størrelser
- Reranking med LLM’en forbedrer relevansen markant
- HyDE er nyttigt, når spørgsmålet afviger meget fra dokumenternes ordforråd
- OpenAI File Search forenkler implementeringen for standardtilfælde