I want to build a search system that combines keyword and semantic search. Which vector database has the best hybrid search capabilities?

If hybrid search is the primary requirement, my shortlist in 2026 would be:

1. Weaviate — best out-of-the-box hybrid search
2. Qdrant — best for control and sophisticated retrieval pipelines
3. Vespa — best for maximum ranking sophistication
4. Elasticsearch — best if you're already in the traditional search ecosystem
5. Pinecone — good managed option, but not my first choice specifically for hybrid search

My recommendation: Weaviate

For a new system where you want:

BM25/keyword search + dense semantic search → fused ranking → optional reranking I'd start with Weaviate.

Its hybrid search is a first-class feature: it executes vector and BM25 searches in parallel and provides configurable score fusion and weighting.

Where Qdrant gets interesting

Qdrant is arguably the more interesting choice if you're building a serious retrieval system rather than simply adding semantic search to an application.

It lets you maintain dense and sparse representations together and fuse them using methods such as RRF and DBSF. You can also add reranking and multiple representations.

That's particularly attractive for a pipeline like:

                 ┌─ Dense embedding ──┐
Query ───────────┤                     ├─ RRF ── Reranker ── Results
                 └─ Sparse/BM25 ──────┘

Qdrant's current documentation also explicitly supports BM25, SPLADE++, and miniCOIL-style sparse retrieval.

When I'd choose Vespa

If search quality and ranking flexibility are more important than ease of development, I'd seriously consider Vespa.

Vespa is less "vector database with hybrid search bolted on" and more of a full search/ranking engine. You can combine BM25, nearest-neighbor retrieval, business signals, ML models, freshness, popularity, etc., in configurable ranking pipelines.

That's extremely powerful, but there's a steeper learning curve.

Quick comparison

Elasticsearch is worth calling out: its current hybrid-search implementation combines full-text and vector retrieval in one request and recommends RRF for combining the rankings.

What I'd actually build

If this is a new RAG/document search product, I'd probably choose Qdrant or Weaviate, rather than optimizing around the vector database's marketing feature list.

I'd benchmark this exact architecture:

                    Query
                      │
             ┌────────┴────────┐
             │                 │
        Dense embedding    Sparse/BM25
             │                 │
          Top 50             Top 50
             │                 │
             └────────┬────────┘
                      │
                     RRF
                      │
                   Top 20
                      │
                 Reranker
                      │
                    Top 5

The important point is that the database isn't necessarily what determines your final search quality. Your embedding model, sparse representation, candidate depth, fusion strategy, reranker, metadata filtering, chunking, and evaluation set can matter at least as much.

For example, Qdrant's own recent guidance recommends measuring dense-only, sparse-only, and hybrid retrieval with an evaluation set before tuning the fusion parameters.

Bottom line:

• Want the easiest excellent hybrid implementation? → Weaviate
• Want to build a highly tunable retrieval stack? → Qdrant
• Want a full-blown search/ranking platform? → Vespa
• Already running Elastic? → Elasticsearch
• Want managed simplicity above all else? → Pinecone

If you tell me your corpus size, expected QPS, document type, whether you need filters/multitenancy, and whether you want managed or self-hosted, I can narrow this down to a specific architecture and database.

Its hybrid search is a first-class feature: it executes vector and BM25 searches in parallel and provides configurable score fusion and weighting.

Where Qdrant gets interesting

Qdrant is arguably the more interesting choice if you're building a serious retrieval system rather than simply adding semantic search to an application.

It lets you maintain dense and sparse representations together and fuse them using methods such as RRF and DBSF. You can also add reranking and multiple representations.

That's particularly attractive for a pipeline like:

                 ┌─ Dense embedding ──┐
Query ───────────┤                     ├─ RRF ── Reranker ── Results
                 └─ Sparse/BM25 ──────┘

Qdrant's current documentation also explicitly supports BM25, SPLADE++, and miniCOIL-style sparse retrieval.

When I'd choose Vespa

If search quality and ranking flexibility are more important than ease of development, I'd seriously consider Vespa.

Vespa is less "vector database with hybrid search bolted on" and more of a full search/ranking engine. You can combine BM25, nearest-neighbor retrieval, business signals, ML models, freshness, popularity, etc., in configurable ranking pipelines.

