Hybrid Search

Hybrid search systems rely on multiple, complementary retrieval models running in parallel. The primary pair is:

• Dense Retrievers (Bi-Encoders): Encode queries and documents into dense vector embeddings. Relevance is calculated via cosine similarity or Maximum Inner Product Search (MIPS).
• Sparse Retrievers (Lexical Search): Use algorithms like BM25 to match documents based on exact term frequency and inverse document frequency. Advanced systems may also incorporate cross-encoders for a final, computationally intensive reranking stage, providing the highest accuracy on a small candidate set.

This component is responsible for merging the disparate relevance scores from each retrieval method into a single, unified ranking. Common techniques include:

• Reciprocal Rank Fusion (RRF): A robust, parameter-free method that sums the reciprocal of each document's rank across result lists, promoting consensus.
• Weighted Score Fusion: Manually or learned weighted combinations of normalized scores (e.g., 0.7 * vector_score + 0.3 * BM25_score).
• Learning-to-Rank (LTR): Machine learning models trained to predict the optimal combination of features from all retrieval methods for final ranking.

Handles metadata filtering—applying hard constraints based on structured attributes like date > 2023 or category = 'news'. Key implementations include:

• Pre-filtering: Applying Boolean filters first to create a reduced candidate set, then performing vector search. Efficient with selective filters.
• Post-filtering: Running a broad search first, then filtering results. Simpler but can discard highly relevant items that don't match filters.
• ANNS with Filters: Modified Approximate Nearest Neighbor Search algorithms (e.g., HNSW with Filters) that respect constraints during graph traversal. Optimized engines use filter pushdown and bitmap indexes for speed.

Analyzes the incoming query—including its text, any metadata filters, and system load—to generate the most efficient execution plan. It decides:

• The order of operations (filter -> vector -> keyword, or parallel retrieval).
• Which indexes to use based on filter selectivity.
• How to decompose conjunctive queries (AND) and disjunctive queries (OR). This component is often exposed via a Query DSL (Domain-Specific Language) that allows developers to express complex hybrid searches declaratively.

The dual storage backbones for fast retrieval:

• Vector Index: A specialized data structure (e.g., HNSW, IVF) that organizes dense embeddings for sub-linear time Approximate Nearest Neighbor Search. It is the core of semantic search.
• Inverted Index: The standard index for lexical search, mapping terms to the documents that contain them. It enables fast lookup for algorithms like BM25. These indexes are populated and maintained by separate ingestion pipelines, often requiring synchronization to ensure result consistency.

An optional, high-precision stage in a multi-stage retrieval pipeline. After the hybrid system retrieves a broad set of candidates (e.g., 100-1000 documents), a reranker re-evaluates them for final precision.

• Cross-Encoder Models: Neural models that take the query and a single document as a combined input, using deep attention to produce a highly accurate relevance score. They are too slow for first-stage retrieval but ideal for reranking.
• Feature-based Rerankers: Use a combination of scores from the first stage, document features, and sometimes lightweight models to refine the final top-N results (e.g., top 10).

Reciprocal Rank Fusion (RRF) is a robust, parameter-free method for combining ranked lists from different retrieval systems. It sums the reciprocal of each document's rank across all lists: score = Σ (1 / (k + rank)). This promotes documents that appear consistently well-ranked, making it highly effective for fusing vector and keyword results without complex score normalization.

• Key Benefit: No tuning required; works out-of-the-box with disparate scoring systems.
• Implementation: Each retrieval engine (e.g., vector ANN, BM25) returns its own ranked list. RRF calculates a unified score for each unique document across lists.
• Use Case: The default fusion strategy in many production vector databases (e.g., Weaviate, Qdrant) due to its simplicity and resilience.

Weighted Score Fusion involves normalizing the relevance scores from each retrieval method (e.g., cosine similarity, BM25) to a common scale and then combining them using a weighted sum: final_score = (α * norm_vector_score) + (β * norm_keyword_score). The weights (α, β) are tunable hyperparameters.

• Normalization: Critical step. Common methods include Min-Max scaling or converting to percentiles.
• Tuning Overhead: Requires a labeled validation set to optimize the weights for a specific domain.
• Precision vs. Recall Trade-off: Increasing the vector weight (α) typically boosts semantic recall, while increasing the keyword weight (β) can improve precision for exact term matching.

This pattern uses a multi-stage retrieval pipeline where a fast, broad hybrid search acts as a first-stage retriever, and a more computationally expensive cross-encoder model performs precise reranking on the smaller candidate set.

• First Stage: A hybrid of fast BM25 and approximate nearest neighbor (ANN) search retrieves 100-1000 candidate documents.
• Second Stage (Reranking): A cross-encoder model, which allows deep token-level interaction between the query and each candidate, computes a highly accurate relevance score for reordering the top results (e.g., top 10).

