Retrieval: Chunking en Ranking
Op deze pagina
Retrieval: Chunking en Ranking
File Search is afhankelijk van een volledige retrieval-pipeline: uw documenten worden opgesplitst in chunks, omgezet in vectoren, geïndexeerd en vervolgens gerangschikt op relevantie wanneer er een query binnenkomt. Inzicht in deze pipeline stelt u in staat de kwaliteit van de respons te optimaliseren.
De Retrieval-pipeline
Wanneer u een bestand uploadt naar een vectoropslag, voert OpenAI automatisch het volgende uit:
- Parsing: Extraheert ruwe tekst uit de bronindeling
- Chunking: Splits de tekst in segmenten van een beheerste grootte
- Embedding: Zet elke chunk om in een vector
- Indexering: Slaat de vectoren op in de vectorindex
Tijdens een query:
- Query Embedding: De vraag wordt omgezet in een vector
- Vector Search: Identificeert de meest vergelijkbare chunks
- Ranking: Rangschikt de resultaten opnieuw op relevantie
- Injectie: Voegt de beste chunks toe aan de context van het model
De Chunking-strategie configureren
Chunking is de instelling die alles andere aanstuurt, en de afweging is eenvoudig. Korte chunks leveren nauwkeurige zoekresultaten op, maar bieden fragmenten die verstoken zijn van context: u vindt de juiste zin, maar verliest de referentie. Lange chunks behouden de context, maar begraven relevante informatie in irrelevante tekst, wat de similariteitsscore verzwakt.
Er is geen universele waarde: de juiste instelling hangt af van uw documentstructuur, zoals samengevat in de onderstaande tabel.
from openai import OpenAI
client = OpenAI()
# Standaardstrategie: auto
vector_store = client.vector_stores.create(
name="legal-base",
chunking_strategy={"type": "auto"}
)
# Aangepaste strategie: kleinere chunks voor hogere precisie
vector_store = client.vector_stores.create(
name="support-faq",
chunking_strategy={
"type": "static",
"static": {
"max_chunk_size_tokens": 400,
"chunk_overlap_tokens": 100
}
}
)
De juiste chunkgrootte kiezen
| Contenttype | max_chunk_size | overlap | Waarom |
|---|---|---|---|
| FAQ, V&A | 200-400 | 50 | Korte, op zichzelf staande antwoorden |
| Technische documentatie | 600-800 | 200 | Paragrafen met context |
| Contracten, juridische teksten | 800-1200 | 300 | Lange, onderling verbonden clausules |
| Broncode | 400-600 | 100 | Functies en klassen |
Impact van overlap
Overlap lost een specifiek probleem op: informatie die over de grens van een chunk heen loopt, zou anders doormidden worden gesneden, waardoor geen van beide helften overeenkomt met de query. Door chunks te laten overlappen, garandeert u dat elke zin intact voorkomt in ten minste één segment. De kosten zijn redundantie: een overlap van 300 tokens op chunks van 800 tokens slaat bijna 40% dubbele tekst op.
# Oorspronkelijke tekst (vereenvoudigd)
# "Clausule 5.1 stelt dat de leverancier binnen 30 dagen moet leveren.
# Bij vertraging gelden boetes van 1% per dag.
# Clausule 5.2 specificeert dat boetes gemaximeerd zijn op 15%."
# Zonder overlap: Clausule 5.1 en boetes kunnen in verschillende chunks terechtkomen
# Met overlap: de link tussen clausule en boetes blijft behouden
Relevantiedrempel en ranking
Ranking bepaalt welke chunks worden behouden. U kunt een filter configureren:
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
}
}]
)
De score_threshold filtert resultaten die onder een bepaalde relevantiedrempel vallen. Een waarde van 0,0 geeft alles terug, terwijl 1,0 te restrictief zou zijn. In de praktijk levert een waarde tussen 0,3 en 0,6 goede resultaten op.
De kwaliteit van retrieval optimaliseren
Documenten voorbereiden
Dit is de meest kosteneffectieve hefboom in deze hele les, en de enige die niets kost aan instellingen: een goed gestructureerd document indexeert goed. Gebruik expliciete koppen, een inleidende zin voor elke sectie en vermijd tabellen die zijn omgezet in een brij van tekst. Omgekeerd zal geen enkele chunking-instelling een PDF redden waarvan de extractie verwarde kolommen oplevert.
# Slecht: Gescande PDF met benaderende OCR
# -> Incoherente chunks, embeddings van lage kwaliteit
# Goed: Gestructureerd document met koppen en secties
# -> Chunks afgestemd op logische secties
# Patroon: Pre-processen voor upload
def prepare_document(raw_text: str) -> str:
"""Schoont en structureert tekst voor indexering."""
# Verwijder repetitieve kopteksten/voetteksten
lines = raw_text.split("\n")
lines = [l for l in lines if not is_header_footer(l)]
# Spaties normaliseren
text = "\n".join(lines)
text = re.sub(r"\n{3,}", "\n\n", text)
return text
Verrijken met metadata
Metadata maakt pre-filtering mogelijk vóór de vectorzoekopdracht, wat de precisie verbetert:
# Uploaden met uitgebreide 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"]
}
)
Kwaliteit van retrieval meten
Zonder meting is elke chunking-instelling slechts intuïtie. Een set van twintig vragen waarvan u het verwachte antwoord en het bijbehorende document kent, volstaat om het proces te objectiveren: wijzig een parameter, voer de testset opnieuw uit en vergelijk. Dit kost weinig werk in vergelijking met urenlang discussiëren over chunkgrootte zonder data.
def evaluate_retrieval(test_questions: list[dict], vs_id: str) -> dict:
"""Evalueert de retrieval-kwaliteit op een testset.
Elk element in test_questions bevat:
- question: de te stellen vraag
- expected_answer: trefwoorden of zinsdelen die in het antwoord worden verwacht
"""
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
Geavanceerde strategieën
Multi-Vector-Store
Query meerdere documentbases parallel:
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
}]
)
Gedecomposeerde queries
Een vraag die meerdere verzoeken bevat, produceert een gemiddelde vector die op geen van alle lijkt, wat leidt tot slechte zoekresultaten voor allemaal. Het opsplitsen in afzonderlijke deelvragen levert aanzienlijk betere resultaten op; dit is hetzelfde principe als bij webzoekopdrachten: een precieze query verslaat een exhaustieve.
def decomposed_search(complex_question: str, vs_id: str) -> str:
"""Splits een complexe vraag op in sub-zoekopdrachten."""
# Stap 1: De vraag decomponeren
decomposition = client.responses.create(
model="gpt-5.6-terra",
input=f"Decompose this question into 2-3 simple sub-questions: {complex_question}",
)
# Stap 2: Zoeken voor elke deelvraag
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)
# Stap 3: Syntheseren
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
Belangrijkste punten
staticchunking met aangepaste grootte en overlap verbetert de precisie- Kleine chunks voor FAQ’s, grote chunks voor juridische documenten
score_thresholdfiltert irrelevante resultaten- Maak uw documenten schoon en structureer ze voor indexering
- Evalueer de retrieval-kwaliteit met een testset