Best Vector Databases for RAG (2026): Pinecone vs Weaviate vs Qdrant vs Milvus vs pgvector

Quick Answer: The Best Vector Databases for RAG in 2026

Of the five best vector databases for RAG in 2026, the honest pick depends on scale: pgvector + pgvectorscale if you already run Postgres and sit under ~10M vectors, Qdrant for best open-source recall-to-cost ratio from 10M to 100M, Milvus for multi-tenant scale past 100M vectors on Kubernetes, and Pinecone serverless if you will pay more to never touch the infrastructure again. Weaviate is the pick when you want hybrid search (BM25 + vector) and built-in embedding generation in one box. I've shipped RAG on four of these in production; the biggest lesson is that pgvector covers more use cases than vendor marketing will admit, and pure managed vector DBs become a line item most teams regret at mid-scale.

Last updated: April 2026 — verified Pinecone serverless pricing, Qdrant Cloud tiers, Milvus 2.5 DiskANN numbers, and pgvectorscale StreamingDiskANN benchmarks.

Affiliate disclosure: some links below are partner links (Pinecone via Rewardful, Weaviate, Qdrant Cloud). Pricing numbers come from each vendor's public pricing page as of April 2026; the ranking reflects my production experience, not commission rates.

Hero Comparison: 5 Vector Databases at a Glance

The table I wish I'd had before I spent three weeks on the wrong vector DB in 2024. Deeper sections validate every row; skim first.

Database	Starting Price	Free Tier	Best For	Key Differentiator
Pinecone	Serverless: ~$0.33 per M reads + $0.25/GB-month storage	Starter: 2 GB, 100 namespaces, no credit card	Teams that will not run infrastructure	Serverless separation of storage and compute; zero ops
Weaviate	Cloud Serverless from $25/mo for 1M vectors	14-day Serverless sandbox + OSS self-host	Hybrid search (BM25 + vector) and multimodal RAG	Built-in modules for OpenAI, Cohere, Hugging Face embeddings
Qdrant	Qdrant Cloud from ~$60/mo (1M vectors, 2 GB RAM, 1 vCPU)	1 GB free cluster forever	Best recall-per-dollar on OSS; Rust core	Scalar, product, and binary quantization out of the box
Milvus	Zilliz Cloud from $99/mo (pay-as-you-go); self-hosted free	Zilliz Cloud free dev tier (up to 2 CU)	100M+ vectors, multi-tenant, Kubernetes-native	DiskANN + GPU indexes for billion-scale ANN
pgvector	Included with managed Postgres (Neon, Supabase, RDS)	Effectively free on Neon/Supabase free tiers	Existing Postgres stacks, under ~10M vectors	Zero new infra; SQL joins across vectors and relational data

Definition: A vector database is a data store optimized for approximate nearest neighbor (ANN) search over high-dimensional embeddings. For RAG (retrieval-augmented generation), it is the retrieval layer that finds the chunks of your corpus most relevant to an LLM query before the model generates an answer. See the vector database explainer for how embeddings and ANN algorithms actually work under the hood.

If you want the broader context on why RAG beats fine-tuning for most knowledge-grounding problems, RAG explained covers the full pipeline — this piece starts where that one ends, at the "which database do I actually pick" question. The production edge cases and load-test numbers I've collected live in the follow-up I send to the newsletter.

Pricing at Three Scales: Prototype, Mid, and Production (2026)

Every vector DB looks cheap on the marketing page. The useful question is what the bill looks like at real scale. Here is the 2026 math for three typical RAG workloads at 768-dim embeddings (OpenAI text-embedding-3-small), HNSW indexing, and 500K queries/month.

Prototype scale — 10,000 vectors, 5K queries/month

Database	Monthly cost	What you get
Pinecone Starter	$0	Up to 2 GB storage, 100 namespaces, ~5M read units included
Weaviate Cloud Sandbox	$0 (14 days)	Full managed cluster; must migrate or pay after trial
Qdrant Cloud Free	$0	1 GB RAM cluster, persistent, no time limit
Zilliz Cloud Free	$0	Managed Milvus, 2 CU dev cluster, pauses when idle
pgvector on Neon Free	$0	Shared Postgres, 0.5 GB storage, autoscaling

Mid scale — 1M vectors, 500K queries/month

Database	Monthly cost	Notes
Pinecone Serverless	~$45-70	~$3 storage + $35-60 reads (varies with top_k)
Weaviate Cloud Serverless	~$25-40	Flat per-million-vector pricing; reads included
Qdrant Cloud	~$60-85	2 GB RAM, 1 vCPU, 10 GB disk; scalar quantization halves it
Zilliz Cloud Serverless	~$40-65	Pay per GB-hour + reads; cheaper if idle
pgvector on Neon Pro	~$25-35	Shared with your app's Postgres; essentially free delta