That's extremely powerful, but there's a steeper learning curve.

Quick comparison

Elasticsearch is worth calling out: its current hybrid-search implementation combines full-text and vector retrieval in one request and recommends RRF for combining the rankings.

What I'd actually build

If this is a new RAG/document search product, I'd probably choose Qdrant or Weaviate, rather than optimizing around the vector database's marketing feature list.

I'd benchmark this exact architecture:

                    Query
                      │
             ┌────────┴────────┐
             │                 │
        Dense embedding    Sparse/BM25
             │                 │
          Top 50             Top 50
             │                 │
             └────────┬────────┘
                      │
                     RRF
                      │
                   Top 20
                      │
                 Reranker
                      │
                    Top 5

The important point is that the database isn't necessarily what determines your final search quality. Your embedding model, sparse representation, candidate depth, fusion strategy, reranker, metadata filtering, chunking, and evaluation set can matter at least as much.

For example, Qdrant's own recent guidance recommends measuring dense-only, sparse-only, and hybrid retrieval with an evaluation set before tuning the fusion parameters.

Bottom line:

When building a hybrid search system (combining dense vectors for semantic meaning and sparse vectors/BM25/inverted indexes for exact keyword matching), the "best" choice depends on whether you want a traditional search engine evolved for AI or a purpose-built vector database.

The top contenders for native, production-grade hybrid search break down as follows:

