Reranking RAG : +40% Genauigkeit mit Cross-Encoders (Leitfaden 2025)

TL;DR

• Reranking = Zweiter Bewertungsdurchlauf der abgerufenen Docs für bessere Genauigkeit
• Cross-encoders bringen 10–25% Präzisionsverbesserung gegenüber reiner retrieval
• API Cohere Rerank : Einfachste Option (1 $/1000 Anfragen)
• Self-hosted : cross-encoders ms-marco (kostenlos, gute Qualität)
• Comparez les rerankers sur vos données avec Ailog

Le Problème du Reranking

Initial retrieval (Vektor-Suche, BM25) wirft ein weites Netz, um potenziell relevante Dokumente zurückzuholen. Allerdings:

• Faux positifs : Einige abgerufene Chunks sind nicht wirklich relevant
• Qualité de classement : Die relevantesten Chunks stehen möglicherweise nicht oben
• Pertinence spécifique à la requête : Das initiale Ranking berücksichtigt nicht die Nuancen der Anfrage

Solution : Die Kandidaten mit einem anspruchsvolleren Modell nach-ranken.

Retrieval in zwei Schritten

Requête → [Étape 1: Récupération] → 100 candidats
        → [Étape 2: Reranking] → 10 meilleurs résultats
        → [Étape 3: Génération] → Réponse

Pourquoi deux étapes ?

• Retrieval : Schnell, skaliert auf Millionen/Milliarden Dokumente
• Reranking : Teuer aber präzise, nur auf einer kleinen Kandidatenmenge
• Le meilleur des deux : Geschwindigkeit + Qualität

Approches de Reranking

Modèles Cross-Encoder

Im Gegensatz zu bi-encoders (embedder query und document getrennt), verarbeiten cross-encoders Query und Document zusammen.

Bi-encoder (Retrieval)

DEVELOPERpython
query_emb = embed(query)           # [768]
doc_emb = embed(document)          # [768]
score = cosine(query_emb, doc_emb)  # Similarity

Cross-encoder (Reranking)

DEVELOPERpython
# Gemeinsam verarbeiten
input = f"[CLS] {query} [SEP] {document} [SEP]"
score = model(input)  # Direkter Relevanzscore

Pourquoi les cross-encoders sont meilleurs :

• Attention zwischen den Tokens von Query und Document
• Erfassen Interaktionen auf Wortebene
• Präzisere Relevanzbewertung

Pourquoi ne pas les utiliser pour la récupération :

• Muss jede Query-Document-Paarung bewerten (O(n))
• Zu langsam für große Sammlungen
• Keine vorab berechneten embeddings

Modèles Cross-Encoder Populaires

ms-marco-MiniLM-L6-v2

DEVELOPERpython
from sentence_transformers import CrossEncoder

model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L6-v2')

# Score query-document pairs
scores = model.predict([
    (query, doc1),
    (query, doc2),
    (query, doc3)
])

# Rerank by score
ranked_indices = np.argsort(scores)[::-1]

Caractéristiques :

• Taille : 80MB
• Vitesse : ~50ms par batch
• Qualité : Bonne pour l'anglais
• Entraînement : Entraîné sur MS MARCO

ms-marco-TinyBERT-L2-v2

• Noch kleiner/schneller
• Leichter Qualitätsverlust
• Gut für latenzkritische Anwendungen

mmarco-mMiniLMv2-L12-H384-v1

• Multilingual support
• Performance ähnlich zu englischen Modellen
• Unterstützt mehr als 100 Sprachen

Implémentation

DEVELOPERpython
class RerankedRetriever:
    def __init__(self, base_retriever, reranker_model):
        self.retriever = base_retriever
        self.reranker = CrossEncoder(reranker_model)

    def retrieve(self, query, k=5, rerank_top_n=20):
        # Stage 1: Retrieve more candidates
        candidates = self.retriever.retrieve(query, k=rerank_top_n)

        # Stage 2: Rerank
        pairs = [(query, doc['content']) for doc in candidates]
        scores = self.reranker.predict(pairs)

        # Sort by reranker scores
        ranked_indices = np.argsort(scores)[::-1]
        reranked_docs = [candidates[i] for i in ranked_indices]

        # Return top-k
        return reranked_docs[:k]

Reranking Basé sur LLM

Ein LLM verwenden, um Relevanz zu beurteilen.

Pertinence Binaire

Das LLM fragen, ob ein Dokument relevant ist.

