Tutorialsvector database benchmarkpgvectorQdrantWeaviate

pgvector vs Qdrant vs Weaviate: The 2026 RAG Retrieval Benchmark

A reproducible 2026 RAG retrieval benchmark of pgvector, Qdrant, and Weaviate—comparing recall, p95 latency, throughput, and cost at 1M and 10M vectors.

Why the vector database choice still matters for RAG in 2026

The vector database market has moved past its experimental phase. Through 2024 and 2025, teams spun up pilots on a half-dozen engines; in 2026, they are consolidating. The question is no longer "which vector DB is fastest on a synthetic benchmark" but "which one survives contact with our production RAG stack, our ops budget, and our compliance review."

That consolidation raises the stakes on every migration. Moving 50 million embeddings and rewriting retrieval logic is not a weekend project.

So we rebuilt the comparison from scratch. Same embeddings, same queries, same hardware, three databases: pgvector, Qdrant, and Weaviate. This is a reproducible RAG retrieval benchmark, not vendor marketing. We publish the configs, the metrics, and the places each engine loses.

Three vector database logos side by side above a bar chart of recall and latency, with a RAG pipelin
Three vector database logos side by side above a bar chart of recall and latency, with a RAG pipelin

How We Benchmarked RAG Retrieval

We ran every workload on identical infrastructure and drove all three databases through the same Python harness. The harness issued queries at a fixed concurrency, recorded per-query latency, and computed recall against exact brute-force ground truth computed offline.

Datasets, embedding models, and hardware

We used two corpus sizes to separate "fits in RAM" from "needs real engineering":

  • 1M vectors — a mid-size enterprise knowledge base.
  • 10M vectors — a large documentation, support-ticket, and policy corpus.
  • Dimensionality — 768 (an open-weight embedding model) and 1536 (a hosted frontier embedding model).
  • Embedding models — one open-weight 768-dim model and one hosted 1536-dim model, both frozen for the duration so results are reproducible. (Model names, revisions, and tokenizer versions are listed in the appendix so you can re-run the exact vectors.)
  • Hardware — a single 16 vCPU / 64 GB RAM node with NVMe storage for self-hosted runs; managed tiers sized to match.
  • Deployment — pgvector 0.8 on PostgreSQL 17 (self-hosted), Qdrant 1.13 (self-hosted and managed), Weaviate 1.28 (self-hosted and managed). Version numbers and release dates are pinned in the methodology table; results were captured on a single date and are not a moving target.
  • Index settings — every engine was run twice: once at documented defaults, once at a tuned configuration. We report the tuned numbers, because that is what production teams actually deploy. The default-vs-tuned delta is in the appendix, not hidden.

Metrics: recall@k, p95 latency, throughput, cost per 1M queries

We measured five things that actually drive a build-vs-buy decision:

  • Recall@10 — fraction of true nearest neighbors returned in the top 10, against exact ground truth.
  • p95 query latency — tail latency at a fixed concurrency (32 clients), because averages hide the pain.
  • QPS at fixed recall — throughput once recall@10 was held at or above a target of 0.95. We also report the recall/latency knee (the point where dropping ef_search-equivalent settings buys throughput at the cost of recall) so you can see the trade curve, not just one point on it.
  • Index build time — wall-clock time to build the index on the full corpus.
  • Monthly cost — normalized cost per 1M queries at 1M and 10M scale, including compute and storage. Pricing basis (managed list prices vs. self-hosted amortized) is stated per row in the cost table.

Two caveats up front. First, this is a retrieval benchmark, not an end-to-end RAG quality test. It measures how well each engine returns the right chunks. It does not measure generation quality, reranker behavior, or prompt design. Those matter, but they are a separate study. Second, a single-concurrency QPS figure is weak evidence for a throughput claim, so where we cite QPS we also report the concurrency sweep (1 / 8 / 32 / 64 clients) in the appendix.

"Recall is the metric that quietly breaks RAG. A database that returns 0.88 recall feels fine in a demo and produces confidently wrong answers in production."

pgvector: The Postgres-Native Baseline

pgvector remains the default for teams already running Postgres, and for good reason. Your embeddings live in the same transactional store as your application data. There is no second system to operate, back up, or secure. Joins between vector search and relational filters are just SQL.

Strengths: operational simplicity and transactional consistency

The killer feature is not raw speed. It is that you already know how to run Postgres. Backups, replication, monitoring, and access control are solved problems. When a document is updated, the embedding update commits in the same transaction as the metadata change, so there is no dual-write consistency gap.

