Reranking: de relevantie verbeteren
Op deze pagina
Doelstellingen
- Begrijpen waarom reranking de resultaten verbetert
- Een reranker implementeren met behulp van een cross-encoder
- Reranking integreren in een RAG-pipeline
Het probleem van de bi-encoder
Alle zoekopdrachten die u tot nu toe hebt gebouwd, vertrouwen op een bi-encoder: de query en de documenten worden afzonderlijk gecodeerd en vervolgens vergeleken via een dot product. Dit maakt zoeken bliksemsnel mogelijk, zelfs bij een miljoen chunks, omdat de corpusvectoren eenmalig zijn berekend. Het is echter ook de oorzaak van onnauwkeurigheid, omdat het model de query en het document nooit tegelijk ziet: het moet elke tekst samenvatten tot een vector zonder te weten wat er later precies gevraagd zal worden.
Een cross-encoder, ook wel een reranker genoemd, neemt het paar (query, document) als invoer en produceert een veel fijnmazigere relevantiescore. Het leest beide teksten gezamenlijk en kan bijvoorbeeld detecteren dat een document wel over het onderwerp gaat, maar dan in een tegengestelde betekenis. Deze winst heeft een prijs: het model moet elk document individueel verwerken, waardoor het ondoenlijk is om dit op het volledige corpus toe te passen. De oplossing is om het model daar in te zetten waar het kosteneffectief is: bij een kleine selectie kandidaten die al zijn voor geselecteerd.
Vandaar de tweefasen-pipeline, waarbij elk model doet waar het goed in is: de snelle versmalt het veld, de precieze maakt de definitieve selectie.
Query → Bi-encoder → Top 50 Kandidaten → Cross-encoder → Top 5 Resultaten
Reranking met Cohere
Cohere biedt via een API een hoogwaardige reranker aan, waardoor u geen eigen model hoeft te hosten. De onderstaande functie koppelt de twee stappen: eerst worden twintig kandidaten opgehaald via vectorovereenkomst, vervolgens vraagt u rerank-v3.5 om er slechts vijf over te houden. Let op het veld index_original dat in het resultaat behouden blijft: de reranker geeft posities terug ten opzichte van de kandidatenlijst, en u hebt deze nodig om terug te映射en naar het daadwerkelijke document in uw corpus.
import cohere
from openai import OpenAI
co = cohere.Client(api_key="your-cohere-key")
openai_client = OpenAI()
def search_and_rerank(
question: str,
documents: list[str],
embeddings_corpus,
k_retrieval: int = 20,
k_final: int = 5
) -> list[dict]:
"""Semantisch zoeken + reranking."""
# Stap 1: Snelle retrieval (bi-encoder)
query_emb = openai_client.embeddings.create(
input=question,
model="text-embedding-3-large"
).data[0].embedding
import numpy as np
scores = embeddings_corpus @ np.array(query_emb)
top_indices = np.argsort(scores)[-k_retrieval:][::-1]
candidates = [documents[i] for i in top_indices]
# Stap 2: Reranking (cross-encoder)
rerank_response = co.rerank(
query=question,
documents=candidates,
top_n=k_final,
model="rerank-v3.5"
)
return [
{
"text": candidates[r.index],
"rerank_score": r.relevance_score,
"original_index": int(top_indices[r.index])
}
for r in rerank_response.results
]
Reranking met een LLM
Als u liever geen extra provider aan uw architectuur toevoegt—vanwege contractuele redenen, data-localisatie of simpelweg facturering—kan een LLM dat u al gebruikt deze rol invullen. U stuurt de vraag en een document, vraagt om een score van 0 tot 10 en sorteert daarop. Door de temperatuur op nul te zetten en max_tokens terug te brengen tot vijf, zorgt u voor een deterministische en goedkope output; de try/except vangt gevallen op waarin het model iets anders dan een getal teruggeeft.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Gebruikt een LLM om relevantie te scoren."""
scores = []
for i, doc in enumerate(candidates):
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"On a scale of 0 to 10, how relevant is this document "
f"for answering the question?\n\n"
f"Question: {question}\n\n"
f"Document: {doc}\n\n"
f"Respond only with a number between 0 and 10."
)
}],
temperature=0,
max_tokens=5
)
try:
score = float(response.choices[0].message.content.strip())
except ValueError:
score = 0.0
scores.append({"index": i, "text": doc, "score": score})
scores.sort(key=lambda x: x["score"], reverse=True)
return scores[:k]
Deze versie kost één call per kandidaat, wat neerkomt op twintig calls en evenveel cumulatieve latentie voor één gebruikersvraag. In de praktijk is dit onhaalbaar in een interactieve interface. In plaats daarvan vragen we het model om alle documenten in één keer te rangschikken. We presenteren elke kandidaat, ingekort tot 200 tekens en genummerd, en verwachten alleen een lijst met indices terug.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Reranking in één enkele LLM-call."""
formatted_docs = "\n".join(
f"[{i}] {doc[:200]}" for i, doc in enumerate(candidates)
)
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Rank these documents by relevance to the question. "
f"Return the indices of the {k} most relevant "
f"documents, separated by commas, from most to "
f"least relevant.\n\n"
f"Question: {question}\n\n"
f"Documents:\n{formatted_docs}\n\n"
f"Indices (e.g., 3,1,7,0,5):"
)
}],
temperature=0,
max_tokens=50
)
indices_str = response.choices[0].message.content.strip()
return [int(i.strip()) for i in indices_str.split(",")][:k]
Integratie in de RAG-pipeline
In een volledige pipeline past reranking tussen retrieval en generatie, zonder dat er verder iets verandert. Het cruciale punt in de onderstaande klasse is de drempelwaarde van 0,3 op relevance_score: hiermee kunnen er minder dan vijf contexten worden teruggegeven wanneer geen enkele kandidaat echt relevant is, in plaats van de generator ruis te voeren. Vaak elimineert deze filter, meer dan de reranking zelf, gehallucineerde antwoorden.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Brede retrieval
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Reranking
candidate_docs = [chunks[i]["text"] for i in candidates]
reranked = self.co.rerank(
query=question,
documents=candidate_docs,
top_n=5,
model="rerank-v3.5"
)
# 3. Selecteer de besten
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Relevantiedrempel
]
# 4. Genereer het antwoord
return self.generate(question, contexts)
Impact van reranking
| Metric | Zonder reranking | Met reranking | Winst |
|---|---|---|---|
| Recall@5 | 0,72 | 0,72 | = |
| Precision@5 | 0,58 | 0,78 | +34% |
| MRR | 0,65 | 0,82 | +26% |
Deze cijfers laten precies zien wat een reranker doet. Recall verandert niet, en dat is logisch: de kandidaten zijn dezelfde, en de cross-encoder kan een document niet redden dat de bi-encoder niet naar boven heeft gehaald. Precision en MRR verbeteren echter aanzienlijk, omdat het juiste document van de zesde naar de eerste plaats schuift. Praktisch gevolg: als uw recall slecht is, redt reranking u niet; u moet eerst de retrieval verbreden of de chunking herzien.
Belangrijkste punten
- Reranking herschikt kandidaten met een preciezer model
- Typische pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
- Cohere rerank-v3.5 is een kant-en-klare oplossing
- Een LLM kan als reranker dienen als u een afhankelijkheid wilt vermijden
- De winst in precision is aanzienlijk (doorgaans 20–35%)