This architecture is standard in high-precision systems like search engines and retrieval-augmented generation (RAG), balancing latency with ultimate result quality.

These patterns define when metadata filters are applied relative to the vector search, a critical performance decision.

• Pre-Filtering: Hard metadata constraints (e.g., user_id = 123, date > 2024-01-01) are applied first to create a reduced candidate set. The vector similarity search then runs only on this subset. This is efficient when filters are highly selective but can miss relevant items if the filter excludes them.
• Post-Filtering: The vector similarity search runs first on the full corpus. Metadata filters are applied afterward to the top-K results. This preserves semantic recall but may return fewer final results if many top vectors fail the filter.

Modern vector databases use filter-aware ANN indices (like HNSW with filters) to blend these approaches, evaluating filters during graph traversal.

A Query Domain-Specific Language (DSL) allows developers to declaratively construct complex hybrid searches combining vector, keyword, and Boolean filter clauses in a single query.

Example Query Structure:

jsonCopy
{
  "must": [
    { "vector": { "query_embedding": [0.1, 0.2,...], "k": 10 } },
    { "filter": { "category": { "equals": "technical" } } }
  ],
  "should": [
    { "bm25": { "query": "neural network architecture" } }
  ]
}

• Clauses: must (AND), should (OR), must_not (NOT) define logical combinations.
• Systems: Implemented by databases like Elasticsearch with its knn clause, OpenSearch, and Vespa.
• Advantage: Provides a single, optimized execution plan, often leveraging filter pushdown for performance.

ColBERT (Contextualized Late Interaction over BERT) is a model architecture that hybridizes sparse and dense retrieval within a single neural network. It produces a "late interaction" score.

• Mechanism: ColBERT encodes the query and document independently into multiple token-level embeddings. The relevance score is computed as the sum of maximum similarity scores between each query token embedding and all document token embeddings.
• Hybrid Nature: It captures fine-grained lexical matching (like sparse retrieval) through token-level comparisons while using dense embeddings for semantic meaning.
• Efficiency: While more expensive than pure bi-encoders, it provides state-of-the-art accuracy and is used as a powerful reranker or as a standalone retriever where precision is paramount.

Semantic search is an information retrieval technique that uses the meaning and contextual relationships of words to find relevant content. It typically relies on dense vector embeddings generated by transformer models to represent queries and documents. Relevance is calculated using similarity metrics like cosine similarity, allowing it to match concepts even when exact keywords are absent. This contrasts with lexical search, enabling it to handle synonyms, paraphrasing, and complex intent.

Lexical search finds documents based on the exact occurrence of query terms or their morphological variants. BM25 (Best Matching 25) is the dominant probabilistic ranking function for this purpose. It improves upon older metrics like TF-IDF by factoring in document length normalization and term frequency saturation. Its strengths include:

• Precision for exact keyword matches.
• Speed and efficiency at scale.
• Interpretability, as scores are based on observable term occurrences. It forms the keyword-based pillar of a hybrid search system.

Reciprocal Rank Fusion (RRF) is a robust score fusion method for combining ranked lists from different retrieval systems (e.g., vector and keyword). It does not require score normalization. The algorithm works by summing the reciprocal of each document's rank across all lists. For example, a document ranked 1st and 3rd gets a score of (1/1 + 1/3). This promotes documents that rank consistently well across diverse retrieval methods, making it a popular, tuning-free choice for hybrid search result aggregation.

Reranking is the process of applying a more sophisticated, computationally expensive scoring model to a small set of candidate documents (e.g., 100-1000) retrieved by a fast first-stage search. Cross-encoder models are typically used for this. They take a query-document pair as a single input, allowing deep, attention-based interaction between all tokens to produce a highly accurate relevance score. Reranking is a key component of multi-stage retrieval architectures, dramatically improving final precision after a broad hybrid retrieval phase.

Filtered search is a retrieval process where metadata-based constraints are applied to narrow the candidate set. These are hard filters using attributes like date > 2024, category = 'news', or user_id = 123. Filters can be applied:

• Pre-filtering: Before vector search, reducing the search space.
• Post-filtering: After vector search, potentially discarding relevant results.
• During search: Integrated into the vector index traversal (e.g., HNSW with filters). Effective hybrid search often combines semantic/lexical retrieval with precise metadata filtering.

Multi-stage retrieval is a search architecture designed for optimal efficiency and accuracy. It uses a cascade of increasingly precise but slower models:

1. First Stage: A fast, high-recall method (e.g., hybrid of BM25 and bi-encoder vector search) retrieves a large candidate set (e.g., 1000 items).
2. Intermediate Stages: (Optional) Additional light-weight rankers or filters.
3. Final Stage: A powerful reranker (e.g., a cross-encoder) scores the small candidate set for optimal precision. This pattern balances low latency with high-quality final results, a common production architecture.