Promptning med informationshämtning
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation:
temperatureochtop_paccepteras endast med ett resonemangsarbete (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Promptning med informationshämtning
Promptning med informationshämtning (Retrieval-Augmented Prompting, RAP) kombinerar dokumentsökning med promptning för att förse modellen med relevant och aktuell kontext. Det är den naturliga utvecklingen av förankring: istället för att manuellt mata in kontext automatiserar du sökningen efter relevanta passager inför varje LLM-anrop.
Skillnaden blir uppenbar vid skalning. Att manuellt klistra in tre användbara stycken från din dokumentation fungerar för en demo, men när din dokumentationsbas växer till några hundra sidor och frågorna strömmar in, vet ingen längre vilka passager som ska klistras in. RAP delegerar detta val till en automatisk komponent som körs före varje generering, vars enda uppgift är att hitta vad som ska placeras i prompten.
Arkitekturen för ett RAP-system
En RAP-pipeline delas upp i tre steg som opererar med olika hastighet och kostnad. Indexering transformerar dina dokument till vektorembeddings; detta sker en gång, offline, och omvandlar varje dokument till en numerisk vektor som kodar dess betydelse, lagrad tillsammans med originaltexten. Hämtning (retrieval) körs däremot vid varje fråga: du transformerar frågan till en vektor med samma embedding-modell och söker sedan efter de närmaste dokumentvektorerna. Slutligen är augmentering bara vanlig promptning – du bygger en systemprompt som innehåller de hämtade passagerna och instruerar modellen att inte gå utanför detta omfång.
Kom ihåg denna uppdelning: allt som är dyrt sker under indexering, där du har råd att vara kräsen, medan allt som upprepas för varje fråga måste vara snabbt. Koden nedan implementerar de två första stegen med cosinussimilaritet som närhetsmått.
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]]
Kompletta pipelinen
Genom att sätta ihop dessa byggstenar får du en klass som ryms på cirka trettio rader. De flesta besluten fattas i den genererade systemprompten, och det lönar sig att läsa den rad för rad. Modellen får först order om att svara ENDAST utifrån de tillhandahållna passagerna, vilket begränsar hallucinerade svar när dokumentationen är tyst. Därefter får den instruktionen att citera passagens nummer för varje påstående, och det är detta som gör verifiering möjlig: en granskare kan spåra tillbaka till källan vid en första anblick. En temperature på 0,1 fullbordar setupen – för ett svar förankrat i dokument är kreativitet en bugg.
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: att dela upp dokument
Att dela upp dokument i bitar (chunks) är avgörande för kvaliteten på hämtningen. Om bitarna är för stora drunknar relevant information; är de för små förloras kontexten. En API-manual uppdelad i block om tio sidor kommer alltid att returnera samma generiska block, oavsett vilken fråga som ställs. Delas den upp i isolerade meningar returneras en mening som börjar med “denna metod” utan att modellen vet vilken metod som avses. Överlappning motverkar specifikt denna risk: varje bit upprepar slutet av den föregående, så information som sträcker sig över en gräns förblir läsbar från åtminstone ett håll.
När dina dokument har en rubrikstruktur är chunking baserad på sektioner nästan alltid överlägsen chunking med fast storlek: en sektion om “Autentisering” förblir intakt, med sin introduktion och sina exempel.
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
Avancerade hämtstrategier
Omrangordning (Reranking)
Efter den initiala hämtningen använder du LLM:n för att ordna om resultaten. Logiken är den hos en tratt: vektorsökning är snabb men approximativ och tar fram ett dussin plausibla kandidater; modellen, som är långsammare men mer nyanserad, läser om dessa kandidater med kännedom om frågan och rankar dem. Du behåller sedan bara toppen av listan för generering. Vinsten är mest synlig vid frågor där flera passager handlar om samma ämne men bara en faktiskt svarar på frågan – tre sektioner nämner ordet “kvot”, men bara en förklarar hur man höjer 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
Hypotetisk dokumentembedding (HyDE)
Generera ett idealiskt hypotetiskt dokument och sök sedan efter liknande dokument. Problemet denna teknik löser är obalans i ordval: en fråga ställd på vardagsspråk ser inte, vektormässigt, ut som ett stycke teknisk dokumentation. Genom att först be modellen skriva det svar den föreställer sig får du en text skriven i samma register som dina dokument, och det är denna text du använder som sökfråga. Det spelar ingen roll om det hypotetiska stycket innehåller approximationer: det används aldrig som svar, bara som en sond.
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)
Använda OpenAI:s inbyggda filsökning
För snabb implementering erbjuder API:t integrerad hämtning. Du laddar upp filen, skapar en vektorbutik, bifogar filen till den och deklarerar verktyget file_search i anropet: chunking, embedding och sökning hanteras serversidan. Detta är rätt val när dina dokument är standardiserade och du inte bryr dig om var datan lagras. Den egna pipelinen behåller fördelen så snart du behöver bemästra chunking, vara värd för indexet själv eller koppla in specifik omrangordning.
# 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]
}]
)
Etablera en baslinje
Ta fem till tio sidor teknisk dokumentation och implementera hela pipelinen, från chunking till generering. Skriv tio frågor vars svar finns i dokumenten, kör pipelinen på var och en, och upprepa sedan med omrangordning aktiverad: det är genom att observera vid vilka frågor rankingen ändras som du förstår vad vektorsökning ensam missar. Avsluta med att mäta procentandelen korrekt förankrade svar, de där varje påstående faktiskt refererar till en tillhandahållen passage. Denna siffra är din utgångspunkt; alla efterföljande optimeringar kommer att bedömas mot den, inte mot intrycket från två eller tre slumpmässigt lästa svar.
Viktiga punkter
- RAP automatiserar injiceringen av relevant kontext i prompten
- Chunking är kritiskt: experimentera med olika storlekar
- Omrangordning med LLM förbättrar relevansen avsevärt
- HyDE är användbart när frågan skiljer sig kraftigt från dokumentens ordval
- OpenAI File Search förenklar implementering för standardfall