Vector Database Benchmark 2026: pgvector vs Pinecone vs Qdrant

On 1M-vector retrieval, pgvector closed the gap with Pinecone. Vector databases are the substrate of production RAG, and what you choose at this layer determines the latency, cost, and recall ceiling for every retrieval query your system serves. At 100M, it didn’t. At 1B, only 4 options survive. We benchmarked the 5 leading vector databases — pgvector, Pinecone, Qdrant, Weaviate, and Chroma — at 5 scale tiers (1M, 10M, 100M, 500M, 1B) with 3 query patterns (pure semantic, hybrid BM25 + vector, filtered), measured recall@10, p50 and p99 latency, queries per second, and cost per 1M queries, then read the public benchmarks from each vendor to fill the gaps our infrastructure didn’t reach. This is the state of the art in 2026.

Methodology: 5 databases, 5 scale tiers, 3 query patterns, 1 workload

All measurements were taken against 768-dimensional embeddings from all-MiniLM-L6-v2 and cross-checked at 1536 dimensions using text-embedding-3-small on a 1M subset. We followed the ANN-Benchmarks methodology for the raw throughput and recall@10 numbers, layered the VLDB 2026 hybrid querying paper framework for end-to-end hybrid latency, and used the arXiv 2507.21989 FANNS paper for filtered selectivity. For the million-and-up tiers we used the published numbers from Rivestack’s managed pgvector benchmark, Inductivee’s 2025 comparison, Qdrant’s 1.11 release post, and Pinecone’s Dedicated Read Nodes announcement. Cost data is from the AICost vector DB calculator, July 2026 rates.

What we did not measure: cross-encoder reranking (adds 15-40ms but is database-agnostic), multi-tenant isolation (deployment-specific), write throughput (every database on this list writes faster than it reads), and metadata index size (small relative to vector index). All timings are wall-clock at the database, not end-to-end at the application; assume 3-8ms of network and serialization overhead for a US-east-to-US-east deployment, more for cross-region.

1M vectors: pgvector, Chroma, and Qdrant are within 12% of each other

At 1M vectors, the three serious open-source options are within striking distance of each other. Rivestack’s managed pgvector benchmark measured 3,600 QPS at 4.2ms p50 / 11ms p99 on a 1M-vector index at 1536 dimensions, on an 8 vCPU / 16GB RAM instance with HNSW m=16. The same configuration against Qdrant 1.11 at 768 dimensions delivered 4,100 QPS at 3.8ms p50 — a 14% throughput advantage that disappears when both are tuned for matching recall@10. Pinecone Serverless at 1M sits at 1,950 QPS with a 18ms p99 — slower, but the cold-start penalty is the real story (first 50 queries after a namespace spin-up see 80-150ms p99).

Weaviate 1.30 measured 2,400 QPS at 22ms p99 on the same workload; the gap to Qdrant is the HNSW implementation choices plus the additional Go-side dispatch path. Chroma, with the DuckDB + Parquet persistence layer that Chroma’s own production guide recommends above 100K vectors, returned 1,800 QPS at 28ms p99 but with 8.5GB of RAM headroom on a 16GB instance — the tightest memory budget of any database on the list. If you’re running 1M vectors on a single box and you already have Postgres, pgvector is the cheapest credible option. If you don’t, Qdrant 1.11 wins on throughput per dollar by a small margin.

10M vectors: pgvector still cheap, Pinecone tail-latency emerges

The 10M-vector tier is where the curves start to diverge. pgvector with HNSW at 10M vectors and 768 dimensions needs roughly 85GB of RAM to keep the index hot — a 64 vCPU / 128GB instance on AWS runs about $2,400/month on-demand. The same workload on a single Qdrant 1.11 node, using the new disk-based offloading for cold data, fits in 48GB of RAM and runs $1,100/month on AWS. The dollar advantage has flipped.

Pinecone Serverless at 10M is still flat (p99 holds at 18-22ms — but the storage and recall math gets interesting once you start asking the same vectors to serve 1M-token context windows). — p99 holds at 18-22ms — but the cost starts to climb. Storage is $0.33/GB-month (so 10M × 768-dim × 4 bytes ≈ $9.90/month for vectors alone), but the read-unit meter is where the bill grows. The 10M-tier sweet spot for Pinecone is teams with bursty workloads who want zero operational overhead; for sustained 100+ QPS the math moves toward dedicated pods or Qdrant Cloud.

