All Vector Databases 2026: The 12-Way Honest Comparison

Every vector database fits one of four architectural shapes. The shape matters more than the vendor name — it determines your ops surface area, your blast radius, your portability story, and your cost model.

**Shape 1: managed serverless.** Pinecone, Weaviate Cloud, Qdrant Cloud Serverless, Zilliz Cloud Serverless, Chroma Cloud, Turbopuffer. You pay per-vector or per-storage + per-query; the vendor handles scaling, replication, backup, upgrades. Lowest ops overhead, highest unit cost at scale, vendor-lock on data shape and query API.

**Shape 2: managed dedicated.** Pinecone Pod-based, Weaviate Enterprise SaaS, Qdrant Premium, Zilliz Dedicated, Elastic Cloud, AWS OpenSearch Service, Vespa Cloud. You provision specific instance sizes, pay hourly/monthly per instance regardless of utilization. Predictable cost, more knobs to tune, still vendor-managed.

**Shape 3: self-host open-source.** Qdrant, Milvus, Weaviate, Chroma server, Elasticsearch, OpenSearch, Vespa, Typesense — all open-source, all runnable on your own Kubernetes/VMs. Lowest dollar cost, highest ops cost, full data sovereignty, required for air-gapped deployments. Same software as the managed tier in most cases.

**Shape 4: in-process library or extension.** FAISS (library), Chroma embedded (Python in-process), pgvector (Postgres extension). No separate service, runs in your existing process or DB. Lowest latency, lowest ops, lowest portability — your application code and your vector store are coupled.

**Verdict on shapes**: greenfield SaaS → shape 1 (serverless) to ship fast. Postgres shop → shape 4 (pgvector) to eliminate infrastructure. Air-gapped/regulated → shape 3 (self-host). Billion-vector scale → shape 1 or 3 with capacity planning. Sub-millisecond latency requirement → shape 4 (FAISS or pgvector with HNSW).

Three pricing models dominate. Each rewards a different workload shape.

**Serverless (Pinecone, Qdrant Cloud Serverless, Zilliz Serverless, Turbopuffer)**: pay per storage GB/month + per query operation + per write operation. Pinecone serverless = $0.33/GB-month storage + $0.33/M write units + $8.25/M read units. Turbopuffer = $0.10/GB-month + $0.40/M query ops. Best for spiky workloads, prototype-to-prod ramps, multi-tenant SaaS with uneven traffic. Worst for sustained high-QPS production where dedicated capacity is cheaper.

**Pod / dedicated (Pinecone Pod-based, Weaviate Enterprise, Zilliz Dedicated, Elastic Cloud)**: pay per instance hour or per pod month. Pinecone p1.x1 pod ~$70/mo for 1M-5M vectors. Elastic Cloud entry $95/mo. Best for predictable sustained workloads, known capacity. Worst for spiky traffic (you pay for idle).

**Bundled / open-source / in-process (pgvector, FAISS, self-host any open-source)**: no separate bill — bundled into your existing Postgres/EC2/K8s spend. pgvector on Supabase free tier handles ~1M vectors at zero marginal cost. Self-host Qdrant on a $40/mo Hetzner box handles 10M-50M vectors. FAISS in-process handles 100M+ vectors on a single 32GB server with no marginal infrastructure.

**Worked cost example, 10M vectors @ 1536 dim, 100k queries/day**: Pinecone serverless ~$20/mo storage + $25/mo reads = $45/mo. Turbopuffer ~$6/mo storage + $1.20/mo reads = $7/mo. Qdrant Cloud Standard ~$60/mo. Self-host Qdrant on 2x Hetzner = $80/mo (2 nodes for replication). pgvector on Supabase Pro = $25/mo. **Range: $7-60/mo for the same workload depending on architectural shape.**

**Verdict on pricing**: at small scale (<1M vectors), all options are <$50/mo and the choice is on ops + features. At medium scale (10M-100M), serverless and self-host costs diverge by 5-10x — model both. At large scale (1B+), Turbopuffer's object-storage-native architecture and self-host Milvus/FAISS are the only cost-viable options for most teams.

ANN-Benchmarks (ann-benchmarks.com) is the canonical public benchmark suite for approximate nearest neighbor search. It runs every algorithm/library against fixed datasets (Glove-100, SIFT-1M, deep-image-96-angular, etc.) and measures recall@10 at various queries-per-second targets. Higher recall + higher QPS = better.

**Single-node SOTA (single algorithm, no managed-service overhead)**: FAISS-HNSW at recall=0.95 reaches ~10,000 QPS on Glove-100 with optimized C++. ScaNN (Google research) and HNSW-lib similar tier. These are research-grade upper bounds.