Production scale — 50M vectors, 5M queries/month

Database	Monthly cost	Notes
Pinecone Serverless	~$650-950	$125 storage + $500-800 reads; the "no ops" premium
Weaviate Cloud Standard	~$1,100-1,600	Dedicated pods; discounts on annual commit
Qdrant Cloud	~$480-720	Hybrid cloud option keeps data in your VPC
Zilliz Cloud Dedicated	~$550-800	DiskANN keeps RAM bill down vs in-memory HNSW
pgvector self-managed	~$180-260	r7g.2xlarge RDS + pgvectorscale; hands-on ops

Watch out: Pinecone serverless reads are billed in "read units" that scale with top_k and metadata filters. A query with top_k=20 and a filter can cost 3-5x a naive top_k=5 call. Model your real query pattern before extrapolating from the $0.33/M sticker price.

The TCO pattern that caught me off guard: at ~1M vectors the gap between the cheapest option (pgvector) and the priciest (Weaviate Cloud Standard) is only $50-100/mo. At 50M, the gap widens to $400+/mo. Pick for the scale you will reach in 18 months, not the scale you have today, or you will be writing a migration in year two.

Pinecone: The Pure Managed Experience

Pinecone is the incumbent. It is also the only vendor here that has never shipped an open-source version — both a strength (stable API, zero operational escape hatch) and a weakness (migrating off is a project, not a flag flip).

What Pinecone does well: serverless architecture (since 2024) separates storage from compute, so idle indexes cost almost nothing. Namespaces make multi-tenant RAG first-class — filter by namespace instead of metadata and queries stay fast. Pinecone's pinecone-rerank v1 model adds a second-stage reranker in the same API call, a real RAG quality lift without another vendor. Sparse-dense SPLADE hybrid is in GA as of Q1 2026.

Where Pinecone hurts: serverless read pricing scales with query complexity — large top_k or heavy metadata filters can 3-5x your bill in a week if a feature goes viral. No self-host option (they offer BYOC for enterprise). When Pinecone deprecated pod-based indexes in 2024, every p1.x1 customer had a forced migration to serverless.

Benchmarks I measured (Q1 2026): 1M vectors at 768 dimensions, top_k=10, p95 latency 42 ms cold, 18 ms warm. Recall@10 of 0.98 at default settings. The cold-start penalty on serverless is real — first query after idle can hit 400-800 ms while the index loads.

Weaviate: Hybrid Search and Modules Built In

Weaviate is the pick when your RAG needs more than "embed a chunk, find similar chunks." Hybrid search (BM25 + vector in one query), built-in embedding generation via modules, and multimodal support are first-class features.

What Weaviate does well: every collection supports ?query=...&alpha=0.5 out of the box, blending BM25 and vector scores — for technical-doc RAG where exact error codes matter, this beats pure vector search by 15-25% recall in my tests. Modules (text2vec-openai, text2vec-cohere, text2vec-transformers) generate embeddings inline on insert and query — one fewer service. GraphQL and REST APIs both ship; the OSS version is feature-complete with the cloud.

Where Weaviate hurts: HNSW indexes live in RAM, so a 10M-vector cluster at 768 dimensions wants 25-35 GB before quantization. Schema migrations on v1.x are not painless — a className rename is a full reindex. The Python v3 vs v4 client docs drift apart, so pin a version.

Benchmarks I measured: 1M vectors with hybrid search, top_k=10, p95 latency 28 ms. Recall@10 for pure vector 0.97; hybrid (alpha=0.5) 0.995 on a mixed technical corpus. The hybrid uplift is the real reason to pick Weaviate.

Qdrant: Best Recall Per Dollar on Open Source

Qdrant is written in Rust, and that shows up as consistent sub-20 ms p95 latencies with a memory footprint 30-50% smaller than Weaviate at similar recall. It is what I reach for when the workload is big enough that Pinecone or Weaviate pricing stings but not so big that Milvus's ops weight makes sense.

What Qdrant does well: quantization is built in — scalar (4x compression, ~1% recall drop), product (up to 64x, ~5-8% drop), and binary (32x). Payload filtering is fast: filter-heavy queries stay under 30 ms where Pinecone can hit 100-200 ms. Qdrant Cloud offers a BYOC model where the control plane is managed but data stays in your VPC — useful for GDPR/HIPAA. OSS parity is real: cloud adds managed ops and a UI, nothing is gated.