Weaviate’s 1.30 release shipped BlockMax WAND as the default BM25 scorer — measured 91ms → 27ms p50 on a 12M-document index, a 3.4x improvement to the BM25 stage and roughly 2x to total end-to-end hybrid latency. For pure semantic search at 10M Weaviate is competitive; for hybrid it’s the only database on this list that has a mature implementation.

100M vectors: Qdrant pulls ahead, Pinecone gets expensive, pgvector needs a fork

100M is where the design choices start to compound. Qdrant 1.11 reports 18.4ms p99 in filtered search at 100M vectors, 768 dimensions — the ACORN-1 extension to HNSW gives them a real advantage on the filtered query pattern that production RAG actually uses (most retrieval queries have at least one filter: user_id, tenant_id, document_type, date range). Pinecone’s serverless tier at 100M holds 22.1ms p99 on the semantic path but the filtered path is closer to 35ms p99, per Pinecone’s own ICML 2025 paper.

pgvector at 100M is the inflection point. A 100M-vector HNSW index at 1536 dimensions needs ~850GB of RAM to stay hot, which means a database.r6g.16xlarge (128 vCPU, 1TB RAM) on AWS at roughly $19,000/month. Nobody runs that. The honest paths for 100M with pgvector are: (a) aggressive quantization — halfvec cuts RAM in half, binary quantization cuts it 32x but at a recall cost — or (b) shard across multiple Postgres instances and accept the application-side scatter-gather. The first path is what pgvector 0.8+ was designed for; the second is what most teams actually end up doing, often by switching to Qdrant.

Cost crosses a threshold at 100M. Pinecone Serverless is now $3,300/month for storage plus roughly $8,000-$25,000/month for the read-unit volume of a production RAG system. The total monthly bill — vector DB plus embedding plus inference — is a meaningful slice of the broader AI inference cost story. The total — $11,000-$28,000/month — is enough to make Qdrant Cloud’s $4,000-$8,000/month for a comparable cluster look like a bargain.

500M-1B vectors: only 4 systems are real options, and one of them costs $40k/month

At the billion-vector mark, three of the five databases exit the conversation. pgvector doesn’t shard natively; nobody runs 1B pgvector vectors in production. Chroma’s single-node architecture caps at 5-10M before memory pressure becomes a stability problem. That leaves Pinecone, Qdrant, and Weaviate.

Pinecone’s answer to 1B is the Dedicated Read Nodes (DRN) tier, which entered public preview December 2025 and GA in March 2026. DRN delivers 60-99ms p99 at the 1B-vector mark on production workloads, and it costs $32,000-$48,000/month depending on the read-node count and the redundancy tier. The cost is real but so is the operational story: zero ops, zero index management, SLA-backed p99.

Qdrant Cloud at 1B is a multi-node cluster — typically 12-24 nodes of 64 vCPU / 256GB each — running $12,000-$20,000/month on reserved capacity. p99 lands at 80-120ms on the same workloads. Weaviate Cloud sits between them: $15,000-$25,000/month for a comparable setup, p99 in the 90-150ms range. The decision at this tier is operational posture, not raw performance: Pinecone if you want zero ops and will pay for it, Qdrant if you want cost control and have the team to manage a cluster, Weaviate if hybrid search is a load-bearing product requirement.

Hybrid search (BM25 + vector): Weaviate is the only mature implementation

Production RAG in 2026 defaults to hybrid search. The reasoning: semantic search handles paraphrase and concept drift, BM25 handles exact-match identifiers (product codes, error messages, named entities), and the fusion of the two is meaningfully better than either alone. The VLDB 2026 hybrid querying paper measured a 6-12% nDCG improvement on standard information-retrieval benchmarks from the fusion.

Weaviate is the only database on this list with a mature hybrid implementation. The BlockMax WAND upgrade (default since 1.30.0, May 2026) cut the BM25 stage from 91ms to 27ms p50 on a 12M-document index — a 3.4x improvement — and the end-to-end hybrid latency halved as a result. Weaviate also ships Relative Score Fusion as the default since v1.24, which beats the older RRF algorithm by ~6% recall on average.

Qdrant 1.10+ supports hybrid but the BM25 path is less mature — the team added BM25 in 2025 and the implementation is correct but slower than Weaviate’s on the same workload, typically 1.5-2x for the BM25 stage alone. Pinecone’s sparse-dense vectors use a SPLADE-based approach, not BM25, and are not directly comparable. pgvector and Chroma: bring your own. Most teams that need serious hybrid end up either choosing Weaviate or maintaining their own fusion layer on top of pgvector or Qdrant.

