Retrieval: Chunking och rangordning
På denna sida
Retrieval: Chunking och rangordning
File Search bygger på en komplett retrieval-pipeline: dina dokument delas upp i bitar (chunks), vektoriseras, indexeras och rangordnas sedan efter relevans när en fråga ställs. Att förstå denna pipeline gör att du kan optimera svarskvaliteten.
Retrieval-pipelinen
När du laddar upp en fil till ett vektorlager utför OpenAI automatiskt följande steg:
- Parsing: Extraherar råtext från källformatet
- Chunking: Delar upp texten i segment med kontrollerad storlek
- Embedding: Vektoriserar varje bit
- Indexering: Lagrar vektorerna i vektorindexet
Vid frågetillfället sker följande:
- Frågeembedding: Frågan vektoriseras
- Vektorsökning: Identifierar de bitar som ligger närmast
- Rangordning: Rangordnar resultaten på nytt efter relevans
- Inmatning: Matar in de bästa bitarna i modellens kontext
Konfigurera chunking-strategin
Chunking är den inställning som styr allt annat, och avvägningen är enkel. Korta bitar ger precisa sökresultat men levererar utdrag som saknar kontext – du hittar rätt mening men tappar referensramen. Långa bitar bevarar kontexten men begraver relevant information i irrelevant text, vilket försvagar likhetspoängen.
Det finns inget universellt värde: rätt inställning beror på din dokumentstruktur, precis som sammanfattas i tabellen nedan.
from openai import OpenAI
client = OpenAI()
# Standardstrategi: auto
vector_store = client.vector_stores.create(
name="legal-base",
chunking_strategy={"type": "auto"}
)
# Anpassad strategi: mindre bitar för högre precision
vector_store = client.vector_stores.create(
name="support-faq",
chunking_strategy={
"type": "static",
"static": {
"max_chunk_size_tokens": 400,
"chunk_overlap_tokens": 100
}
}
)
Välja rätt bitstorlek
| Innehållstyp | max_chunk_size | overlap | Varför |
|---|---|---|---|
| FAQ, Q&A | 200-400 | 50 | Korta, fristående svar |
| Teknisk dokumentation | 600-800 | 200 | Stycken med kontext |
| Avtal, juridiska texter | 800-1200 | 300 | Långa, sammanlänkade klausuler |
| Källkod | 400-600 | 100 | Funktioner och klasser |
Påverkan av överlappning
Överlappning löser ett specifikt problem: information som sträcker sig över gränsen mellan två bitar skulle annars klippas itu, vilket innebär att ingen av halvorna matchar frågan. Genom att låta bitarna överlappa garanterar du att varje mening förekommer intakt i minst ett segment. Kostnaden är redundans – en överlappning på 300 token för bitar på 800 token lagrar nästan 40 % duplicerad text.
# Originaltext (förenklad)
# "Klausul 5.1 anger att leverantören måste leverera inom 30 dagar.
# Vid försening tillämpas vite på 1 % per dag.
# Klausul 5.2 specificerar att vitet är taket vid 15 %."
# Utan överlappning: Klausul 5.1 och vite kan hamna i olika bitar
# Med överlappning: länken mellan klausul och vite bevaras
Relevanströskel och rangordning
Rangordningen avgör vilka bitar som behålls. Du kan konfigurera ett filter:
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the return policy?",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store.id],
"max_num_results": 10,
"ranking_options": {
"ranker": "auto",
"score_threshold": 0.5
}
}]
)
score_threshold filtrerar bort resultat under en viss relevanströskel. Ett värde på 0,0 returnerar allt, medan 1,0 skulle vara alltför restriktivt. I praktiken ger värden mellan 0,3 och 0,6 bra resultat.
Optimera retrieval-kvalitet
Förbereda dokument
Detta är den mest kostnadseffektiva hävstången i hela lektionen, och den enda som inte kostar något i inställningar: ett välstrukturerat dokument indexeras bra. Använd tydliga rubriker, en inledande mening för varje avsnitt och undvik tabeller som omvandlats till textmos. Omvänt kommer ingen chunking-inställning att rädda en PDF vars extrahering producerar sammanflätade kolumner.
# Dåligt: Skannad PDF med ungefärlig OCR
# -> Inkoherenta bitar, embedding av låg kvalitet
# Bra: Strukturerat dokument med rubriker och avsnitt
# -> Bitar anpassade efter logiska sektioner
# Mönster: Förbehandla före uppladdning
def prepare_document(raw_text: str) -> str:
"""Rensar och strukturerar text före indexering."""
# Ta bort upprepade sidhuvuden/sidfötter
lines = raw_text.split("\n")
lines = [l for l in lines if not is_header_footer(l)]
# Normalisera mellanrum
text = "\n".join(lines)
text = re.sub(r"\n{3,}", "\n\n", text)
return text
Berika med metadata
Metadata möjliggör förfiltrering före vektorsökning, vilket förbättrar precisionen:
# Ladda upp med rik metadata
documents = [
{"file": "hr-policy-2026.pdf", "department": "hr", "type": "policy", "year": 2026},
{"file": "supplier-contract-a.pdf", "department": "procurement", "type": "contract", "year": 2026},
{"file": "it-security-guide.pdf", "department": "it", "type": "guide", "year": 2025},
]
for doc in documents:
with open(doc["file"], "rb") as f:
file_obj = client.files.create(file=f, purpose="assistants")
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file_obj.id,
attributes={
"department": doc["department"],
"document_type": doc["type"],
"year": doc["year"]
}
)
Mäta retrieval-kvalitet
Utan mätning är varje chunking-inställning bara intuition. En uppsättning på tjugo frågor där du känner till det förväntade svaret och vilket dokument det finns i räcker för att objektivisera processen: ändra en parameter, kör testsviten på nytt och jämför. Detta är lite arbete jämfört med timmar spenderade på att debattera bitstorlek utan data.
def evaluate_retrieval(test_questions: list[dict], vs_id: str) -> dict:
"""Utvärderar retrieval-kvalitet på en testuppsättning.
Varje element i test_questions innehåller:
- question: frågan som ska ställas
- expected_answer: nyckelord eller fraser som förväntas i svaret
"""
results = {"total": 0, "relevant": 0, "irrelevant": 0}
for test in test_questions:
response = client.responses.create(
model="gpt-5.6-terra",
input=test["question"],
tools=[{
"type": "file_search",
"vector_store_ids": [vs_id],
"max_num_results": 5
}]
)
answer = response.output_text.lower()
found_keywords = sum(
1 for word in test["expected_answer"]
if word.lower() in answer
)
results["total"] += 1
if found_keywords >= len(test["expected_answer"]) * 0.5:
results["relevant"] += 1
else:
results["irrelevant"] += 1
results["relevance_rate"] = results["relevant"] / results["total"]
return results
Avancerade strategier
Multi-Vector-Store
Fråga flera dokumentbaser parallellt:
response = client.responses.create(
model="gpt-5.6-terra",
input="Compare our HR policy with legal obligations",
tools=[{
"type": "file_search",
"vector_store_ids": [
vs_internal_policies,
vs_legal_texts
],
"max_num_results": 15
}]
)
Dekomponerade frågor
En fråga som innehåller flera begäranden producerar en genomsnittlig vektor som inte liknar någon av dem, vilket leder till dåliga sökresultat för alla. Att bryta ner den i separata delfrågor ger betydligt bättre resultat – detta är samma princip som vid webbsökning: en precis fråga slår en uttömmande.
def decomposed_search(complex_question: str, vs_id: str) -> str:
"""Dekomponerar en komplex fråga i delsökningar."""
# Steg 1: Dekomponera frågan
decomposition = client.responses.create(
model="gpt-5.6-terra",
input=f"Decompose this question into 2-3 simple sub-questions: {complex_question}",
)
# Steg 2: Sök efter varje delfråga
sub_results = []
for sub_q in decomposition.output_text.split("\n"):
if sub_q.strip():
r = client.responses.create(
model="gpt-5.6-terra",
input=sub_q.strip(),
tools=[{"type": "file_search", "vector_store_ids": [vs_id]}]
)
sub_results.append(r.output_text)
# Steg 3: Syntetisera
synthesis = client.responses.create(
model="gpt-5.6-terra",
input=f"Original question: {complex_question}\n\n"
f"Intermediate results:\n" + "\n---\n".join(sub_results) +
"\n\nSynthesize a complete and coherent answer."
)
return synthesis.output_text
Viktiga punkter
staticchunking med anpassad storlek och överlappning förbättrar precisionen- Små bitar för FAQ, stora bitar för juridiska dokument
score_thresholdfiltrerar bort irrelevanta resultat- Rensa och strukturera dina dokument före indexering
- Utvärdera retrieval-kvalitet med en testuppsättning