DEVELOPERpython
def llm_rerank_binary(query, documents, llm):
    relevant_docs = []

    for doc in documents:
        prompt = f"""Ce document est-il pertinent pour la requête ?

Requête: {query}

Document: {doc}

Réponds seulement 'yes' ou 'no'."""

        response = llm.generate(prompt, max_tokens=5)

        if 'yes' in response.lower():
            relevant_docs.append(doc)

    return relevant_docs

Notation de la Pertinence

Numerische Relevanzscores erhalten.

DEVELOPERpython
def llm_rerank_score(query, documents, llm):
    scored_docs = []

    for doc in documents:
        prompt = f"""Note la pertinence de ce document pour la requête sur une échelle de 1-10.

Requête: {query}

Document: {doc}

Score de pertinence (1-10):"""

        score = int(llm.generate(prompt, max_tokens=5))
        scored_docs.append((doc, score))

    # Sort by score
    scored_docs.sort(key=lambda x: x[1], reverse=True)
    return [doc for doc, score in scored_docs]

Classement Comparatif

Dokumente paarweise oder als Batch vergleichen.

DEVELOPERpython
def llm_rerank_comparative(query, documents, llm):
    prompt = f"""Classe ces documents par pertinence pour la requête.

Requête: {query}

Documents:
{format_documents(documents)}

Fournis le classement (du plus au moins pertinent):"""

    ranking = llm.generate(prompt)
    ranked_docs = parse_ranking(ranking, documents)

    return ranked_docs

Avantages :

• Sehr präzise
• Kann nuancierte Relevanz erfassen
• Erklärt die Begründung

Inconvénients :

• Teuer (LLM-Aufrufe pro Dokument oder Batch)
• Langsam (Hunderte ms bis Sekunden)
• Kann Kontextfenster überschreiten bei vielen Docs

Utiliser quand :

• Höchste Qualität erforderlich
• Kosten/Latenz akzeptabel
• Kleine Kandidatenmenge (< 10 Docs)

API Cohere Rerank

Managed Reranking-Service.

DEVELOPERpython
import cohere

co = cohere.Client(api_key="your-key")

def cohere_rerank(query, documents, top_n=5):
    response = co.rerank(
        query=query,
        documents=documents,
        top_n=top_n,
        model="rerank-english-v2.0"
    )

    return [doc.document for doc in response.results]

Modèles :

• rerank-english-v2.0 : Anglais
• rerank-multilingual-v2.0 : Plus de 100 langues

Tarification :

• 1,00 $ pour 1000 recherches (en 2025)

Avantages :

• Service géré
• Haute qualité
• Multilingue

Inconvénients :

• API-Latenz
• Laufende Kosten
• Abhängigkeit vom Provider

FlashRank

Effizientes lokales Reranking.

DEVELOPERpython
from flashrank import Ranker, RerankRequest

ranker = Ranker(model_name="ms-marco-MultiBERT-L-12")

def flashrank_rerank(query, documents, top_n=5):
    rerank_request = RerankRequest(
        query=query,
        passages=[{"text": doc} for doc in documents]
    )

    results = ranker.rerank(rerank_request)

    return [r.text for r in results[:top_n]]

Avantages :

• Sehr schnell (optimierte Inferenz)
• Self-hosted
• Keine API-Kosten

Reranking Hybride

Mehrere Signale kombinieren.

DEVELOPERpython
def hybrid_rerank(query, documents, weights=None):
    if weights is None:
        weights = {
            'vector_score': 0.3,
            'bm25_score': 0.2,
            'cross_encoder': 0.5
        }

    # Obtenir les scores de différents modèles
    vector_scores = get_vector_scores(query, documents)
    bm25_scores = get_bm25_scores(query, documents)
    ce_scores = get_cross_encoder_scores(query, documents)

    # Normaliser les scores à [0, 1]
    vector_scores = normalize(vector_scores)
    bm25_scores = normalize(bm25_scores)
    ce_scores = normalize(ce_scores)

    # Combinaison pondérée
    final_scores = (
        weights['vector_score'] * vector_scores +
        weights['bm25_score'] * bm25_scores +
        weights['cross_encoder'] * ce_scores
    )

    # Classer les documents
    ranked_indices = np.argsort(final_scores)[::-1]
    return [documents[i] for i in ranked_indices]

Stratégies de Reranking

Reranking Top-K

Nur die besten Kandidaten des initialen retrieval nach-ranken.

