Hybrid Search: Combining Dense and Sparse Retrieval (2026)

When to Use

• ✓Queries frequently include specific product codes, model numbers, or technical jargon that vector search misses
• ✓Your document corpus has structured identifiers (invoice numbers, part numbers, API names) that need exact matching
• ✓Enterprise search where user queries mix natural language with specific terms
• ✓After setting up basic vector RAG and precision is still suboptimal (below 0.75)
• ✓Legal or compliance search where missing an exact-match clause is unacceptable

How It Works

1. 1Dense search: embed the query and retrieve the top-K chunks by cosine similarity. Good at semantic matching, paraphrase, and conceptual similarity. Poor at exact keyword matching.
2. 2Sparse search (BM25): tokenize the query and score documents by term frequency and inverse document frequency. Excellent at exact keyword matching. Poor at semantic similarity or paraphrase.
3. 3Reciprocal Rank Fusion (RRF): combine the ranked lists from both searches using RRF formula: score(d) = Σ 1/(k + rank(d)). k=60 is standard. RRF doesn't require calibrated scores — just ranks — making it simple and robust.
4. 4Learned fusion: train a small ranker that weights dense and sparse scores based on query type. More powerful than RRF but requires labeled training data. Use RRF by default, learned fusion for high-traffic production systems.
5. 5Most vector databases now support hybrid search natively: Elasticsearch (dense+BM25), Qdrant (dense+sparse vectors), Weaviate (BM25+dense), Pinecone (dense+sparse with SPLADE). No need to maintain separate sparse and dense indexes.

Examples

from qdrant_client import QdrantClient, models
from fastembed import SparseTextEmbedding

client = QdrantClient(url=QDRANT_URL)
sparse_model = SparseTextEmbedding(model_name='prithivida/Splade_PP_en_v1')

def hybrid_search(query: str, top_k: int = 10):
    dense_vector = embed_model.embed(query)  # your dense embedder
    sparse_vector = list(sparse_model.embed([query]))[0]
    
    results = client.query_points(
        collection_name='documents',
        prefetch=[
            models.Prefetch(query=dense_vector, using='dense', limit=50),
            models.Prefetch(query=sparse_vector, using='sparse', limit=50),
        ],
        query=models.FusionQuery(fusion=models.Fusion.RRF),
        limit=top_k
    )
    return results

# Elasticsearch 8.8+ native hybrid search with RRF
query = {
    'retriever': {
        'rrf': {
            'retrievers': [
                {
                    'standard': {
                        'query': {
                            'match': {'content': user_query}
                        }
                    }
                },
                {
                    'knn': {
                        'field': 'content_vector',
                        'query_vector': query_embedding,
                        'num_candidates': 50
                    }
                }
            ],
            'rank_window_size': 100,
            'rank_constant': 60
        }
    },
    'size': 10
}

Common Mistakes

• ✗Using simple score averaging instead of RRF — averaging dense and sparse scores requires calibrated scores on the same scale. Dense cosine similarity and BM25 scores have completely different ranges. Always use RRF or a trained combiner.
• ✗Not tuning the K value in RRF — k=60 is a robust default but not universal. For corpora with many highly relevant documents, k=10–20 gives higher weight to top-ranked results. A/B test on your eval set.
• ✗Forgetting to build a sparse index — dense-only vector DBs (early Pinecone, Chroma) don't support sparse search. If your DB doesn't support sparse natively, run BM25 in a separate Elasticsearch or Opensearch instance.
• ✗Applying hybrid search to all query types — simple factual lookups ('What is the capital of France?') don't benefit from hybrid search. Apply it selectively to queries with specific terms or where pure vector search has poor recall.

FAQ