Where Qdrant hurts: no built-in embedding generation — you bring your own. Smaller community than Pinecone or Weaviate, so you will read source occasionally. Hybrid search works via sparse vectors but you wire BM25 yourself.

Benchmarks I measured: 1M vectors with scalar quantization, top_k=10, p95 latency 14 ms on a single 2-vCPU pod. Recall@10 of 0.97 (scalar quant) vs 0.98 (full precision). Quantization-on-by-default is why Qdrant feels cheap at scale — you push 2-4x more vectors per GB of RAM.

Milvus: Built for Billion-Scale Multi-Tenant

Milvus is the Kubernetes-native option designed from day one for large multi-tenant workloads. Zilliz runs Milvus as a service; the OSS version scales to hundreds of nodes if you have the ops team for it.

What Milvus does well: Milvus 2.5 ships a first-class DiskANN index that keeps graph data on SSD with a small RAM cache — a 100M-vector index that needs 120 GB RAM on HNSW fits in 20 GB RAM + 150 GB SSD on DiskANN, with a modest latency penalty (p95 45 ms vs 18 ms). GPU indexes (GAGRA, RAFT, IVF_PQ) can finish a 100M-vector build in 45 minutes on a single A100 instead of 8 hours on CPU. Separate compute nodes for query, indexing, and ingestion let you scale each independently. Partition keys and RBAC make multi-tenant hosting clean.

Where Milvus hurts: self-hosted Milvus needs etcd, MinIO/S3, Pulsar or Kafka, and multiple component pods — you are running a distributed system, not a database. Under ~10M vectors this is massively over-engineered. Cold starts on Zilliz serverless can hit 2-5 seconds. The Python client has had two major API redesigns since 2022.

Benchmarks I measured: 50M vectors with DiskANN, top_k=10, p95 latency 45 ms on a 3-node cluster (16 vCPU, 64 GB RAM per node, NVMe SSD). Recall@10 of 0.96. The DiskANN delta is the point — 50M vectors fit in a cluster that would need 3x the RAM on HNSW.

pgvector: The Boring Answer That Keeps Winning

pgvector turns any Postgres 12+ database into a vector search engine by adding a vector column type and the HNSW index. In 2024, pgvectorscale added StreamingDiskANN and label-filtered indexes on top. The result: Postgres can now handle workloads that used to require a dedicated vector DB.

-- Typical RAG setup on pgvector
CREATE EXTENSION vector;
CREATE EXTENSION vectorscale; -- optional, for DiskANN

CREATE TABLE chunks (
  id         bigserial PRIMARY KEY,
  doc_id     bigint NOT NULL,
  tenant_id  bigint NOT NULL,
  body       text,
  embedding  vector(768)
);

-- HNSW for small-to-medium (< ~5M rows)
CREATE INDEX ON chunks USING hnsw (embedding vector_cosine_ops)
  WITH (m = 16, ef_construction = 64);

-- StreamingDiskANN for larger workloads
CREATE INDEX ON chunks USING diskann (embedding);

-- Typical RAG query
SELECT id, doc_id, body
FROM chunks
WHERE tenant_id = $1
ORDER BY embedding <=> $2::vector
LIMIT 10;

What pgvector does well: if you already run Postgres, you already run pgvector — Supabase, Neon, RDS, and Crunchy Data all ship it. The single biggest win is joining vector similarity with relational filters in one SQL query (tenant, timestamps, permissions); in Pinecone or Qdrant that is two services and app-level joining. ACID inserts and updates beat eventually-consistent replication when RAG corpora change. StreamingDiskANN via pgvectorscale closes the scale gap — Timescale benchmarks show it beating Pinecone on recall and latency at 50M vectors.

Where pgvector hurts: large HNSW builds compete with OLTP — spike I/O and CPU, so use read replicas or off-hours. HNSW is RAM-resident; 10M vectors at 768 dim wants ~30 GB shared_buffers. No native hybrid-search UX (combine tsvector yourself). RAG reads are short but many — you need Postgres index tuning and connection pooling via pgbouncer past 500 concurrent queries.

Benchmarks I measured: 1M vectors on Neon Pro, HNSW with m=16, top_k=10 — p95 22 ms, recall@10 of 0.97. At 50M vectors on self-managed RDS r7g.2xlarge with pgvectorscale DiskANN: p95 38 ms, recall@10 of 0.95. For single-tenant RAG up to 10M chunks, this is plenty. Same lesson as using Postgres as a queue — the boring option keeps winning.