DEVELOPERpython
# Récupérer top 20, reclasser pour obtenir top 5
candidates = retriever.retrieve(query, k=20)
reranked = reranker.rerank(query, candidates, top_n=5)

Paramètres :

• Récupérer : 3–5x des finalen k
• Reranker : finales K erforderlich

Exemple :

• Bedarf: 5 finale Ergebnisse
• Récupérer 20 Kandidaten
• Reclasser auf top 5

Reranking en Cascade

Mehrere Reranking-Stufen mit zunehmender Genauigkeit.

DEVELOPERpython
# Stage 1: Fast retrieval
candidates = fast_retriever.retrieve(query, k=100)

# Stage 2: Fast reranker
reranked_1 = tiny_reranker.rerank(query, candidates, top_n=20)

# Stage 3: Accurate reranker
reranked_2 = large_reranker.rerank(query, reranked_1, top_n=5)

return reranked_2

Utiliser quand :

• Sehr große Kandidatenmengen
• Mehrere Qualitätsstufen erforderlich
• Kosten-/Latenzoptimierung

Reranking Adaptatif à la Requête

Verschiedene Reranker je nach Anfragetyp.

DEVELOPERpython
def adaptive_rerank(query, documents):
    query_type = classify_query(query)

    if query_type == "factual":
        # Schlüsselwortsignale verwenden
        return bm25_rerank(query, documents)

    elif query_type == "semantic":
        # Cross-encoder verwenden
        return cross_encoder_rerank(query, documents)

    elif query_type == "complex":
        # LLM verwenden
        return llm_rerank(query, documents)

Optimisation des Performances

Traitement par Lots

Mehrere Queries effizient nach-ranken.

DEVELOPERpython
# Schlecht: Einer nach dem anderen
for query in queries:
    rerank(query, docs)

# Gut: Batch-Verarbeitung
pairs = [(q, doc) for q in queries for doc in docs]
scores = reranker.predict(pairs, batch_size=32)

Mise en Cache

Reranking-Ergebnisse cachen.

DEVELOPERpython
from functools import lru_cache
import hashlib

def cache_key(query, doc):
    return hashlib.md5(f"{query}:{doc}".encode()).hexdigest()

@lru_cache(maxsize=10000)
def cached_rerank_score(query, doc):
    return reranker.predict([(query, doc)])[0]

Reranking Asynchrone

Reranking-Aufrufe parallelisieren.

DEVELOPERpython
import asyncio

async def async_rerank_batch(query, documents):
    tasks = [
        rerank_async(query, doc)
        for doc in documents
    ]
    scores = await asyncio.gather(*tasks)
    return rank_by_scores(documents, scores)

Évaluation

Métriques

Precision@k : Relevante Docs im Top-k nach Reranking

DEVELOPERpython
def precision_at_k(reranked_docs, relevant_docs, k):
    top_k = set(reranked_docs[:k])
    relevant = set(relevant_docs)
    return len(top_k & relevant) / k

NDCG@k : Normalized Discounted Cumulative Gain

DEVELOPERpython
from sklearn.metrics import ndcg_score

def evaluate_reranking(predictions, relevance_labels, k=5):
    return ndcg_score([relevance_labels], [predictions], k=k)

MRR : Mean Reciprocal Rank

DEVELOPERpython
def mrr(reranked_docs, relevant_docs):
    for i, doc in enumerate(reranked_docs, 1):
        if doc in relevant_docs:
            return 1 / i
    return 0

Tests A/B

Reranking-Strategien vergleichen.

DEVELOPERpython
# Kontrolle: Kein reranking
control_results = retriever.retrieve(query, k=5)

# Behandlung: Mit reranking
treatment_candidates = retriever.retrieve(query, k=20)
treatment_results = reranker.rerank(query, treatment_candidates, k=5)

# Messen: Nutzerzufriedenheit, Qualität der Antwort

Analyse Coût-Bénéfice

Bonnes Pratiques

1. Toujours sur-récupérer pour le reranking : Récupérer 3–5x le k final
2. Commencer avec cross-encoder : MiniLM est un bon défaut
3. Mesurer l'impact : Test A/B reranking vs pas de reranking
4. Ajuster le nombre de récupération : Équilibrer coût et rappel
5. Considérer le budget de latence de requête : Le reranking ajoute 50–500ms
6. Surveiller les coûts : Le reranking LLM peut être coûteux à grande échelle

Choisir un Reranker

Prototypage :

