RAG Rerankers

Reranking components for improving retrieval quality by re-scoring and reordering documents based on query-document relevance using advanced models and techniques.

Core Classes

CrossEncoderReranker

Description: Cross-encoder based reranker for high-quality relevance scoring

Parameters:

• model_name (str): HuggingFace model name (default: "cross-encoder/ms-marco-MiniLM-L-6-v2")
• max_length (int): Maximum sequence length (default: 512)
• batch_size (int): Batch size for processing (default: 32)
• device (str): Device for computation ("cpu", "cuda", "auto")

Returns: CrossEncoderReranker instance

Example:

from recoagent.rag.rerankers import CrossEncoderReranker

# Create cross-encoder reranker
reranker = CrossEncoderReranker(
    model_name="cross-encoder/ms-marco-MiniLM-L-6-v2",
    max_length=512,
    batch_size=16,
    device="cuda"
)

# Rerank documents
query = "What is machine learning?"
documents = [
    "Machine learning is a subset of artificial intelligence",
    "Deep learning uses neural networks for pattern recognition",
    "Natural language processing deals with text understanding"
]

reranked_results = reranker.rerank(query, documents, top_k=5)

BiEncoderReranker

Description: Bi-encoder based reranker for efficient similarity scoring

Parameters:

• model_name (str): HuggingFace model name
• similarity_metric (str): Similarity metric ("cosine", "dot", "euclidean")
• normalize_embeddings (bool): Normalize embeddings (default: True)

Returns: BiEncoderReranker instance

Example:

from recoagent.rag.rerankers import BiEncoderReranker

# Create bi-encoder reranker
reranker = BiEncoderReranker(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    similarity_metric="cosine",
    normalize_embeddings=True
)

# Rerank documents
reranked_results = reranker.rerank(query, documents, top_k=5)

HybridReranker

Description: Combines multiple reranking methods for optimal results

Parameters:

• rerankers (List[BaseReranker]): List of rerankers to combine
• fusion_method (str): Fusion method ("weighted", "rank_fusion", "reciprocal")
• weights (List[float]): Weights for each reranker

Returns: HybridReranker instance

Example:

from recoagent.rag.rerankers import HybridReranker, CrossEncoderReranker, BiEncoderReranker

# Create individual rerankers
cross_encoder = CrossEncoderReranker(model_name="cross-encoder/ms-marco-MiniLM-L-6-v2")
bi_encoder = BiEncoderReranker(model_name="sentence-transformers/all-MiniLM-L6-v2")

# Create hybrid reranker
hybrid_reranker = HybridReranker(
    rerankers=[cross_encoder, bi_encoder],
    fusion_method="weighted",
    weights=[0.7, 0.3]
)

# Rerank with hybrid approach
reranked_results = hybrid_reranker.rerank(query, documents, top_k=5)

RerankResult

Description: Represents a reranked result with improved scoring

Fields:

• chunk_id (str): Unique chunk identifier
• content (str): Document content
• metadata (Dict): Document metadata
• original_score (float): Original retrieval score
• reranked_score (float): Reranked score
• reranking_method (str): Method used for reranking

Usage Examples

Basic Cross-Encoder Reranking

from recoagent.rag.rerankers import CrossEncoderReranker

# Create reranker
reranker = CrossEncoderReranker(
    model_name="cross-encoder/ms-marco-MiniLM-L-6-v2",
    device="cuda"
)

# Retrieve initial documents (from retriever)
query = "How does machine learning work?"
initial_documents = [
    "Machine learning algorithms learn patterns from data",
    "Deep learning is a subset of machine learning",
    "Neural networks are inspired by biological neurons",
    "Supervised learning uses labeled training data",
    "Unsupervised learning finds hidden patterns"
]

# Rerank for better relevance
reranked_results = reranker.rerank(
    query=query,
    documents=initial_documents,
    top_k=3
)

# Display results
for i, result in enumerate(reranked_results, 1):
    print(f"{i}. Score: {result.reranked_score:.3f}")
    print(f"   Content: {result.content}")
    print(f"   Method: {result.reranking_method}")
    print()

Advanced Hybrid Reranking

from recoagent.rag.rerankers import HybridReranker, CrossEncoderReranker, BiEncoderReranker

# Create multiple rerankers
cross_encoder = CrossEncoderReranker(
    model_name="cross-encoder/ms-marco-MiniLM-L-6-v2",
    device="cuda"
)

bi_encoder = BiEncoderReranker(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    similarity_metric="cosine"
)

# Create hybrid reranker
hybrid_reranker = HybridReranker(
    rerankers=[cross_encoder, bi_encoder],
    fusion_method="weighted",
    weights=[0.6, 0.4]
)

# Rerank documents
query = "What are the applications of artificial intelligence?"
documents = [
    "AI is used in healthcare for medical diagnosis",
    "Machine learning powers recommendation systems",
    "Natural language processing enables chatbots",
    "Computer vision is used in autonomous vehicles",
    "AI helps in fraud detection in banking"
]

# Get reranked results
reranked_results = hybrid_reranker.rerank(query, documents, top_k=3)

# Analyze results
print(f"Query: {query}")
print(f"Reranked {len(documents)} documents to top {len(reranked_results)}")
print()

for i, result in enumerate(reranked_results, 1):
    print(f"{i}. Score: {result.reranked_score:.3f} (Original: {result.original_score:.3f})")
    print(f"   Content: {result.content}")
    print()

Reranking with Metadata

from recoagent.rag.rerankers import CrossEncoderReranker
from recoagent.rag.retrievers import RetrievalResult

# Create reranker
reranker = CrossEncoderReranker()