**Managed-service benchmarks (vendor-reported, less reproducible)**: Pinecone publishes ~95-99% recall at 10ms p50 latency on their serverless tier. Qdrant Cloud reports ~0.99 recall at sub-10ms on dedicated. Weaviate similar tier. Vendor numbers are typically tuned (specific dataset, specific index params) — treat as upper bound for marketing context, not as a directly-comparable benchmark.

**The recall/QPS frontier is flatter than vendors imply.** On the same dataset and same index params, the top 5-6 vector DBs all hit recall ≥ 0.95 at production-acceptable QPS (1k-10k QPS per node). The differentiator is rarely raw recall — it's the cost per QPS, the hybrid-search story, the operational model.

**Real production benchmark you should run**: build a 1k-query held-out eval set from your own corpus with known-relevant docs. Run recall@10 against each candidate DB at your target index size (1M, 10M, 100M — whatever matches your scale). The 4 hours of work prevents 4 months of mediocre retrieval.

**Verdict on recall**: assume all 12 DBs above can hit ≥ 0.95 recall@10 if tuned. Differentiate on cost, hybrid, ops shape, not on benchmark headlines.

Pure dense retrieval (embeddings only) misses exact-keyword queries, proper-noun queries, code-symbol queries, and any query where the user's vocabulary doesn't match the corpus vocabulary. Hybrid search (BM25 keyword + dense vector, fused via Reciprocal Rank Fusion or learned fusion) closes that gap and is the production default in 2026. See our hybrid search tutorial for the architecture and code.

**Native hybrid in one index**: Qdrant (sparse+dense vectors, single API), Weaviate (alpha-blend BM25+dense), Elasticsearch (BM25 + dense + ELSER), OpenSearch (BM25 + dense + neural plugin), Vespa (rank profiles combining any signals), Typesense (typo-tolerant text + vector since 0.25). These are the strongest hybrid-search picks — one query API, one index, no application-layer fusion code.

**Hybrid via two indexes + RRF**: Pinecone (sparse-dense vectors since 2024, but per-vendor design is two distinct vector spaces stored together), Milvus (sparse-dense), Chroma (you fuse externally). Workable but more app-layer code.

**No native hybrid**: FAISS (DIY — pair with a separate BM25 library like rank_bm25). Pure dense, you assemble the hybrid in application code.

**Practical advice**: if your queries are mostly natural-language semantic ('show me docs about X'), pure dense is fine. If queries mix code, proper nouns, error messages, or exact-token searches, native hybrid is meaningfully better and one of the strongest reasons to pick Qdrant, Weaviate, or one of the search-engine hybrids over Pinecone or FAISS.

**Verdict on hybrid**: Qdrant and Weaviate are the cleanest 'native hybrid' picks for a vector-first team. Elasticsearch / OpenSearch / Vespa win for search-first teams that already run those engines.

Hosting model is usually the first hard constraint. Three buckets, each with sub-options.

**Managed-only (vendor-locked)**: Pinecone, Turbopuffer. You cannot self-host. Lowest ops, vendor lock-in for data shape and query API. Pinecone export is a custom format (no standard vector DB import shape exists). For most teams without compliance requirements this is fine; for regulated industries it's often disqualifying.

**Managed-OR-self-host (open core)**: Qdrant, Milvus, Weaviate, Chroma, Elasticsearch, OpenSearch, Vespa, Typesense. Same software runs on the vendor's managed tier or on your Kubernetes. Easy migration in either direction. Open-source license usually Apache 2.0 or Business Source. **This is the safest architectural pick** — start managed, migrate to self-host if/when cost or compliance demands it, no rewrite required.

**In-process or extension only**: FAISS (library), Chroma embedded, pgvector (extension). No separate process or service. Zero network hop, lowest latency, lowest ops, lowest portability (your code couples to your vector store).

**Cloud provider managed offerings (not the vendor)**: AWS OpenSearch Service (OpenSearch hosted by AWS), Azure AI Search (vector mode), Google Cloud Vector Search (managed Matching Engine), MongoDB Atlas Vector Search (Voyage embeddings native). These are managed-by-cloud-provider rather than managed-by-vendor — predictable for teams committed to one cloud, less feature-rich than the vendor offering typically.

**Verdict on hosting**: greenfield with no compliance constraints → managed (Pinecone if you want zero-ops, Qdrant Cloud if you want migration optionality later). Compliance-driven → self-host the open-source tier. Postgres shop with <10M vectors → pgvector, skip the separate service entirely.

Every vector DB scales to 'large' on paper. The reality is each has a sweet spot. Operating outside that spot means paying more for less performance.

