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 (2 $/1000 Anfragen)
• Self-hosted : cross-encoders ms-marco (kostenlos, gute Qualität)
• Vergleichen Sie die Reranker auf Ihren Daten mit Ailog

Das Problem des Reranking

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

• Falsch-Positive: Einige abgerufene Chunks sind nicht wirklich relevant
• Ranking-Qualität: Die relevantesten Chunks stehen möglicherweise nicht oben
• Anfragespezifische Relevanz: Das initiale Ranking berücksichtigt nicht die Nuancen der Anfrage

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

Retrieval in zwei Schritten

Anfrage → [Schritt 1: Retrieval] → 100 Kandidaten
        → [Schritt 2: Reranking] → 10 beste Ergebnisse
        → [Schritt 3: Generierung] → Antwort

Warum zwei Stufen?

• Retrieval : Schnell, skaliert auf Millionen/Milliarden Dokumente
• Reranking : Teuer aber präzise, nur auf einer kleinen Kandidatenmenge
• Das Beste aus beidem: Geschwindigkeit + Qualität

Reranking-Ansätze

Cross-Encoder-Modelle

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

Warum Cross-Encoder besser sind:

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

Warum man sie nicht für das Retrieval verwendet:

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

Beliebte Cross-Encoder-Modelle

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]

Eigenschaften:

• Größe: 80MB
• Geschwindigkeit: ~50ms pro Batch
• Qualität: Gut für Englisch
• Training: Auf MS MARCO trainiert

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

Implementierung

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]

LLM-basiertes Reranking

Ein LLM verwenden, um Relevanz zu beurteilen.

Binäre Relevanz

Das LLM fragen, ob ein Dokument relevant ist.

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

    for doc in documents:
        prompt = f"""Ist dieses Dokument relevant für die Anfrage?

Anfrage: {query}

Dokument: {doc}

Antworte nur mit 'yes' oder 'no'."""

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

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

    return relevant_docs

Relevanzbewertung

Numerische Relevanzscores erhalten.

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

    for doc in documents:
        prompt = f"""Bewerte die Relevanz dieses Dokuments für die Anfrage auf einer Skala von 1-10.

Anfrage: {query}

Dokument: {doc}

Relevanzscore (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]

Vergleichendes Ranking

Dokumente paarweise oder als Batch vergleichen.

DEVELOPERpython
def llm_rerank_comparative(query, documents, llm):
    prompt = f"""Ordne diese Dokumente nach Relevanz für die Anfrage.

Anfrage: {query}

Dokumente:
{format_documents(documents)}

Gib das Ranking an (vom relevantesten zum am wenigsten relevanten):"""

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

    return ranked_docs

Vorteile:

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

Nachteile:

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

Verwenden wenn:

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

Cohere Rerank API

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-v3.5"
    )

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

Modelle:

• rerank-v3.5: Mehrsprachig (mehr als 100 Sprachen)
• rerank-v4.0-pro / rerank-v4.0-fast: Neueste mehrsprachige Modelle (Qualität / niedrige Latenz)

Preise:

• 2,00 $ pro 1000 Suchen (rerank-v3.5); rerank-v4.0: 2,00–2,50 $ (Stand: Juli 2026)

Vorteile:

• Verwalteter Service
• Hohe Qualität
• Mehrsprachig

Nachteile:

• 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]]

Vorteile:

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

Hybrides Reranking

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
        }

    # Scores von verschiedenen Modellen holen
    vector_scores = get_vector_scores(query, documents)
    bm25_scores = get_bm25_scores(query, documents)
    ce_scores = get_cross_encoder_scores(query, documents)

    # Scores auf [0, 1] normalisieren
    vector_scores = normalize(vector_scores)
    bm25_scores = normalize(bm25_scores)
    ce_scores = normalize(ce_scores)

    # Gewichtete Kombination
    final_scores = (
        weights['vector_score'] * vector_scores +
        weights['bm25_score'] * bm25_scores +
        weights['cross_encoder'] * ce_scores
    )

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

Reranking-Strategien

Top-K Reranking

Nur die besten Kandidaten des initialen retrieval nach-ranken.

DEVELOPERpython
# Top 20 abrufen, neu ranken für Top 5
candidates = retriever.retrieve(query, k=20)
reranked = reranker.rerank(query, candidates, top_n=5)

Parameter:

• Abrufen: 3-5x des finalen k
• Reranker: finales k erforderlich

Beispiel:

• Bedarf: 5 finale Ergebnisse
• 20 Kandidaten abrufen
• Auf Top 5 re-ranken

Kaskaden-Reranking

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

Verwenden wenn:

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

Anfrageadaptives Reranking

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)

Leistungsoptimierung

Batch-Verarbeitung

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)

Caching

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]

Asynchrones Reranking

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)

Bewertung

Metriken

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

A/B-Tests

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

Kosten-Nutzen-Analyse

Best Practices

1. Immer mehr abrufen als benötigt: 3-5x des finalen k abrufen
2. Mit Cross-Encoder beginnen: MiniLM ist ein guter Standard
3. Auswirkung messen: A/B-Test Reranking vs. kein Reranking
4. Abrufmenge anpassen: Kosten und Recall ausbalancieren
5. Latenzbudget beachten: Reranking fügt 50-500ms hinzu
6. Kosten überwachen: LLM-Reranking kann bei Skalierung teuer werden

Einen Reranker auswählen

Prototyping:

• cross-encoder/ms-marco-MiniLM-L6-v2
• Einfach zu verwenden, gute Qualität

Produktion (Kostensensitiv):

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

Produktion (Qualitätsfokus):

• Cohere Rerank API
• Maximale Qualität, verwaltet

Mehrsprachig:

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

Maximale Qualität (Budget vorhanden):

• LLM-basiertes Reranking
• GPT-4, Claude für die besten Ergebnisse

Expertentipp von Ailog: Reranking hat hohen Impact, ist aber nicht die erste Priorität. Beginnen Sie damit, Ihr Chunking, Ihre Embeddings und Ihr Retrieval richtig zu machen - das ist das Fundament. Sobald Sie ein funktionierendes RAG-System haben, ist Reranking der einfachste Weg, 10-25% zusätzliche Präzision zu gewinnen. Starten Sie mit der Cohere Rerank API für Verbesserungen ohne Konfiguration. Wir haben Reranking in der Produktion an einem Nachmittag hinzugefügt und sofort weniger Halluzinationen und bessere Antwortqualität beobachtet.

Reranking auf Ailog testen

Vergleichen Sie Reranking-Modelle ohne Konfiguration:

Die Ailog-Plattform bietet:

• Cohere Rerank, Cross-Encoder, LLM-Reranking
• Qualitätsvergleich nebeneinander
• Latenz- und Kostenanalyse
• A/B-Tests mit echten Anfragen

Testen Sie Reranking kostenlos →

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 2$ 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.

Nächste Schritte

Mit optimiertem Retrieval und Reranking ist es entscheidend, die Performance zu messen. Der nächste Leitfaden behandelt die Metriken und Bewertungsmethoden zur Beurteilung der RAG-Systemqualität.