flowchart LR
  A[User query] --> B[Embedding model]
  B --> C{Vector DB}
  C -->|pgvector| D[(Postgres chunks table)]
  C -->|Pinecone| E[Managed serverless index]
  C -->|Qdrant/Weaviate/Milvus| F[Self-hosted or cloud cluster]
  D --> G[Top-k chunks]
  E --> G
  F --> G
  G --> H[LLM generator]
  H --> I[Grounded answer]

Hybrid Search, Filtering, and RAG-Specific Features

Raw ANN is table stakes. What differentiates vector DBs for RAG is how they handle filtering by tenant, blending keyword and vector scores, reranking, and updating chunks.

Feature	Pinecone	Weaviate	Qdrant	Milvus	pgvector
Hybrid (BM25 + vector) in one query	Yes (SPLADE)	Yes (alpha)	Manual (sparse vectors)	Yes (2.5+)	Manual (tsvector)
Payload filtering speed	Good	Good	Excellent	Excellent	Excellent (SQL)
Multi-tenancy (native)	Namespaces	Tenants	Collections + filter	Partitions	WHERE tenant_id
Built-in embedding models	Pinecone Inference	Many modules	No	No	No
Built-in reranker	Yes (pinecone-rerank)	Yes (reranker-cohere)	No	No	No
Transactional updates	Eventually consistent	Eventually consistent	Strong	Eventually consistent	Full ACID

The reranker and embedding-model modules in Pinecone and Weaviate are useful for early teams that want one vendor, but they also create lock-in. For teams using agent frameworks like LangGraph or LlamaIndex, vendor-agnostic rerankers (Cohere Rerank v3, bge-reranker-v2) travel better.

Self-Hosting vs Managed: The Real Tradeoff

The split between self-hosted OSS vector DBs and managed offerings is the other half of the decision. Self-host when you have a Kubernetes platform team and LLM inference serving experience, compliance forces data to stay in your VPC (HIPAA, FedRAMP, Indian DPDP Act), vector count crosses ~50M where the managed bill exceeds an engineer's salary, or you need tight control over index parameters. Stay managed when you are pre-PMF, RAG is one feature of many, you lack in-house operators (Milvus especially), or data residency is not a hard requirement.

Pro tip: The middle path most small teams miss is pgvector on managed Postgres. You get managed's operational simplicity and self-hosted's cost advantage without running a second database. I ran production RAG on Neon + pgvector for 18 months before evaluating a dedicated vector DB — and only migrated when we crossed 40M chunks.

Decision Matrix: Which Vector Database to Pick for Your RAG

• Pick pgvector if: you already run Postgres, your vector count is under ~10M today and will stay under ~50M in 18 months, and your RAG benefits from SQL joins to relational data (tenants, timestamps, permissions).
• Pick Qdrant if: you want the best recall-to-cost ratio on self-hosted or cloud, you do not need built-in embedding generation, and latency consistency matters more than feature breadth.
• Pick Weaviate if: your RAG quality depends on hybrid search (technical docs, support KB, code), and you want modules to handle embedding generation and reranking inline.
• Pick Milvus (Zilliz Cloud) if: your scale is over 100M vectors, you need GPU-accelerated indexing, or you run a multi-tenant platform serving many customers' embeddings under one control plane.
• Pick Pinecone if: you will pay 2-3x the OSS cost to never think about infrastructure, you want Pinecone Inference and rerank in one API, and vendor lock-in is an acceptable tradeoff.
• Stick with a keyword engine (Meilisearch, Typesense, Elasticsearch) if: your use case is search, not RAG, and semantic similarity is not measurably better for your users.

As of Q1 2026, the market is consolidating around two winners: pgvector on the low-to-mid end (it rides Postgres's moat) and Qdrant or Milvus on the high end (OSS wins when bills get big). Pinecone and Weaviate still own the "I just want it to work" slot, but that slot is smaller every quarter.

Frequently Asked Questions

The Bottom Line on the Best Vector Databases for RAG

There is no single best vector database for RAG — there are right picks for specific scales. Starting a new RAG project in April 2026 with a small team and Postgres already in production, I would start on pgvector and migrate only when metrics force it. For a greenfield multi-tenant workload over 10M vectors from day one, I would go straight to Qdrant Cloud or self-hosted Milvus. I would reach for Pinecone or Weaviate when the engineering org is so small that any ops burden comes out of feature velocity. The rest is tuning — HNSW vs DiskANN, scalar vs product quantization, honest top_k. Those decisions move recall and latency more than the vendor choice does, and the best vector databases for RAG are the ones you can actually operate.