Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Reranking: de relevantie verbeteren

Les 13 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Het probleem van de bi-encoder
  3. Reranking met Cohere
  4. Reranking met een LLM
  5. Integratie in de RAG-pipeline
  6. Impact van reranking
  7. Belangrijkste punten

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

MetricZonder rerankingMet rerankingWinst
Recall@50,720,72=
Precision@50,580,78+34%
MRR0,650,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%)