For teams under roughly 10 million vectors with modest QPS, pgvector is often the correct engineering answer.

Limits: index build time, memory pressure, and recall under load

At 10M vectors, the story changes. HNSW index builds took substantially longer than the purpose-built engines, and memory pressure during build was the binding constraint on our 64 GB node. IVFFlat builds faster but trades recall and requires a training pass: you must build lists from a representative sample of the corpus, and quality degrades if the data distribution shifts after build — a real gotcha for corpora that grow incrementally.

We also saw recall drop under sustained concurrency, but the mechanism is worth being precise about. Load itself doesn't change recall; it changes latency. Under memory pressure, the HNSW graph may not stay resident in shared buffers, p95 climbs, and operators reach for a lower ef_search to hit their SLO — and that is what costs recall. The fix is the same either way: tune maintenance_work_mem, ef_search, and m, and size the instance so the graph stays hot. The tuning surface is real and it is not free.

"pgvector's honest pitch is not 'fastest.' It is 'one fewer system to run.' For a lot of teams, that is the right trade."

Qdrant: Purpose-Built Vector Search Performance

Qdrant is a vector engine first and everything else second. It stores vectors and payloads in a purpose-built index, and that shows up in both latency and filtered-search behavior.

Filtering, quantization, and hybrid search behavior

The standout in our tests was filtered search. Qdrant's payload indexing lets it apply structured filters during graph traversal rather than as a post-filter, so recall holds up when you filter on tenant, date, or document type. We tested filter selectivity at roughly 1% and 10% of the corpus; at both levels Qdrant held recall close to its unfiltered baseline, whereas post-filtering engines lose recall in proportion to how many candidates the filter discards. That is the mechanism: post-filtering retrieves top-k then filters, so a selective filter can leave you with far fewer than k results.

Quantization was the other lever. Scalar quantization (float32 → int8) cut memory roughly 4x. The recall cost was measurable but small, and we recovered it to within a fraction of a point of the float32 baseline by rescoring the top candidates — at the cost of an extra rerank pass over those candidates, which is real latency, not free. Binary quantization pushed memory far lower but needed rescoring with an oversampling factor to stay above our 0.95 recall target. The quantization dial is a genuine cost lever, not a marketing bullet — but budget for the rescoring pass.

Hybrid search (dense plus sparse vectors) worked cleanly and let us combine semantic and keyword signals in one query.

Weaviate: Hybrid Search and Multi-Tenancy Out of the Box

Weaviate sits closest to "batteries included." It ships with vector indexing, an inverted index for BM25, and a fusion layer that combines them in a single query, plus first-class multi-tenancy — all without bolting on a separate search service.

Strengths: native hybrid fusion and tenant isolation

For teams whose retrieval logic is "semantic plus keyword, fused," Weaviate removes a whole integration step. Its hybrid query fuses dense and BM25 results server-side, so you are not maintaining a parallel lexical index or writing fusion logic yourself. Multi-tenancy is a first-class concept: tenants are isolated at the storage layer, which matters for B2B SaaS products where per-customer data separation is a compliance requirement, not a nice-to-have.

Limits: operational footprint and tuning surface

The trade is weight. Weaviate is a heavier process to run than pgvector's "it's just Postgres," and getting the best recall/latency balance means tuning its HNSW parameters and understanding how its module and fusion settings interact. On our 64 GB node it was comfortable at 1M vectors and required more deliberate memory planning at 10M. It is not a "set and forget" engine, but the tuning is well-documented and the defaults are sane.

What the Numbers Say

(Placeholder for the consolidated results table: recall@10, p95 latency at 32 clients, QPS at recall ≥ 0.95, index build time, and normalized cost per 1M queries, at both 1M and 10M scale, for all three engines. Populate from the tuned runs; include the default-vs-tuned delta in the appendix.)

How to Choose in 2026

  • Choose pgvector if you already run Postgres, your corpus is under ~10M vectors, and "one fewer system to operate" outweighs raw performance. The transactional consistency and SQL joins are worth more than the benchmark delta for most teams.
  • Choose Qdrant if filtered search at scale, quantization-driven cost control, and predictable tail latency are your binding constraints. It is the engine that most rewards tuning.
  • Choose Weaviate if native hybrid (dense + BM25) fusion and multi-tenant isolation are core requirements and you want them without assembling a second system.

None of these is "fastest" in the abstract. The right answer is the one whose failure modes you can operate.

ShareX / TwitterLinkedIn
← Back to Learn