# Simulate retrieval results with metadata
retrieval_results = [
    RetrievalResult(
        chunk=Chunk(
            content="Machine learning is transforming healthcare",
            metadata={"source": "medical_journal", "date": "2024-01-15", "authority": "high"}
        ),
        score=0.8,
        retrieval_method="vector"
    ),
    RetrievalResult(
        chunk=Chunk(
            content="AI applications in finance include fraud detection",
            metadata={"source": "tech_blog", "date": "2023-12-01", "authority": "medium"}
        ),
        score=0.7,
        retrieval_method="bm25"
    ),
    RetrievalResult(
        chunk=Chunk(
            content="Deep learning models require large datasets",
            metadata={"source": "research_paper", "date": "2024-02-01", "authority": "high"}
        ),
        score=0.6,
        retrieval_method="vector"
    )
]

# Extract documents and metadata
documents = [result.chunk.content for result in retrieval_results]
metadata_list = [result.chunk.metadata for result in retrieval_results]

# Rerank with metadata consideration
reranked_results = reranker.rerank_with_metadata(
    query="AI in healthcare and finance",
    documents=documents,
    metadata_list=metadata_list,
    top_k=2
)

# Display results with metadata
for result in reranked_results:
    print(f"Score: {result.reranked_score:.3f}")
    print(f"Content: {result.content}")
    print(f"Source: {result.metadata['source']}")
    print(f"Authority: {result.metadata['authority']}")
    print("---")

Batch Reranking for Multiple Queries

from recoagent.rag.rerankers import CrossEncoderReranker

# Create reranker
reranker = CrossEncoderReranker(batch_size=8)

# Multiple queries to process
queries = [
    "What is machine learning?",
    "How do neural networks work?",
    "What are AI applications in healthcare?",
    "Explain deep learning concepts"
]

# Common document set
documents = [
    "Machine learning algorithms learn from data",
    "Neural networks are inspired by the brain",
    "AI is revolutionizing medical diagnosis",
    "Deep learning uses multiple layers",
    "Healthcare AI improves patient outcomes"
]

# Batch rerank for efficiency
batch_results = reranker.batch_rerank(
    queries=queries,
    documents=documents,
    top_k=3
)

# Process results
for i, (query, results) in enumerate(zip(queries, batch_results)):
    print(f"Query {i+1}: {query}")
    for j, result in enumerate(results, 1):
        print(f"  {j}. Score: {result.reranked_score:.3f} - {result.content[:50]}...")
    print()

Custom Reranker Implementation

from recoagent.rag.rerankers import BaseReranker, RerankResult
from typing import List, Dict, Any

class CustomBusinessReranker(BaseReranker):
    """Custom reranker with business-specific logic."""
    
    def __init__(self, business_rules: Dict[str, Any]):
        self.business_rules = business_rules
    
    def rerank(self, query: str, documents: List[str], top_k: int = 5) -> List[RerankResult]:
        """Custom reranking with business rules."""
        results = []
        
        for i, doc in enumerate(documents):
            # Calculate base score (simplified)
            base_score = 0.5
            
            # Apply business rules
            if "premium" in doc.lower():
                base_score += 0.2
            
            if any(keyword in doc.lower() for keyword in self.business_rules.get("priority_keywords", [])):
                base_score += 0.3
            
            # Create result
            result = RerankResult(
                chunk_id=f"chunk_{i}",
                content=doc,
                metadata={"custom_reranker": True},
                original_score=0.5,
                reranked_score=base_score,
                reranking_method="custom_business"
            )
            results.append(result)
        
        # Sort by reranked score
        results.sort(key=lambda x: x.reranked_score, reverse=True)
        return results[:top_k]

# Create custom reranker
business_reranker = CustomBusinessReranker({
    "priority_keywords": ["enterprise", "scalable", "secure"]
})

# Use custom reranker
query = "Enterprise AI solutions"
documents = [
    "Our enterprise AI platform is scalable and secure",
    "Machine learning for small businesses",
    "Secure AI solutions for large organizations"
]

results = business_reranker.rerank(query, documents, top_k=2)

API Reference

CrossEncoderReranker Methods

rerank(query: str, documents: List[str], top_k: int = 5) -> List[RerankResult]

Rerank documents using cross-encoder model

Parameters:

• query (str): Search query
• documents (List[str]): Documents to rerank
• top_k (int): Number of top results to return

Returns: List of reranked results

batch_rerank(queries: List[str], documents: List[str], top_k: int = 5) -> List[List[RerankResult]]

Rerank documents for multiple queries in batch

Parameters:

• queries (List[str]): List of queries
• documents (List[str]): Documents to rerank
• top_k (int): Number of top results per query

Returns: List of reranked results for each query

BiEncoderReranker Methods

rerank(query: str, documents: List[str], top_k: int = 5) -> List[RerankResult]

Rerank documents using bi-encoder model

Parameters:

• query (str): Search query
• documents (List[str]): Documents to rerank
• top_k (int): Number of top results

Returns: List of reranked results

HybridReranker Methods

rerank(query: str, documents: List[str], top_k: int = 5) -> List[RerankResult]

Rerank documents using hybrid approach

Parameters:

• query (str): Search query
• documents (List[str]): Documents to rerank
• top_k (int): Number of top results

Returns: List of reranked results

add_reranker(reranker: BaseReranker, weight: float) -> None

Add new reranker to hybrid system

Parameters:

• reranker (BaseReranker): Reranker to add
• weight (float): Weight for the reranker

See Also

• RAG Retrievers - Document retrieval
• RAG Evaluators - Reranking evaluation
• RAG Query Understanding - Query processing