**Sub-1M vectors (prototype, single-tenant SaaS, internal tools)**: pgvector, Chroma embedded, FAISS, Pinecone Starter, Qdrant Cloud Free. All free or near-free. Pick on ergonomics — usually pgvector if you already run Postgres, Chroma embedded if you don't.

**1M-100M vectors (mid-size production RAG, customer-facing SaaS)**: Pinecone serverless, Qdrant Cloud Standard, Weaviate Serverless, Zilliz Serverless, Elasticsearch, OpenSearch. All work well. Hybrid-search picks (Qdrant, Weaviate, Elastic) edge out pure-vector picks at this scale because relevance matters more than ingest throughput.

**100M-1B vectors (enterprise RAG, large document warehouses)**: Pinecone Pod-based, Qdrant self-host on multi-node, Milvus self-host on multi-node, Zilliz Dedicated, Vespa Cloud, Turbopuffer (genuinely shines here — object-storage-native eliminates the storage cost wall). Pinecone serverless gets expensive past 100M vectors; pod-based becomes competitive.

**1B-10B+ vectors (web-scale, search-engine workloads)**: Turbopuffer (designed for this — $0.10/GB-month storage scales linearly), Milvus self-host with GPU acceleration, Vespa (Yahoo-pedigree, ran Yahoo Search), Elasticsearch on dedicated multi-node clusters, FAISS-on-disk (research-grade, not for production OLTP). Pinecone, Weaviate, Qdrant Cloud all technically scale here but become operationally painful and cost-prohibitive vs Turbopuffer or Vespa.

**Per-tenant index limits**: Pinecone Starter caps at 200 namespaces, Standard unlimited. Weaviate multi-tenancy is first-class (per-tenant index isolation). Qdrant supports per-collection sharding. pgvector multi-tenant = one table per tenant or schema-per-tenant — Postgres native patterns.

**Verdict on scaling**: pick the DB for the scale you'll be at in 12-18 months, not the scale you're at on day one. Migrating from Pinecone serverless to Turbopuffer at 500M vectors is painful; starting on Qdrant (open-source) and scaling on the same software end-to-end is trivial.

**Use case 1: greenfield SaaS RAG, prototype-to-prod in 2 weeks.** Pick **Pinecone serverless** (zero ops, official LangChain/LlamaIndex integrations, $0 Starter tier for prototype). Migrate later if/when cost demands it.

**Use case 2: existing Postgres shop, <10M vectors, transactional consistency matters.** Pick **pgvector** (no new infrastructure, JOIN against existing tables, single backup/restore story). See our build RAG with pgvector tutorial.

**Use case 3: hybrid search is critical (code, proper nouns, exact-token queries common).** Pick **Qdrant** (native sparse+dense, fastest open-source benchmarks, managed + self-host parity) or **Weaviate** (native alpha-blend, GraphQL ergonomics). See our hybrid search tutorial.

**Use case 4: regulated industry, air-gapped deployment, no managed service allowed.** Pick **Qdrant self-host** or **Milvus self-host** (both Apache 2.0, both kubernetes-native, both production-grade at billion-scale). Avoid Pinecone (no self-host option).

**Use case 5: extreme cost-floor at 100M+ vector scale.** Pick **Turbopuffer** (object-storage-native, $0.10/GB-month vs $0.33+ on traditional architectures — typically 3-5x cheaper at scale). See our Turbopuffer vs Pinecone deep-dive.

**Use case 6: existing Elasticsearch/OpenSearch shop adding RAG.** Pick **the engine you already run** — Elasticsearch 8.x+ and OpenSearch 2.x+ both have first-class vector + hybrid support. Avoid introducing a second data plane. See our Elasticsearch vs OpenSearch vs Typesense comparison.

**Verdict on the decision tree**: most teams find one of these archetypes fits within 5 minutes of reading them. The DB choice is rarely the bottleneck — the prompt quality, the chunking strategy, and the rerank step matter more. Don't over-optimize the DB pick; pick the one that minimizes your ops surface area and move on.

**Turbopuffer** raised a $14M Series A from a16z in late 2024 and matured in 2025 into a production-grade serverless option specifically for the 100M+ vector scale tier. The object-storage-native architecture (vectors stored in S3/GCS with smart caching) is genuinely novel — costs scale linearly with storage, not with provisioned capacity.

**Pinecone** introduced sparse-dense vectors in 2024 (hybrid search support), shipped serverless in late 2023 with major pricing improvements through 2024-2025. Migrated most users off pod-based onto serverless. Pricing has held stable through 2026.

**Voyage AI was acquired by MongoDB** in late 2024 and integrated into MongoDB Atlas Vector Search as the native embedding provider. Standalone Voyage API remains available. MongoDB Atlas Vector Search is now a competitive 13th option not listed in our table above — same hosting story as managed Atlas.

