Cross-Encoder Reranking for RAG Precision

Why Cross-Encoders?

Bi-encoders (standard embeddings) encode query and document separately. Cross-encoders process them together - much more accurate but slower.

Bi-encoder: sim(encode(query), encode(doc)) Cross-encoder: score(query + doc together)

Implementation

DEVELOPERpython
from sentence_transformers import CrossEncoder

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

def rerank(query, documents, top_k=5):
    # Create query-document pairs
    pairs = [[query, doc] for doc in documents]
    
    # Score all pairs
    scores = model.predict(pairs)
    
    # Sort by score
    ranked = sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)
    
    return [doc for doc, score in ranked[:top_k]]

# Use it
initial_results = vector_search(query, k=100)
final_results = rerank(query, initial_results, top_k=10)

Best Models (April 2026)

The reranking landscape has evolved dramatically. Here are the current leaders:

API Rerankers (by ELO rating)

Source: Agentset Reranker Leaderboard, April 2026

Self-Hosted Rerankers (by Hit@1 accuracy)

Key insight: model size does not determine quality. GTE-reranker at 149M params matches Nemotron at 1.2B on Hit@1.

What's New

Zerank 2 (ZeroEntropy, 2026)

• Instruction-following: append business context, abbreviations, user preferences
• 100+ languages, cross-lingual support
• Fastest API reranker (265ms) at lowest cost ($0.025/M)

Cohere Rerank 4 Pro (2026)

• +170 ELO improvement over v3.5
• +400 ELO on business/finance tasks
• Multilingual single-model architecture

Jina Reranker v3 (late 2025)

• Listwise reranker: processes query + all candidates in single context window (up to 64 docs)
• 10x smaller than generative listwise rerankers
• BEIR: 61.94 nDCG@10 across 18 languages

Qwen3-Reranker Series (2026)

• Three sizes: 0.6B, 4B, 8B — all Apache 2.0
• 100+ languages, 32K context, code retrieval support
• Best fully open-source reranker option

GTE-reranker-modernbert-base (Alibaba, 2026)

• 149M params, 8192 token context, Flash Attention 2
• The efficiency champion — matches 1B+ models at fraction of the cost

Two-Stage Retrieval

DEVELOPERpython
def two_stage_rag(query, vector_db):
    # Stage 1: Fast bi-encoder retrieval (100 candidates)
    candidates = vector_db.search(
        query_embedding=embed(query),
        k=100
    )
    
    # Stage 2: Slow but accurate cross-encoder reranking
    cross_encoder = CrossEncoder('Alibaba-NLP/gte-reranker-modernbert-base')
    pairs = [[query, doc['content']] for doc in candidates]
    scores = cross_encoder.predict(pairs)
    
    # Return top 10
    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, _ in ranked[:10]]

LLM-as-Reranker: Emerging Trend

Using LLMs as rerankers is gaining traction in 2026:

• RankGPT (GPT-4): best listwise reranker (DL19: 75.59, Covid: 85.51)
• Open-source listwise rerankers now achieve 97% of GPT-4 effectiveness via QLoRA fine-tuning
• FIRST (IBM Research): ranking from first-token logits only, cutting latency by 21-42%
• AFR-Rank: 2.7x efficiency over RankGPT while reducing API costs

LLM rerankers deliver highest quality but at significant latency/cost. Cross-encoders remain the production default for most use cases.

Performance Optimization

Cross-encoders are slow - optimize:

DEVELOPERpython
# Batch processing
def batch_rerank(query, documents, batch_size=32):
    pairs = [[query, doc] for doc in documents]
    all_scores = []
    
    for i in range(0, len(pairs), batch_size):
        batch = pairs[i:i+batch_size]
        scores = model.predict(batch)
        all_scores.extend(scores)
    
    return sorted(zip(documents, all_scores), key=lambda x: x[1], reverse=True)

When to Rerank

Always rerank when:

• Precision is critical
• Cost of false positives is high
• You have compute budget

Skip reranking when:

• Latency < 100ms required
• High QPS (> 1000/sec)
• Budget constrained