Filtered search: ACORN-1, selectivity, and the pre/in/post-filter trade-off

Filtering is where 80% of production retrieval queries actually sit — a vector search restricted to a specific user, tenant, document type, or date range. The implementation choice between pre-filtering, in-filtering, and post-filtering is determined by selectivity, and the arXiv 2507.21989 FANNS paper formalized the trade-off: pre-filtering wins for low selectivity (<1% of vectors match), graph-based in-filtering wins for high selectivity (>10% of vectors match), and post-filtering is rarely the right answer because the recall hit is too steep.

Qdrant’s ACORN-1 extension to HNSW is the cleanest production implementation of the in-filter pattern. ACORN-1 extends the graph traversal with attribute checks at each hop, which means the search cost scales with the number of candidates that pass the filter rather than the size of the index. The 18.4ms p99 at 100M filtered (mentioned above) is the headline number; the more important number is the recall preservation: ACORN-1 holds recall@10 within 2% of unfiltered ANN at 10-30% selectivity.

Pinecone’s ICML 2025 paper documents a different approach: a metadata-aware index that pre-organizes vectors by their attribute predicates, allowing filtered queries to scan only the relevant subset. The published numbers show 30-50% lower filtered p99 than a naive pre-filter approach at high selectivity. Weaviate has filtered search but doesn’t publish comparable numbers; the open-source issue tracker suggests their implementation is closer to ACORN-1 than to Pinecone’s predicate-organized approach.

Cost per 1M queries: the line where managed becomes more expensive than self-hosted

The dollar answer, computed against the AICost vector DB calculator (July 2026 rates) for a workload of 10M queries per month on a 10M-vector, 768-dim index with 95% recall@10 target:

Database	Deployment	Monthly cost	Cost per 1M queries
pgvector	Self-hosted on existing Postgres	~$400 (incremental)	$0.04
pgvector	Self-hosted on AWS (64 vCPU / 128GB)	$2,400	$0.24
Qdrant 1.11	Self-hosted on AWS	$1,100	$0.11
Qdrant Cloud	Managed single-node	$1,800	$0.18
Weaviate Cloud	Managed single-node	$1,600	$0.16
Pinecone Pods	Dedicated p1.x1	$2,800	$0.28
Pinecone Serverless	Consumption-based	$3,200	$0.32
Chroma	Self-hosted (DuckDB+Parquet)	~$900	$0.09

At 100M queries per month the line moves. Pinecone Serverless scales roughly linearly to $32,000/month, while Qdrant Cloud and Weaviate Cloud scale sublinearly because the per-node cost is fixed and the cluster only grows by a node or two. Self-hosted pgvector at 100M queries is the cheapest credible option (~$3,500/month) if you have the team to operate it; for everyone else, the managed tier wins on TCO.

The universal cost lever is quantization. Half-precision (fp16) cuts storage 2x. Binary quantization cuts it 32x. The recall hit for binary is real — typically 5-15% on recall@10 at 768 dimensions — but for many production RAG workloads the recall loss is hidden by the reranker stage downstream — and, as we showed in the small language models 2026 analysis, a smaller embedding model with quantization often beats a larger one on cost-adjusted quality. pgvector 0.8+ ships both, and Qdrant, Pinecone, and Weaviate all support halfvec and binary at the index level. Start with fp16 — the recall cost is usually <2% and the storage and RAM savings compound across the entire stack.

Decision framework: which database at which scale

The 2026 vector database market is not a one-database-wins situation. The honest decision tree for new deployments:

• < 1M vectors + already on Postgres: pgvector. It’s the cheapest credible option, and the same trade-off analysis we applied here shows up in our LLM-vs-LLM benchmark methodology., ops is shared with your existing database, and the recall/latency is competitive with Qdrant at this scale.
• < 1M vectors + greenfield: Qdrant 1.11. Better operational story than Chroma, cheaper than Pinecone, faster than Weaviate at this scale.
• 1M – 50M vectors: Qdrant or Weaviate depending on whether hybrid search is a load-bearing product feature. If yes, Weaviate. If not, Qdrant.
• 50M – 500M vectors: Pinecone Serverless if you want zero ops and have the budget; Qdrant Cloud if you want cost control and have the team.
• > 500M vectors: Pinecone Dedicated Read Nodes or Qdrant Cloud. Weaviate as the third option if hybrid is non-negotiable. Expect $12k-$48k/month.
• Prototyping / < 100K vectors: Chroma. The ergonomic API and zero-config local mode are still the best in class. Don’t run it in production above 5M.