**Chroma launched Chroma Cloud in 2025** (previously self-host only). Pay-as-you-go pricing. The embedded mode remains the default for LangChain prototypes; Cloud is the production path.

**Milvus 2.4 shipped GPU-accelerated search** for dedicated tiers (Zilliz Cloud). Sub-millisecond query latency at billion-scale on H100 nodes, at premium cost.

**pgvector 0.7+** introduced HNSW indexing (previously IVFFlat only), bringing pgvector to recall/QPS parity with the dedicated vector DBs for indexes under ~10M vectors. Major repositioning of pgvector from 'good enough for prototypes' to 'production-viable for mid-scale RAG.'

**Deprecations and consolidations**: several smaller vector DBs that launched 2022-2023 have shuttered or pivoted. The 12 above are the survivors as of June 2026 — the market consolidated around them.

**Live-verify before procurement**: vendor pricing pages change frequently in the vector DB space. Open each vendor's pricing URL (linked in the footnote) and confirm rates before committing to a long-term architecture.

**Mistake 1: defaulting to Pinecone because you read about it first.** Pinecone is a solid managed product but not universally the right pick. pgvector wins on cost+simplicity at <10M vectors; Qdrant/Weaviate win on hybrid search; Turbopuffer wins on cost at 100M+ scale; FAISS wins on raw single-node performance. Read the use-case decision tree above before defaulting.

**Mistake 2: optimizing ingest cost while ignoring query cost.** Embedding 1M docs once is $10-100; querying that index 1M times/month is the recurring bill. Pinecone read units ($8.25/M) become the dominant line item at >100k queries/day. Model the QPS-weighted cost, not the headline storage cost.

**Mistake 3: picking a managed service when you already run Postgres.** pgvector + Supabase or Neon eliminates an entire piece of infrastructure for the price of a Postgres extension. The 'I need a real vector DB' instinct is usually wrong below 10M vectors.

**Mistake 4: skipping the reranker.** Two-stage retrieval (vector DB top-100 → Cohere rerank-v3.5 top-10) improves precision by 10-30% at trivial cost ($1/1k queries). Add it regardless of which vector DB you pick. See Cohere rerank vs Voyage vs BGE.

**Mistake 5: not benchmarking on your own corpus.** Public ANN-Benchmarks tell you about Glove-100 and SIFT-1M, not about your actual documents and queries. Build a 200-query held-out eval set with known-relevant docs and measure recall@10 on each candidate. The 4 hours of work prevents 4 months of mediocre retrieval.

**Mistake 6: locking into a managed product with no self-host migration path.** If compliance or cost ever forces you off Pinecone or Turbopuffer, the migration is a rewrite. Picking an open-core vendor (Qdrant, Milvus, Weaviate, Chroma) preserves optionality at near-zero cost.

Pricing in this comparison is sourced from vendor pricing pages as follows, fetched 2026-06-21. **Pinecone**: pinecone.io/pricing — serverless GA late 2023, pricing stable through 2026. **Weaviate**: weaviate.io/pricing — Serverless Cloud Standard $25/mo + per-vector add-on, launched 2024, stable. **Qdrant**: qdrant.tech/pricing — Cloud Free 1GB launched 2024, Standard ~$30-60/mo entry, stable. **Chroma**: trychroma.com/pricing — Chroma Cloud launched 2025, pay-as-you-go.

**Zilliz/Milvus**: zilliz.com/pricing — Serverless from $0.10/hr CU launched 2024. **Turbopuffer**: turbopuffer.com/pricing — $0.10/GB/month + $0.40/M queries, GA 2025. **Elastic Cloud**: elastic.co/pricing — Standard from $95/mo, stable. **AWS OpenSearch Service**: aws.amazon.com/opensearch-service/pricing/ — t3.small.search from ~$0.10/hr.

**Vespa Cloud**: vespa.ai/pricing — pay-per-node hourly. **Typesense Cloud**: cloud.typesense.org — entry $0.044/hr or $32/mo. **FAISS**: github.com/facebookresearch/faiss — Apache 2.0, free.

**ANN-Benchmarks**: ann-benchmarks.com — public benchmarks, last major update 2024-2025; specific algorithm results visible at github.com/erikbern/ann-benchmarks.

**Live-verify**: open each vendor's pricing URL and confirm rates match before procurement. Vector DB pricing models have been more volatile than LLM pricing through 2024-2026 as the market consolidates — newer pricing tiers (especially around serverless and free tiers) often replace the ones cited above. The architectural shape recommendations in this guide hold regardless of specific pricing.