• Elasticsearch — Best overall for enterprise lexical + semantic hybrid search. Because it started as a dominant text search engine (using Lucene's BM25), adding dense vector search and native Reciprocal Rank Fusion (RRF) makes it unmatched if exact keyword precision, tokenization, synonym handling, and complex text querying are core requirements. Use the Elasticsearch Hybrid Search Guide to explore their implementation.
• OpenSearch — Best open-source alternative to Elasticsearch. Built on Apache Lucene and Faiss, it offers robust out-of-the-box hybrid queries and RRF score normalization. It is ideal if you need a scalable, open-source ecosystem with heavy text-analytics crossover.
• Qdrant — Best purpose-built vector database for native sparse & multi-vector search. Unlike many vector DBs that only support metadata filtering and call it "hybrid," Qdrant natively supports sparse vectors (like SPLADE or BM25-style expansions) alongside dense vectors and ColBERT multi-vector representations. It is lightweight, written in Rust , and exceptionally fast for real-time applications. Check out the details on Qdrant Features.
• Weaviate — Best for modular, developer-friendly RAG pipelines. Weaviate has first-class hybrid search combining dense vectors with built-in BM25 and customizable weighting parameters (alpha ). It seamlessly manages the multi-modal ingestion pipeline and has great abstraction layers for popular orchestration frameworks.
• Milvus — Best for extreme, billion-scale deployments. Milvus supports hybrid search by combining dense and sparse vector fields and merging them via RRF. It shines if you operate at a massive data scale requiring GPU acceleration, though it demands more infrastructure tuning than Qdrant or Weaviate.

Quick Recommendation Guide

• Choose Elasticsearch or OpenSearch if your application is text-heavy and relies heavily on complex linguistics, custom analyzers, and exact keyword matching.
• Choose Qdrant or Weaviate if you are building an LLM/RAG application from scratch and want a dedicated vector database with clean, programmatic hybrid APIs and low operational overhead.

To help narrow this down, tell me:

• What is your estimated data scale (number of documents/vectors)?
• Are you looking for a fully managed cloud service or a self-hosted open-source setup?
• Do you need advanced features like cross-lingual search or neural reranking?

If your goal is specifically keyword + semantic search in one search system, my top pick today would be Qdrant, with Weaviate a very close alternative.

My ranking

🥇 Qdrant — my recommendation

Qdrant has become particularly compelling for hybrid retrieval because it treats dense and sparse vectors as first-class citizens. You can store a semantic embedding alongside a sparse lexical representation and combine them in the same query.

For example:

                 Query
                   │
          ┌────────┴────────┐
          ▼                 ▼
    Dense embedding     Sparse embedding
    (semantic)          (lexical/BM25)
          │                 │
          ▼                 ▼
       Top 100            Top 100
          └────────┬────────┘
                   ▼
             RRF / DBSF
                   │
                   ▼
              Top 50
                   │
                   ▼
             Reranker
             (ColBERT)
                   │
                   ▼
               Top 10

The particularly nice part is that Qdrant's query API supports prefetching, fusion, and multi-stage retrieval. It supports RRF and DBSF for combining retrieval results, and you can subsequently rerank the candidates.

Qdrant also explicitly supports the architecture I'd generally recommend for a modern search engine:

dense retrieval + sparse retrieval → fusion → late-interaction reranking.

That gives you much more flexibility than simply doing:

BM25 score * 0.3 + cosine similarity * 0.7

In particular, Qdrant points out that raw BM25 and dense-vector scores live on different scales, so naïvely adding them with a fixed alpha can be problematic. RRF or score normalization is generally safer.

🥈 Weaviate — easiest choice

If you want something that makes hybrid search extremely straightforward, I'd seriously consider Weaviate.

Its hybrid query natively runs vector search + BM25 in parallel, then fuses the results. It supports relativeScoreFusion and rankedFusion, with relativeScoreFusion being the default. You can also control the balance using an alpha parameter.

Conceptually:

collection.query.hybrid(
    query="how do I reset my password?",
    alpha=0.5,
    limit=10
)

And Weaviate's BM25 implementation has useful search-specific features such as field selection, property boosting, tokenization options, and configurable BM25 parameters.

I'd choose Weaviate over Qdrant if your priority is:

"I want excellent hybrid search without designing the retrieval architecture myself." I'd choose Qdrant if your priority is:

"I want maximum control over the retrieval pipeline."

🥉 Vespa — potentially the most powerful

If you're building something closer to Google/Bing-style search infrastructure than a typical RAG application, I'd put Vespa very high on the list.

Its strength isn't simply "vector + BM25." It's the ability to construct sophisticated ranking pipelines combining lexical relevance, vectors, business signals, freshness, personalization, learned ranking, and multiple retrieval stages.

The downside is complexity. Vespa is considerably more of a search engine platform than a straightforward vector database.

What I'd actually build

For a new system in 2026, I'd probably start with:

Documents
   │
   ├── Dense embedding ────────┐
   │                            │
   └── Sparse embedding/BM25 ──┤
                                ▼
                           Qdrant
                                │
                           RRF / DBSF
                                │
                           50–100 docs
                                │
                         ColBERT reranker
                                │
                              Top 10

This handles the two failure modes particularly well:

Keyword search wins when the query contains:

• product IDs
• names
• error codes
• technical terminology
• exact phrases
• SKUs
• acronyms

Semantic search wins when the query is:

• conversational
• vague
• paraphrased
• conceptually related to the document
• using terminology different from the source text

And then reranking fixes many of the cases where neither first-stage retriever gets the ordering quite right.

Qdrant's own documentation demonstrates essentially this dense + sparse + late-interaction architecture.

One important caveat

If by "keyword search" you mean serious traditional search—complex Boolean queries, phrase queries, stemming, extensive analyzers, faceting, aggregations, typo tolerance, etc.—I'd also seriously evaluate Elasticsearch/OpenSearch rather than assuming a vector database is the right foundation.

But if you're asking:

"I want a modern semantic search system where lexical and vector retrieval are both first-class, and I may eventually add reranking." I'd pick Qdrant.

If you tell me roughly what you're searching (e.g. RAG over documents, ecommerce products, code, support tickets, enterprise documents, or web search) and your approximate corpus size, I can give you a much more specific Qdrant vs Weaviate vs Elasticsearch vs Vespa recommendation and an architecture.

In particular, Qdrant points out that raw BM25 and dense-vector scores live on different scales, so naïvely adding them with a fixed alpha can be problematic. RRF or score normalization is generally safer.

🥈 Weaviate — easiest choice

If you want something that makes hybrid search extremely straightforward, I'd seriously consider Weaviate.

Its hybrid query natively runs vector search + BM25 in parallel, then fuses the results. It supports relativeScoreFusion and rankedFusion, with relativeScoreFusion being the default. You can also control the balance using an alpha parameter.

Conceptually:

collection.query.hybrid(
    query="how do I reset my password?",
    alpha=0.5,
    limit=10
)

And Weaviate's BM25 implementation has useful search-specific features such as field selection, property boosting, tokenization options, and configurable BM25 parameters.

I'd choose Weaviate over Qdrant if your priority is:

"I want excellent hybrid search without designing the retrieval architecture myself." I'd choose Qdrant if your priority is:

"I want maximum control over the retrieval pipeline."

🥉 Vespa — potentially the most powerful

If you're building something closer to Google/Bing-style search infrastructure than a typical RAG application, I'd put Vespa very high on the list.

Its strength isn't simply "vector + BM25." It's the ability to construct sophisticated ranking pipelines combining lexical relevance, vectors, business signals, freshness, personalization, learned ranking, and multiple retrieval stages.

The downside is complexity. Vespa is considerably more of a search engine platform than a straightforward vector database.

What I'd actually build

For a new system in 2026, I'd probably start with:

Documents
   │
   ├── Dense embedding ────────┐
   │                            │
   └── Sparse embedding/BM25 ──┤
                                ▼
                           Qdrant
                                │
                           RRF / DBSF
                                │
                           50–100 docs
                                │
                         ColBERT reranker
                                │
                              Top 10

This handles the two failure modes particularly well:

Keyword search wins when the query contains:

• product IDs
• names
• error codes
• technical terminology
• exact phrases
• SKUs
• acronyms

Semantic search wins when the query is:

• conversational
• vague
• paraphrased
• conceptually related to the document
• using terminology different from the source text

And then reranking fixes many of the cases where neither first-stage retriever gets the ordering quite right.

Qdrant's own documentation demonstrates essentially this dense + sparse + late-interaction architecture.

One important caveat

When combining keyword and semantic search, several modern vector databases stand out, but Qdrant and Weaviate are widely considered to have the best native, production-ready hybrid search capabilities.

The "best" choice depends on whether you prefer native sparse-vector embedding integration or built-in BM25 scoring fused with vector math.

Top Contenders for Hybrid Search

• Qdrant: Best for unified vector-centric architecture. Qdrant handles hybrid search by natively supporting both dense vectors (for semantic meaning) and sparse vectors (for keyword/BM25 matching) within the same collection. Via its Universal Query API and algorithms like Reciprocal Rank Fusion (RRF), it executes both smoothly in a single call. It also features FastEmbed , making local generation of sparse BM25 vectors trivial.
• Weaviate: Best for developer-friendly abstraction. Weaviate natively runs a BM25 keyword search in parallel with a dense vector search. It allows you to tune the alpha parameter to explicitly balance keyword relevance versus contextual semantics, using fusion algorithms to merge the result sets seamlessly.
• Elasticsearch / OpenSearch: While historically traditional search engines rather than pure vector databases, they are top-tier if your application relies heavily on complex text processing, synonyms, and mature BM25, and you are adding vector search as an auxiliary capability.
• Pinecone: Offers hybrid capabilities, but traditionally requires managing the score fusion or namespace merging more explicitly on your application layer compared to the native sparse/dense multi-vector implementations in Qdrant or Weaviate.

How to Choose Based on Your Needs

1. Choose Qdrant if: You want a clean, high-performance Rust-based database where keyword matching is treated as a true sparse vector property alongside your dense embeddings, optimizing storage and query performance in a unified pipeline.
2. Choose Weaviate if: You want out-of-the-box score balancing (alpha tuning) between standard BM25 text search and vector search without needing to generate your own sparse embeddings manually.

To help narrow down the right fit, tell me:

• Are you planning to self-host or use a managed cloud service?
• Do you already have a preferred library for generating sparse/BM25 vectors , or do you need the database to handle text-to-vector processing natively?

If hybrid search is the primary requirement, my pick today would be Qdrant or Elasticsearch, depending on what you mean by “best.”

My ranking

🥇 Qdrant — my default recommendation

Qdrant has become particularly compelling for hybrid retrieval because you can store dense and sparse vectors together and fuse their results. Its hybrid-search API supports both RRF and distribution-based score fusion, and its sparse retrieval can represent lexical signals such as BM25/SPLADE.

That gives you an architecture like:

                 Query
                   │
          ┌────────┴────────┐
          │                 │
     Dense embedding    Sparse embedding
          │                 │
      semantic search   lexical search
          │                 │
          └────────┬────────┘
                   │
                  RRF
                   │
              reranking
                   │
                results

Qdrant also supports a subsequent reranking stage, including late-interaction approaches, which is useful when you want to push relevance beyond simple dense+sparse fusion.

🥈 Elasticsearch — best if search is more important than “vector DB”

If you're building a serious search product, I'd strongly consider Elasticsearch instead of a dedicated vector database.

It gives you mature lexical search—BM25/BM25F, analyzers, synonyms, fuzziness, field boosting, filters, etc.—alongside vector retrieval. Its current hybrid approach supports reciprocal rank fusion (RRF) and reranking.

I'd choose Elasticsearch when you expect queries like:

"error 503 nginx production" where exact terms, fields, filters, boosts, and linguistic analysis matter just as much as semantic similarity.

🥉 Weaviate — easiest API

Weaviate has perhaps the cleanest out-of-the-box hybrid-search abstraction. A single hybrid query runs BM25 and vector search and fuses their scores. You can tune the alpha parameter between pure keyword (0) and pure vector (1), and it supports different fusion strategies.

That's excellent if your priority is:

“I want hybrid search working quickly without building the retrieval machinery myself.”

Don't overlook Vespa

If by “best” you mean maximum control over ranking, Vespa is arguably the most powerful option.

It treats retrieval and ranking as one unified pipeline and supports keyword + vector + structured filtering, with multi-phase ranking and machine-learned ranking models.

The tradeoff is substantially more complexity than Qdrant/Weaviate.

What I'd choose

For a new system, I'd narrow it to:

• Qdrant → best overall choice for a modern RAG/semantic search system.
• Elasticsearch → best if you're building a general-purpose search engine with sophisticated lexical search.
• Weaviate → best if you want the simplest dedicated hybrid-search API.
• Vespa → best if search relevance/ranking is the core product and you're willing to invest in the infrastructure.
• OpenSearch → excellent choice if you're already in the AWS/OpenSearch ecosystem; it has native BM25 + semantic hybrid search with configurable score normalization/combination.

One important distinction: don't evaluate these solely on whether they support “hybrid search.” The interesting question is how much control you have over the retrieval and ranking pipeline. For a high-quality system, I'd benchmark BM25 + dense → fusion (RRF) → reranker rather than just comparing built-in hybrid-search scores.

If you tell me your corpus size, query type (RAG vs product/document search), latency target, and whether you need self-hosting, I can give you a much more concrete Qdrant vs Elasticsearch vs Weaviate recommendation.

That gives you an architecture like:

                 Query
                   │
          ┌────────┴────────┐
          │                 │
     Dense embedding    Sparse embedding
          │                 │
      semantic search   lexical search
          │                 │
          └────────┬────────┘
                   │
                  RRF
                   │
              reranking
                   │
                results

Qdrant also supports a subsequent reranking stage, including late-interaction approaches, which is useful when you want to push relevance beyond simple dense+sparse fusion.

🥈 Elasticsearch — best if search is more important than “vector DB”

If you're building a serious search product, I'd strongly consider Elasticsearch instead of a dedicated vector database.

It gives you mature lexical search—BM25/BM25F, analyzers, synonyms, fuzziness, field boosting, filters, etc.—alongside vector retrieval. Its current hybrid approach supports reciprocal rank fusion (RRF) and reranking.

I'd choose Elasticsearch when you expect queries like:

"error 503 nginx production" where exact terms, fields, filters, boosts, and linguistic analysis matter just as much as semantic similarity.

🥉 Weaviate — easiest API

Weaviate has perhaps the cleanest out-of-the-box hybrid-search abstraction. A single hybrid query runs BM25 and vector search and fuses their scores. You can tune the alpha parameter between pure keyword (0) and pure vector (1), and it supports different fusion strategies.

That's excellent if your priority is:

“I want hybrid search working quickly without building the retrieval machinery myself.”

When building a hybrid search system that combines keyword (lexical/BM25 or sparse vectors) and semantic (dense vector) search, Weaviate and Qdrant generally stand out as having the most robust, native, and production-ready hybrid search capabilities among purpose-built vector databases. However, traditional heavyweights like Elasticsearch and OpenSearch remain the gold standard if your text corpus is massive and lexical matching dominates.

The top contenders compare across hybrid-specific dimensions as follows:

• Weaviate is the best all-in-one choice for out-of-the-box hybrid search . It treats hybrid search as a first-class citizen. It performs a native BM25 keyword search and a dense vector search simultaneously within a single API call, using configurable score fusion (like Reciprocal Rank Fusion) and an alpha parameter to easily dial the balance between keyword precision and semantic context.
• Qdrant is the top pick for performance, memory efficiency, and developer control. It supports native sparse vectors (using models like SPLADE or miniCOIL) alongside dense vectors in a single collection. This allows true sparse-dense hybrid indexing at the database layer rather than just bolting a separate text search on top, and it handles result fusion via clean query APIs.
• Elasticsearch / OpenSearch are the optimal choice if your application relies heavily on complex text analysis, tokenization, synonyms, and mature BM25, but needs integrated vector search. Because they were built as text search engines first, their lexical capabilities are far more mature than any newer vector-first database, though they carry a heavier infrastructure footprint.
• Pinecone offers serverless full-text and hybrid search, but its implementation historically required you to supply pre-calculated sparse vectors on certain tiers rather than handling pure automated text-to-BM25 natively in the query pipeline like Weaviate.
• pgvector (PostgreSQL) is great if your data already lives in Postgres, but it does not have native sparse/BM25 support. Doing hybrid search requires writing application-level logic to combine Postgres tsvector full-text search with vector distance, then manually merging/fusing the scores.

To help narrow down which database fits your exact architecture, let me know:

• What is your expected data scale (number of documents/vectors)?
• Are you looking for a fully managed cloud service or an open-source/self-hosted setup?
• Do you prefer a native BM25 implementation or a sparse vector (SPLADE) approach for your keywords?

When building a hybrid search system (combining semantic dense vectors with lexical keyword search like BM25 or sparse vectors), two dedicated vector databases lead the pack for native, first-class implementation: Weaviate and Qdrant.

The right choice depends on how you want to handle your sparse/keyword indexing and your overall operational preference.

1. Weaviate: The Out-of-the-Box Leader

Weaviate treats hybrid search as a core, primary feature rather than an add-on.

• How it works: It natively combines dense vector search with BM25 keyword search in a single query. You can easily tune the balance between semantic and keyword relevance using an α alpha𝛼 parameter or choose between relative score fusion and reciprocal rank fusion (RRF).
• Why it's great: It requires the least amount of external pipeline plumbing. You send raw text, and it can even handle auto-vectorization via integrated modules.
• Best for: Teams that want an all-in-one ecosystem where hybrid search "just works" out of the box with minimal configuration.

2. Qdrant: The Performance & Sparse Vector King

Built in Rust, Qdrant approaches hybrid search by allowing you to store both dense vectors (for meaning) and sparse vectors (for exact keyword/token matching, using models like SPLADE or BM25 expansions) inside the exact same collection.

• How it works: Qdrant handles true sparse-dense hybrid queries natively at the storage engine level, letting you apply precise payload filtering alongside the hybrid score without a steep performance penalty.
• Why it's great: Exceptional memory efficiency, blistering query speeds, and arguably the cleanest API implementation for combining sparse and dense scores using RRF or linear fusion.
• Best for: Performance-conscious or budget-conscious teams who want granular control over sparse representations and lightning-fast filtered hybrid queries.

Alternative Mentions

• Pinecone: Offers sparse-dense hybrid capabilities, but traditionally requires you to generate your sparse/keyword vectors externally before pushing them, making it slightly less seamless natively than Qdrant or Weaviate.
• Elasticsearch / OpenSearch: If your application leans heavily on traditional text search and enterprise search features first, with vectors added as a secondary capability, Elastic/OpenSearch remains a heavyweight choice for mature lexical-to-semantic setups.
• PostgreSQL (with pgvector): Great if your data is already in Postgres, but you have to manually combine full-text search (tsvector ) with vector distance queries in your application layer or via custom functions rather than having a slick native hybrid scoring operator.

To help narrow down the ideal database for your architecture, tell me:

• Are you planning to self-host the database, or do you require a fully managed cloud service?
• How large is your expected dataset (number of documents/vectors)?

If hybrid search is the primary requirement, my top picks are:

1. Vespa — best overall for sophisticated search/ranking systems
2. Qdrant — best vector-native option with excellent hybrid capabilities
3. Weaviate — best developer experience for straightforward semantic + keyword search
4. Elasticsearch — best if you already want a traditional search engine with vectors added

My recommendation: Vespa

I'd choose Vespa if you're building a serious search product rather than just adding RAG to an application.

Vespa treats search as retrieval + ranking, rather than simply "vector search plus BM25." You can combine BM25, dense-vector similarity, metadata, popularity, freshness, business rules, and ML models in sophisticated ranking expressions. Its ranking framework can use arbitrary mathematical functions and machine-learned models.

For example, you can effectively build something like:

final_score =
    0.45 * semantic_similarity
  + 0.30 * bm25_score
  + 0.10 * freshness
  + 0.10 * popularity
  + 0.05 * business_score

And you can do multi-stage ranking, where inexpensive retrieval gets candidates and more expensive models rerank the top results.

Qdrant is probably the best alternative

Qdrant's approach is particularly nice if you think of your system as dense vectors + sparse vectors. You can store both representations on the same point and combine them using its Query API. It supports RRF and DBSF fusion, multiple prefetches, and multi-stage queries/reranking.

That's a very good architecture for:

                    ┌─ dense semantic search ─┐
query ──────────────┤                         ├── fusion ── rerank
                    └─ sparse/keyword search ─┘

I'd pick Qdrant over Vespa if you want a simpler vector-first architecture and don't need Vespa's extremely powerful ranking framework.

Weaviate is easiest to get started with

Weaviate has a very clean built-in hybrid query that combines BM25F and vector search. You can control the relative weighting with alpha and choose fusion strategies such as relative-score fusion or ranked fusion.

So if your desired API is essentially:

collection.query.hybrid(
    query="machine learning infrastructure",
    alpha=0.6
)

Weaviate is hard to beat for simplicity.

Elasticsearch is worth serious consideration

Don't overlook Elasticsearch. Its hybrid search combines full-text and vector search in one request, and Elastic recommends Reciprocal Rank Fusion (RRF) for combining the rankings.

If you need things like sophisticated text analyzers, phrase queries, fuzzy matching, faceting, aggregations, highlighting, geo search, etc., Elasticsearch can actually be a better choice than a "pure" vector database.

Quick comparison

If I were starting today:

• Search engine / product search / large-scale retrieval: Vespa
• RAG / semantic search with strong keyword fallback: Qdrant
• Want the easiest implementation: Weaviate
• Already running Elasticsearch: Don't switch—use Elasticsearch hybrid search

One important point: the database isn't necessarily the biggest determinant of hybrid-search quality. Your sparse representation, embedding model, candidate counts, fusion algorithm, filters, and especially reranker often matter more. I'd benchmark the top 3 against your actual queries and relevance judgments rather than relying on generic vector DB benchmarks.

If you tell me your dataset size, query type (RAG/product/docs/code), latency target, and whether you need self-hosting, I can narrow this down to a specific architecture and configuration.

If hybrid search—keyword + semantic—is the core requirement, my current shortlist would be:

1. Elasticsearch — best overall search engine
2. Weaviate — best dedicated vector DB with very ergonomic hybrid search
3. Qdrant — best lightweight/open-source vector-first option
4. Vespa — best for sophisticated, large-scale ranking
5. Pinecone — best managed/simple option, but less compelling if lexical search is central

My pick: Elasticsearch

If you're building a real search product, rather than just a RAG system, I'd lean toward Elasticsearch.

Its hybrid search is unusually mature: you can combine BM25/full-text retrieval with dense or sparse vector retrieval in one search request, and it supports RRF (Reciprocal Rank Fusion) as well as weighted/linear fusion. It also gives you mature analyzers, synonyms, fuzziness, field boosting, facets, filtering, geo search, and reranking.

That's important because hybrid search isn't just:

vector_score + BM25_score

In production, you'll often want something like:

                    ┌── BM25 ───────────┐
Query ──────────────┤                    ├── RRF ──> reranker ──> results
                    └── vector search ──┘

Elasticsearch has this retrieval/fusion architecture built in.

Where Weaviate wins

If you specifically want a vector database, I'd probably choose Weaviate.

Its hybrid search is a first-class operation: it runs BM25 and vector search in parallel and combines their results, with configurable fusion strategies and an alpha parameter for controlling the semantic-vs-keyword balance.

That makes it particularly nice for applications like:

• RAG
• document search
• product search
• knowledge bases
• semantic search with exact-name/SKU matching

It's considerably more search-oriented than simply bolting a lexical index onto a vector database.

Qdrant is a strong alternative

Qdrant is probably my choice if you want a lean, open-source vector-first system and are comfortable doing a little more of the search orchestration yourself. It supports sparse + dense vectors and hybrid retrieval, but Weaviate's API is generally more purpose-built around hybrid search. Current comparisons also consistently put Qdrant and Weaviate near the top for OSS hybrid retrieval.

Quick decision

One important point: don't choose based on ANN/vector benchmarks alone. For hybrid search, your actual relevance benchmark matters much more. Test queries containing both semantic queries ("comfortable shoes for long walks") and exact queries ("Nike Air Max 270, "ERR_CONNECTION_RESET", SKUs, names, IDs, etc.). Lexical search preserves precision on exact terms while semantic retrieval handles paraphrases and intent.

If I were starting today:

• Building a search engine/product search → Elasticsearch
• Building RAG/semantic retrieval → Weaviate
• Want self-hosted + lean + fast → Qdrant
• Already standardized on Postgres → pgvector

If you tell me your expected document/vector count, QPS, latency target, and whether this is RAG vs product/document search, I can narrow it down to one and explain the architecture I'd use.

When combining keyword and semantic search, Weaviate and Qdrant emerge as the top contenders for native, production-grade hybrid search capabilities, though traditional search engines like Elasticsearch and OpenSearch remain powerful if your workflow leans heavily toward text-heavy lexical retrieval.

The leading options compare across key capabilities as follows:

• Weaviate stands out as the overall hybrid champion. It treats BM25 keyword search and dense vector search as first-class citizens in a single query. You can tune the balance using an α alpha𝛼 parameter to slide between pure keyword and pure semantic matching, with built-in result fusion (Reciprocal Rank Fusion or relative score fusion). It also offers auto-vectorization modules, meaning you can send raw text directly without managing an external embedding pipeline.
• Qdrant excels with native sparse and dense vector support in a single collection. Instead of forcing a traditional BM25 engine alongside a vector index, Qdrant allows you to use learned sparse representations (like SPLADE or BM42) alongside dense embeddings. Combined with its blazing-fast Rust core and advanced payload filtering, it's ideal if you need high-throughput, filter-heavy hybrid queries.
• Elasticsearch / OpenSearch are the pragmatic choices if your application requires advanced enterprise search features (like deep query DSL, heavy synonym mapping, highlighting, and complex aggregations) alongside vector capabilities. They use Apache Lucene for mature lexical search (BM25) combined with native k k𝑘-NN vector search.
• Pinecone offers managed sparse-dense hybrid search capabilities, but it often requires you to generate your sparse/keyword vectors externally in your application layer before sending them over, making the developer experience slightly less seamless than Weaviate or Qdrant.
• pgvector handles hybrid search if you are already using PostgreSQL, but it requires you to manually combine Postgres's native tsvector full-text search with vector distances in your application code or SQL queries rather than offering a native unified scoring mechanism.

To help narrow down the ideal choice for your project, tell me:

• Are you leaning toward a fully managed cloud service or a self-hosted/open-source stack?
• Roughly how many documents or vectors do you plan to index?
• Do you already have an existing pipeline generating sparse/dense embeddings?