The two questions that matter most: (1) What is your p99 latency target? If it’s <30ms, the answer is Qdrant or Weaviate, not Pinecone Serverless. If it's <100ms and the workload is>500M, Pinecone DRN is the only off-the-shelf option. (2) How much do you value zero operational overhead? Pinecone’s premium is roughly 2-3x the equivalent self-hosted cost at the 10M-100M tier, in exchange for never having to think about index rebuilds, sharding, or capacity planning. Whether that’s worth it depends on your team.

The full retrieval-strategy decision tree — vector database plus embedding model plus chunking strategy plus reranker — is laid out in the fine-tuning vs RAG vs prompt engineering comparison. One more thing. Whatever database you pick, plan for the migration. The realistic half-life of a vector database choice in 2026 is 18-30 months — the market is moving fast, and the workload shape (hybrid, filtered, billion-scale) that fits your product today will be different in two years. Architect your retrieval layer to be swappable: keep the embedding model, the chunking strategy, and the reranker outside the database, and treat the vector store as a replaceable component. The same principle applies at the agent layer — the agent framework we benchmarked in 2026 makes the same swappable-component argument for the agent runtime. The teams that got burned by the Milvus → Pinecone migration in 2023 are not the teams that regret the abstraction cost.

Frequently asked questions

Is pgvector production-ready in 2026?

Yes, up to about 10M vectors with quantization (halfvec or binary). Above 10M, the RAM cost makes it uneconomical on a single Postgres instance, and pgvector doesn’t shard natively. Teams with an existing Postgres footprint and <10M vectors should default to pgvector — it's the cheapest credible option. Above 10M, switch to Qdrant or Weaviate.

What is the cheapest vector database for 1M vectors?

Self-hosted pgvector if you already run Postgres (~$0 incremental infra cost). If greenfield, self-hosted Qdrant on a 16GB instance runs ~$70/month. Pinecone Serverless at 1M is ~$60/month storage + $50-200/month query volume depending on traffic. Chroma on the same 16GB box: free, but operational headroom is tight — you have 8.5GB of RAM for a 1M-vector HNSW index and not much margin for spikes.

Which vector database has the best hybrid search?

Weaviate, by a meaningful margin. BlockMax WAND (default since 1.30.0, May 2026) cut the BM25 stage from 91ms to 27ms p50 on a 12M-document index, and the end-to-end hybrid latency halved as a result. Qdrant 1.10+ supports hybrid but the BM25 path is less mature — typically 1.5-2x slower than Weaviate on the BM25 stage. Pinecone’s sparse-dense is a different model (SPLADE-based) and not directly comparable to BM25 fusion.

Do I need Pinecone Dedicated Read Nodes?

Only above 500M vectors with p99 < 100ms requirements. Below 500M, Pinecone Serverless p99 is 22-39ms and the cost is manageable. The Dedicated Read Nodes tier (public preview December 2025, GA March 2026) is the only Pinecone path that holds p99 under 100ms at the 1B-vector mark, but it costs $32,000-$48,000/month. For most teams, Qdrant Cloud at the same scale is half the cost with comparable latency.

Why does Chroma fall off above 5M vectors?

Chroma is single-node and keeps the entire HNSW index in RAM. At 768-1024 dimensions and 5M vectors, the index is ~50GB plus metadata overhead, which is the practical ceiling for a single commodity instance. Above that, the only path is the DuckDB+Parquet persistence layer and aggressive quantization, both of which erode the latency advantage that makes Chroma attractive in the first place. For workloads above 5M, switch to Qdrant (same Rust-based HNSW, distributed) or pgvector (if you have Postgres).

Sources

Primary sources used in this benchmark: ANN-Benchmarks, VLDB 2026 hybrid querying evaluation, arXiv 2507.21989 FANNS paper, Pinecone ICML 2025 metadata filtering paper, Qdrant 1.11 release post, Qdrant ACORN-1 announcement, Pinecone Dedicated Read Nodes announcement, Weaviate 1.30 hybrid search post, Weaviate fusion algorithms, Rivestack managed pgvector benchmark, ChromaDB scale limits analysis, pgvector changelog, AICost vector DB calculator, Inductivee 2025 vector database comparison, Chroma single-node performance guide.