• cross-encoder/ms-marco-MiniLM-L6-v2
• Facile à utiliser, bonne qualité

Production (Sensible aux Coûts) :

• cross-encoder/ms-marco-TinyBERT-L2-v2
• Self-hosted, rapide

Production (Axé Qualité) :

• API Cohere Rerank
• Qualité maximale, géré

Multilingue :

• mmarco-mMiniLMv2-L12-H384-v1
• cross-encoder/mmarco-mMiniLMv2-L12

Qualité Maximale (Budget Disponible) :

• Reranking basé LLM
• GPT-4, Claude pour les meilleurs résultats

Conseil d'Expert d'Ailog : Le reranking a un impact élevé mais n'est pas la première priorité. Commencez par bien faire votre découpage, vos embeddings et votre retrieval - ce sont les fondations. Une fois que vous avez un système RAG fonctionnel, le reranking est le moyen le plus simple de gagner 10–25% de précision supplémentaire. Commencez avec l'API Cohere Rerank pour des gains sans configuration. Nous avons ajouté le reranking en production en un après-midi et avons immédiatement vu moins d'hallucinations et une meilleure qualité de réponse.

Tester le Reranking sur Ailog

Comparez les modèles de reranking sans configuration :

La plateforme Ailog inclut :

• Cohere Rerank, cross-encoders, reranking LLM
• Comparaison de qualité côte à côte
• Analyse de latence et de coût
• Tests A/B avec de vraies requêtes

Testez le reranking gratuitement →

FAQ

Was ist der Unterschied zwischen Reranking und Vektorsuche?

Die Vektorsuche (Retrieval) vergleicht Embeddings, um schnell Kandidaten-Dokumente unter Millionen zu finden. Reranking kommt danach: Es nimmt diese Kandidaten (typischerweise 20-100) und bewertet sie mit einem präziseren Modell (Cross-Encoder) neu, das jedes Anfrage-Dokument-Paar tiefgehend analysiert. Vektorsuche priorisiert Geschwindigkeit, Reranking priorisiert Präzision.

Verlangsamt Reranking die RAG-Antworten?

Ja, Reranking fügt typischerweise 50 bis 500ms Latenz hinzu, abhängig vom Modell und der Anzahl der Dokumente. Ein leichtgewichtiger Cross-Encoder wie TinyBERT fügt ~50ms für 20 Dokumente hinzu. Cohere Rerank fügt ~200ms hinzu (inklusive API-Aufruf). LLM-basiertes Reranking (GPT-4, Claude) kann 1-3 Sekunden hinzufügen. Für die meisten RAG-Anwendungen überwiegt der Qualitätsgewinn diese Verzögerung bei Weitem.

Welchen Reranker sollte man für mehrsprachige Inhalte verwenden?

Für mehrsprachige Projekte verwenden Sie ein auf mehrsprachigen Daten trainiertes Modell wie cross-encoder/mmarco-mMiniLMv2-L12 (Open Source) oder die Cohere Rerank API, die nativ über 100 Sprachen unterstützt. Vermeiden Sie Modelle, die ausschließlich auf englischen MS MARCO-Daten trainiert wurden: Sie verlieren an Qualität bei nicht-englischen Inhalten. Die mMARCO-Modelle wurden speziell auf mehrsprachigen Daten trainiert.

Ist Reranking für ein RAG-System unverzichtbar?

Nein, aber es wird dringend empfohlen. Eine gute RAG-Pipeline ohne Reranking kann korrekt funktionieren, wenn Chunking und Embeddings gut kalibriert sind. Reranking bringt typischerweise 10-25% zusätzliche Präzision und reduziert Halluzinationen. Es ist die Optimierung mit dem besten Aufwand-Wirkung-Verhältnis, sobald die Grundlagen stehen.

Was kostet Reranking in der Produktion?

Self-hosted Cross-Encoder sind kostenlos (ohne GPU-Compute). Cohere Rerank kostet etwa 1$ pro 1.000 Reranking-Anfragen. LLM-basiertes Reranking kostet deutlich mehr (Input-Tokens × Anzahl der Dokumente). Für die Mehrheit der Projekte bieten Cohere Rerank oder ein self-hosted Cross-Encoder das beste Preis-Leistungs-Verhältnis.

Prochaines Étapes

Avec la retrieval et le reranking optimisés, il est crucial de mesurer les performances. Le prochain guide couvre les métriques et méthodologies d'évaluation pour évaluer la qualité du système RAG.