Vector Database Comparison 2026: Pinecone vs Qdrant vs Weaviate vs Milvus vs pgvector

As of August 2026, the thing that actually decides the quality of your RAG (retrieval-augmented generation) pipeline or AI agent is not the model — it’s the retrieval layer. You can bolt on the best LLM money can buy, but if it can’t surface the right source documents, the answer falls apart. That’s why the vector database comparison conversation in 2026 has shifted away from “which one is fastest” toward “which one fits where our data already lives, how many ops people we have, and whether we need hybrid search.” This guide covers five options — Pinecone, Qdrant, Weaviate, Milvus (Zilliz), and pgvector — using nothing but official documentation and official pricing pages.

The timing is unusually interesting right now. Milvus 3.0 was announced on 27 July 2026 and tagged for release on 29 July. That’s less than a week old at the time of writing, and the concept is “lake-native”: querying the Parquet, Iceberg, Lance, and Vortex tables already sitting in your object storage without copying them into a vector database at all. If you already run a data lake, that removes the assumption that you have to build an ingestion pipeline from scratch.

Around the same time, the pgvector camp had far more urgent news. CVE-2026-3172 is a buffer overflow caused by integer wraparound during parallel HNSW index builds. Every version from 0.6.0 through 0.8.1 is affected, and the fix landed in 0.8.2. Also, plenty of blogs are writing “pgvector 0.9” — 0.9 does not exist. As of 2 August 2026 the latest release is 0.8.6 (2026-07-29). Throughout this guide I correct that kind of widely repeated bad number against the official values, one at a time.

Below, we start with a head-to-head comparison table, then go product by product through a feature deep dive, cover how to talk about performance honestly, break down the official pricing in full, give recommendations by user type, and finish with practical tips, common mistakes, and an FAQ. Rather than lining up plausible-looking benchmark figures, the approach here is simple: use numbers only where they’re verified, and say so plainly where they aren’t. That’s far more useful when you’re the one signing off on the decision.

1. Executive Summary: The Five Big Vector Databases at a Glance, August 2026

For AI engineers and tech leads who are short on time, here’s the design philosophy, latest version, pricing structure, free tier, and trade-offs of all five, compressed into a single table.

📊 Head-to-Head Comparison of the Top 5 Vector Databases, August 2026

The row you should read first in that table is the last one. These five aren’t really competing products so much as different answers to different organizational situations. If you already run Postgres and you’re under ten million vectors, pgvector is effectively the default, and adopting a dedicated vector database means manufacturing new costs for yourself in the form of ops headcount and a sync pipeline.

2. Feature Deep Dive: The Five Vector Databases

🌲 1) Pinecone — the benchmark for fully managed serverless

• Serverless is now the default, full stop: The old pod-based indexes are legacy; serverless is the standard path today. Never having to think about node sizing, sharding, or rebalancing is Pinecone’s entire reason for existing. For a team without an infrastructure engineer, that single line outweighs every other row in the comparison table.
• All three index types on serverless: Pinecone supports dense, sparse, and full-text indexes, and full-text uses BM25 with Lucene query syntax. The stale claim that “sparse is pod-only” is still circulating, and it isn’t true. All three run on serverless.
• First-party embedding and reranking models: Pinecone ships pinecone-sparse-english-v0 for sparse embeddings and uses bge-reranker-v2-m3 as its reranker. Free and Builder plans get that reranker only; the full model lineup unlocks on Standard and above.
• Hard limits worth knowing, part 1 — general indexes: 40KB of metadata per record, top_k capped at 10,000, query results capped at 4MB, and metadata filters using $in/$nin capped at 10,000 values per operator. If you pull a generous candidate set off a dense index for reranking, you have far more headroom than most articles suggest.
• Hard limits worth knowing, part 2 — sparse indexes only: Sparse indexes carry a separate, much tighter set of limits: a maximum of 1,000 non-zero values per sparse vector (the general sparse-vector limit is 2,048), top_k capped at 1,000, 10 upserts/sec, and 100 QPS on queries. Plenty of comparison articles copy these sparse-only numbers as if they were Pinecone’s global limits — the top_k ceiling of 1,000 applies to sparse indexes only; the general limit is 10,000. Bulk initial loads do have to be scheduled around the sparse throughput.
• What changed in 2026: A flat-rate Builder tier at $20/month was introduced to fill the gap between Starter and Standard. It targets exactly the segment where the free tier is too small but usage-based billing is too scary — solo developers and small teams.

🦀 2) Qdrant — Rust-based, and genuinely serious about memory efficiency

• TurboQuant halves your memory: Introduced in v1.18.0 (2026-05-11), TurboQuant is a quantization technique developed by Google Research. It applies a fast Hadamard rotation to spread values evenly across coordinates before compressing them, and by Qdrant’s own measurements it delivers half the memory of scalar quantization (SQ) at comparable recall and speed. Compression can go up to 8x. Given that RAM is a large share of what a vector database actually costs, this isn’t just a feature — it lands directly on the invoice.
• Observability built for operators: The same v1.18 release added a memory monitoring web UI and API that break down a collection’s disk, RAM, and page-cache usage by component — vectors, payload, and index separately. You can now confirm where the memory went instead of guessing. An audit log query API and request tracing IDs shipped alongside it.
• Schema changes without downtime: You can add and remove named vectors without recreating the collection. For teams swapping embedding models or experimenting with multi-vector setups, that saves the entire cost of a re-ingest.
• Hybrid search as a first-class citizen: Native sparse vectors have been supported since v1.7, so you can keep dense and sparse in the same collection and handle it all in one query through the Query API using either RRF or weighted linear fusion.
• Vendor viability: Qdrant raised a $50M Series B on 12 March 2026, bringing the total to $87.8M (led by Advance Venture Partners, with Bosch Ventures joining as a new investor). That matters only when you’re assessing whether the vendor will still be around; it is not an argument about the product.
• So what do you give up? — Qdrant’s trade-offs: Because its strengths concentrate on single-node efficiency, Milvus has the deeper architecture and operational track record once you push distributed scale-out past 100 million vectors. And with no unit prices on the official pricing page, you cannot produce an accurate monthly cost before you commit — you have to configure a spec in the console or get a quote from sales. In organizations with a strict budget-approval process, that friction is bigger than it sounds.
• Earlier releases were substantive too: v1.17 (February 2026) brought Relevance Feedback queries and search latency improvements, while v1.16 added hierarchical multi-tenancy (tenant promotion) and ACORN-based improvements to filtered vector search. The latest patch is v1.18.3 (2026-07-17).

🕸️ 3) Weaviate — where hybrid search has been battle-tested the longest

• Hybrid tuned by a single alpha: A native BM25 module and dense vectors are fused through one alpha parameter on the query. Being able to shift weight between keyword matching and semantic search by changing a single character turns out to matter more than you’d expect in real work, where tuning is iterative. Of the five, Weaviate has been running hybrid search in production the longest.
• Multi-tenancy is a first-class feature: The combination of tenant isolation and hybrid search is Weaviate’s sweet spot, which makes it a natural fit for B2B SaaS that must keep each customer’s data separate.
• The practical additions in v1.35: Object TTL (automatic expiry of object lifetimes) lets you clean up stale documents automatically, plus zstd compression, flat index + RQ quantization going GA (it was preview in 1.34), runtime-configurable OIDC certificates, and operational modes (controlling which kinds of work each node will handle).
• Embedding document images directly: The multi2multivec-weaviate module in v1.35 supports multimodal document embedding — embedding page images and retrieving them with text queries. Worth a look if you’re handling scanned PDFs, tables, or layout-heavy documents and want to skip the OCR pipeline entirely.
• The support policy is strict: Only the three most recent minor versions (1.36 / 1.37 / 1.38) receive bug and security patches. The current release is v1.38.x (2026-06-05), preceded by v1.37.x (2026-04-16), v1.36.x (2026-02-24), v1.35.x (2025-12-17), and v1.34.x (2025-11-05). The habit of letting a version sit for a year doesn’t survive here.

🐦 4) Milvus / Zilliz — massive-scale distribution and the arrival of “lake-native”

• Milvus 3.0, built around lake-native: Announced 27 July 2026, released 29 July. The core idea is lake-native indexing: “zero-copy external collections” that let you query data sitting in open table formats (Parquet / Lance / Iceberg / Vortex) in object storage without copying it into the vector database. In other words, you skip the customary ETL job that replicates tens of terabytes.
• Loon, a new storage engine: A manifest-based storage engine whose goal is to sharply reduce the read amplification that comes with low-latency point access against object storage. Vortex is the default storage format.
• Search and ranking pulled into the engine: Beyond plain nearest-neighbor search, the engine now handles rich ranking, aggregations, sparse search, and multi-vector search internally. The release also brought SINDI for learned-sparse vectors, server-side MinHash generation, nullable vector fields, custom dictionaries for full-text search, and broader Faiss-compatible index support. Snapshots (zero-copy point-in-time collection views) and Spark integration are included as well.
• Milvus 2.6 is still very much in service: Its own cloud-native WAL, Woodpecker, removed the dependency on Kafka and Pulsar. The zero-disk design persists all logs to object storage such as S3, GCS, or MinIO, and as of 2.6 the WAL itself is optional. A new Streaming Node works alongside the Query and Data Nodes, and tiered storage, RaBitQ quantization, full-text search, and multi-tenancy all got stronger. The vendor claims 72% memory savings at equal recall and 4x the performance of Elasticsearch — read those as Milvus (Zilliz) internal measurements.
• What changed recently in managed Zilliz Cloud: As of 1 January 2026, storage pricing was unified at $0.04/GB/month across AWS, Azure, and GCP. With cross-region and cross-cloud data transfer now available, transfer costs are passed through at the provider’s cost with no markup. Milvus 2.6.x went GA on Zilliz Cloud on 20 January 2026, and Zilliz claims — again, by its own measurement — that tiered storage delivers cache hit rates above 90% and storage cost reductions of up to 87% in production.
• The tooling is being rebuilt too: Attu 3.0 Beta (July 2026) arrived with multi-cluster management, AI agents, and a fully rewritten console.

🐘 5) pgvector — the most powerful option is “don’t adopt a new database”

• Check your version first: The latest release is 0.8.6 (2026-07-29). “pgvector 0.9” does not exist. Several tech blogs have it wrong, so verify before you copy-paste anything into internal docs.
• 🔴 CVE-2026-3172 — check this today: Integer wraparound during parallel HNSW index builds causes a buffer overflow. Versions 0.6.0 through 0.8.1 are affected; 0.8.2 contains the fix. Any database user who can create or REINDEX an HNSW index with parallel workers could leak sensitive data from other relations or crash the database server. If you can’t patch immediately, set max_parallel_maintenance_workers = 0 to disable parallel HNSW builds as a stopgap.
• The 2026 release cadence has been dense: 0.8.3 (2026-06-17) fixed potential index corruption during HNSW vacuuming and a distance-calculation performance regression on PostgreSQL 18. 0.8.4 (2026-06-30) cleaned up HNSW vacuuming error messages, insert problems during maintenance, and IVFFlat build memory over-allocation. 0.8.5 (2026-07-08) reduced the memory required to build IVFFlat indexes on small datasets, and 0.8.6 addressed an IVFFlat build buffer overflow on 32-bit systems, the non-zero count limit when converting arrays to sparsevec, and IVFFlat scan memory during nested loop joins. A run of fixes like that is also a signal of heavy real-world production usage.
• Two index types: HNSW and IVFFlat: HNSW has the better speed-recall trade-off but builds slowly and uses more memory. IVFFlat builds fast and stays light. If you raise maintenance_work_mem for a parallel HNSW build, you need to size shared memory to at least the same amount or the build errors out. PostgreSQL 18 support arrived in 0.8.1 (2025-09-04).
• Hybrid is the biggest weakness: There is no built-in hybrid search. You compute tsvector full-text search and vector distance separately, then fuse them yourself in application code (RRF or similar). It’s the most hands-on part of any of the five, and this single item is the most common reason teams migrate to a dedicated vector database.
• If you want to squeeze out more performance: Timescale’s pgvectorscale 0.9.0 is a separate extension layered on top of pgvector; it adds PG18 support, drops PG13 support, and supports concurrent index builds. If you’re weighing your Postgres options more broadly, reading it alongside PostgreSQL vs MySQL vs MongoDB database comparison will give you a clearer picture of the whole stack.

3. The Performance Benchmark Showdown: Honestly, “Go Measure It Yourself”

If you came to this section expecting a glossy QPS table, let me set expectations now. As of August 2026 there is no credible, cross-verified benchmark comparing these five under identical conditions. So we’re not going to build that table. Building it would mean lying.

You’ll understand faster if you see how much the circulating numbers contradict each other. One source puts Qdrant at 41.47 QPS on 50 million vectors and, in the same paragraph, gives pgvectorscale 471 QPS. That’s a 10x gap with neither hardware nor index parameters specified. On p99 latency, you’ll find a source claiming “roughly 12ms for Qdrant, 16ms for Weaviate, 18ms for Milvus at 10 million vectors” sitting right next to another claiming “under 8ms for Qdrant.” Impressive-sounding lines like “Pinecone: 1 billion vectors, 50ms p95, 10,000 QPS vs Qdrant: 20ms p95, 15,000 QPS” trace back to a single SEO blog post, with the test conditions nowhere to be found.

[Qualitative assessment based on architectural strengths — tendencies, not numbers]
Qdrant   : ⭐⭐⭐⭐⭐ Single-node latency (Rust + SIMD-optimized HNSW)
Milvus   : ⭐⭐⭐⭐⭐ Extreme-scale throughput (distributed architecture, 100M+ vectors)
Weaviate : ⭐⭐⭐⭐☆ Optimized for hybrid workloads (QPS drops under heavy filters)
Pinecone : ⭐⭐⭐⭐☆ Reliable performance with zero ops (little room to tune)
pgvector : ⭐⭐⭐☆☆ Practically on par with dedicated DBs up to ~1M scale

It’s more accurate to talk about architectural tendencies rather than numbers. Qdrant is understood to be strong on single-node latency thanks to SIMD-optimized HNSW on a Rust base. Milvus, being distributed, has the advantage on throughput at 100 million vectors and beyond. Weaviate is optimized for hybrid workloads, though QPS is reported to degrade as metadata filters get heavier. The general consensus on pgvector is that with an HNSW index it is practically on par with dedicated vector databases at around the one-million mark.

Vendor benchmarks are worth referencing as long as you attribute them. Milvus 2.6’s 72% memory savings and 4x-Elasticsearch claim is Zilliz’s own measurement, as is Zilliz Cloud tiered storage hitting 90%+ cache hit rates and up to 87% storage cost savings. Qdrant TurboQuant’s half-the-memory-of-SQ and up-to-8x compression is likewise Qdrant’s own measurement. Treat all three the way you treat manufacturer-quoted fuel economy. And note that Milvus 3.0 is one week old, so no independent benchmark exists yet. If you see an article quoting 3.0 performance numbers today, be suspicious of the source.

The practical answer here comes down to one thing. Run ANN-Benchmarks or VectorDBBench yourself, with your embeddings, your dimensionality, your filter conditions, and your hardware. 1536 dimensions and 384 dimensions are completely different games, and rankings routinely flip the moment metadata filters enter the picture. An architecture chosen on someone else’s benchmark usually turns into regret in the first month of production.

4. Full Pricing and Plan Comparison

Pricing is the most misunderstood area in this entire vector database comparison. Pinecone’s Read/Write Unit rates in particular are quoted all over the internet at roughly half the official figures. Everything below comes from official pricing pages.

[Cost of entry — ordered by minimum monthly spend]
pgvector         : $0        (open source, you only pay to host Postgres)
Pinecone Builder : $20/mo    (flat rate, includes 10GB storage)
Weaviate Flex    : from $45/mo  (PAYG, raised from $25 in the Oct 2025 overhaul)
Pinecone Standard: $50/mo    (minimum spend — NOT a flat rate)
Weaviate Premium : from $400/mo (prepaid contract)
Pinecone Enterprise: $500/mo (minimum spend, 99.95% SLA)
Qdrant / Zilliz  : usage-based — no published unit prices, contact them directly

💰 Official Pinecone Pricing

Plenty of comparison articles list Pinecone Read Units at $8.25 per million and Write Units at $2.00 per million. The official Standard figures are $16–18 per million RU and $4–4.50 per million WU. If you built your budget model on those wrong numbers, your actual invoice will be double what you planned. There’s no official record of when a price change happened, so rather than asserting “they raised prices,” it’s safer to remember it as this is what the official price is right now.

💰 Official Weaviate Pricing

The thing you must not miss about Weaviate is that the billing unit is “one million dimensions.” It’s calculated as vector count × dimensionality, not vector count — so using a 1536-dimension embedding model costs 4x what a 384-dimension model costs for the same number of documents. Your embedding model choice is your infrastructure cost decision. On top of that, the pricing was completely overhauled in October 2025: the old Serverless and Enterprise tiers were retired in favor of Flex and Premium, and the entry price rose from $25 to $45. For the record, the “Plus $280” tier some articles mention does not exist on the official page. The free Sandbox gives you 100,000 objects / 1GB memory / 10GB disk / 1 collection / up to 3 tenants, and Dedicated supports roughly 40 regions across major clouds while lower tiers are region-restricted.

💰 Qdrant, Zilliz, and pgvector

Now let’s talk about the hidden costs. First, none of the five publishes an official price list in Korean won (KRW) — relevant if you’re budgeting for a Korean-market deployment. Everything is billed in USD, so exchange-rate swings land straight in your budget, and any “₩X per month” figure you’ve seen somewhere is one person’s arbitrary conversion, not an official price. Second, “minimum spend” and “flat rate” are completely different things. Pinecone Standard’s $50 is a minimum spend, not a flat fee, so RU/WU charges stack on top of it as traffic grows. Builder’s $20, by contrast, is flat and therefore predictable. Third, “free” self-hosting is a number with the labor cost removed. Running Qdrant or Milvus yourself costs nothing in licensing, but backups, monitoring, upgrades, and incident response eat your team’s time. If you have no infrastructure owner, a managed $50 plan is frequently cheaper than self-hosting. If you’re curious about the underlying cloud account economics, reading this alongside AWS vs GCP vs Azure cloud provider comparison will make your total cost of ownership (TCO) math considerably more accurate.

5. Final Recommendations by User Type

🎯 1) Teams already running PostgreSQL with fewer than 10 million vectors

• Best choice: pgvector
• Why: Adopting a new database means creating a sync pipeline and one more thing to operate. Simply being able to commit the source record and its embedding in the same transaction eliminates half your consistency bugs. With an HNSW index, the general consensus is that at this scale it’s practically on par with a dedicated vector database. Just make absolutely sure your version is 0.8.2 or higher before you start.

🎯 2) Early-stage startups and solo developers with no infrastructure engineer

• Best choice: Pinecone Builder or Qdrant Free
• Why: Pinecone Builder gives you 10GB of storage plus 5M WU and 2M RU for a flat $20/month, so the invoice never spikes. If your budget is literally zero, Qdrant’s free-forever tier (0.5 vCPU / 1GB RAM / 4GB disk) has no time limit and works well for the prototype stage.

🎯 3) B2B SaaS where per-customer data isolation is mandatory

• Best choice: Weaviate
• Why: Multi-tenancy by itself is not Weaviate’s alone — Qdrant shipped hierarchical multi-tenancy (tenant promotion) in v1.16, and Milvus 2.6 strengthened its own. The real reason to pick Weaviate is that tenant isolation and native BM25 hybrid search come combined in one product. B2B document search is full of queries that must match exactly (contract numbers, SKUs), which makes per-tenant hybrid effectively mandatory, and Object TTL additionally automates contractual data-destruction deadlines. If you need isolation alone rather than all three, Qdrant is a perfectly good runner-up. Just remember that Weaviate’s billing is dimension-based, so run a cost simulation first if you’re using high-dimensional embeddings.

🎯 4) Enterprises already running a data lake (Iceberg/Parquet)

• Best choice: Milvus 3.0
• Why: Lake-native indexing lets you query Parquet, Lance, Iceberg, and Vortex tables without copying them. The ETL job that replicates tens of terabytes into a vector database — and the double-storage bill that comes with it — disappears entirely. That said, it’s one week old, so validate in staging first, and if stability is your top priority, consider running the GA 2.6 line in parallel.

🎯 5) Cost-sensitive teams that still won’t compromise on production RAG quality

• Best choice: Qdrant
• Why: TurboQuant halving memory versus scalar quantization is the deciding factor. Since RAM is a large share of what a vector database costs, that saving flows straight through to your infrastructure bill. Native sparse plus RRF fusion also means hybrid search takes only a few lines of code.

🎯 6) Mid-scale teams: 10M–100M vectors, no data lake, not on Postgres either

• Best choice: Qdrant if you have someone to run it, Pinecone Standard if you don’t
• Why: This is actually the most common production RAG deployment, and it falls straight through the cracks between the thresholds above. pgvector gets uncomfortable around ten million vectors as index build time and memory climb, while Milvus 3.0’s lake-native indexing delivers nothing without a lake and leaves you holding the distributed-operations complexity. So the deciding question isn’t scale — it’s whether you have a person to run this. If someone owns backups, monitoring, and upgrades, Qdrant gives you the best cost-per-quality thanks to memory efficiency (TurboQuant) and native hybrid. If nobody does, Pinecone Standard removes the ops headcount entirely. Just budget for the fact that Standard is a $50/month minimum spend with RU/WU stacking on top, not a flat fee.

🎯 7) Regulated industries (finance, healthcare) where SLA and audit requirements come first

• Best choice: Pinecone Enterprise, Zilliz Cloud Business Critical, or Qdrant Private Cloud
• Why: Ranking these by SLA number alone will actually mislead you. At top tier it’s Pinecone Enterprise 99.95%, Qdrant Standard multi-AZ 99.95%, and Zilliz Cloud Business Critical 99.99% with multi-replica — availability is comparable across the board, and Zilliz publishes the highest figure. The real differentiators are contractual and audit-related. Pinecone Enterprise bundles HIPAA, audit logs, and BYOC, with BYOC deploying into your own cloud account on a zero-access basis. Zilliz Cloud’s Business Critical is the plan its official documentation explicitly targets at healthcare, finance, and mission-critical systems, and it comes with BYOC (99.95%) as well — so it belongs on your shortlist if you have regulatory requirements. If data physically cannot leave your perimeter, Qdrant’s Private Cloud (fully isolated dedicated deployment) or self-hosting is the realistic answer.

🎯 8) Teams that need to ship internal document search or a knowledge base fast

• Best choice: Weaviate or Pinecone
• Why: Internal documents are full of keywords that must match exactly — product names, employee IDs, policy numbers — so pure vector search fails on them. Options where hybrid comes standard, like Weaviate’s alpha fusion or Pinecone’s full-text index (BM25 + Lucene syntax), cut development time substantially. If you’re still deciding which LLM to pair it with, ChatGPT vs Claude vs Gemini AI model comparison will help.

6. Practical Tips and Common Mistakes

✅ Tip 1) Check your pgvector version today

Run SELECT extversion FROM pg_extension WHERE extname = 'vector';. Anything below 0.8.2 is exposed to CVE-2026-3172 — a vulnerability where a user who can build HNSW indexes with parallel workers may leak data from other relations or crash the server. If you’re on managed Postgres, confirm when your provider moved to 0.8.2 or higher; if you can’t upgrade right away, setting max_parallel_maintenance_workers = 0 to block parallel HNSW builds is your interim defense. Ideally, go all the way to the current 0.8.6, because 0.8.3 also fixed potential index corruption during HNSW vacuuming.

✅ Tip 2) Hybrid search is no longer optional

In production RAG in 2026, hybrid search (BM25 + vectors) has become the default. On knowledge-intensive corpora, pure vector search misses exact-match queries like proper nouns, code identifiers, and numbers. The problem is that this is where the maturity gap between products is widest.

Doing hybrid on pgvector means writing your own fusion logic, RRF or otherwise. It’s doable, but that code becomes an asset requiring ongoing tuning and maintenance. “Is hybrid a hard requirement?” is the single most practical question for deciding whether you stay on pgvector or leave.

✅ Tip 3) Revisit embedding dimensionality as a cost decision

Weaviate bills per million dimensions. Embedding one million documents at 1536 dimensions is 1.536 billion dimensions; a 384-dimension model gives you 384 million. If retrieval quality holds up, dimensionality reduction or a smaller model is an immediate 4x saving. Even outside Weaviate, dimensionality drives every vector database’s cost through memory usage. Layer on quantization — Qdrant’s TurboQuant, Weaviate’s RQ quantization, or Milvus’s RaBitQ — and the savings grow further.

✅ Tip 4) Design around Pinecone’s hard limits from day one

Some limits really hurt when you hit them in production. 40KB of metadata per record — any design that stuffs the full document text into metadata dies right here. top_k capped at 10,000 on general indexes, with query results capped at 4MB — if your pipeline pulls a generous candidate set for a reranker, you have plenty of headroom, and in practice you’ll usually hit the 4MB result ceiling first. The 1,000 ceiling only bites if you rerank off a sparse index. Mistaking that sparse-only 1,000 for a global Pinecone limit and needlessly shrinking a dense candidate pool is a common design error. $in/$nin capped at 10,000 values per operator — passing user permission filters as an ID list will blow up as the organization grows. And sparse indexes are limited to 10 upserts/sec and 100 QPS, so plan your bulk initial load schedule around that throughput.

✅ Tip 5) Don’t let Weaviate versions get stale

Weaviate patches bugs and security issues only in the three most recent minor versions (1.36/1.37/1.38). Releases come roughly every two months, so leaving it alone for six months pushes you outside the support window. You’re better off putting a quarterly upgrade slot on the team calendar and leaving it there.

✅ Tip 6) Decide on Milvus 3.0 by asking “do we have a lake?”

3.0’s lake-native indexing only changes the game for organizations that already have open-table-format data in object storage. If your data lives in Postgres or an application database to begin with, 3.0’s core value never materializes and you’re left holding the operational complexity of a distributed architecture. It’s also one week old, so there are no independent benchmarks yet. Validate it in staging with your own data before you move, and if stability is paramount, the 2.6.x line that went GA on Zilliz Cloud on 20 January 2026 remains a perfectly rational choice.

✅ Tip 7) Cost out the “we can always migrate later” step before you need it

This article’s conclusion is “start with pgvector,” and that advice only holds if you know what the moving step actually costs. The good news first: you generally do not need to re-embed. Vectors are raw float arrays you can export and import as-is, so you don’t pay the embedding API again. A full re-embed only happens if you’re changing models at the same time.

What actually costs money and time is the other four things. First, index rebuild time — HNSW builds slowly and eats memory, so at scale the schedule is dominated not by the transfer but by how long the new side takes to finish building indexes. Second, ID and metadata schema mapping — every product has different ID type constraints, metadata/payload models, and filter syntax, so you end up rewriting your filter queries. Third, the dual-write window — a zero-downtime cutover means writing to both systems for a while and diffing the results, and during that window you pay for both. Fourth, retrieval quality regression testing — a different engine ranks the same query differently, so your golden-set evaluation has to be rerun.

This is what “lock-in,” listed as Pinecone’s biggest weakness in the table in section 1, actually means. Pinecone has no self-hosting path (BYOC is a separate contract), so the moment you decide to leave you must stand up replacement infrastructure from scratch and then pay all four costs above. Qdrant, Milvus, and pgvector at least leave you the exit of “keep running the same engine on our own servers.” Writing and running an export script once, at adoption time, tells you up front whether that cost is one you can absorb.

❌ Common mistake 1) Choosing an architecture from someone else’s benchmark

As we saw, published figures disagree by an order of magnitude. Change the dimensionality, filter conditions, or hardware and the rankings themselves flip. Narrowing to two candidates and measuring them on your own data costs half a day — much cheaper than the six months you’ll lose to the wrong choice.

❌ Common mistake 2) Counting self-hosting as “free”

An Apache 2.0 license means the license fee is zero, not that operating costs are zero. Backups, restore drills, monitoring, version upgrades, and incident response are all your team’s hours. In organizations without an infrastructure owner, managed pricing is usually the cheaper option.

❌ Common mistake 3) Putting quoted prices into a budget without verifying them

Pinecone’s widely quoted RU/WU rates are off from the official ones by roughly 2x, Weaviate’s entry price changed from $25 to $45 in October 2025, and pgvector “0.9” doesn’t exist at all. Getting in the habit of opening the official pricing page once before anything goes into a budget document will save you an awkward moment in a meeting later.

7. Frequently Asked Questions (FAQ)

Q. What’s the first question to ask in a vector database comparison?

“Are we already running PostgreSQL?” If you are and you’re under ten million vectors, pgvector is the default, and adopting a dedicated vector database means manufacturing new costs for yourself in the form of another system to operate and a sync pipeline. The next question is “will we pay for managed or run it ourselves?”, and the last is “is hybrid search a hard requirement?” Those three questions narrow five options down to two.

Q. Is pgvector good enough for production RAG?

It depends on scale and requirements. With an HNSW index, the general consensus is that it’s practically on par with a dedicated vector database at around the one-million mark, and managing embeddings in the same transaction as the source data is a genuine advantage. That said, hybrid search isn’t built in, so you have to fuse tsvector and vector distance yourself in application code. Whether you can absorb that implementation and maintenance burden is the deciding factor.

Q. Is the latest pgvector version 0.9?

No. 0.9 does not exist. As of 2 August 2026 the latest release is 0.8.6 (2026-07-29). Several tech blogs list it incorrectly as 0.9, so be careful. And since anything below 0.8.2 is vulnerable to CVE-2026-3172, checking your version is a security matter, not a trivia matter.

Q. Where’s the best place to start for free?

It depends on what you’re doing. Qdrant Free is free forever with no time limit, giving you 0.5 vCPU / 1GB RAM / 4GB disk plus free cloud inference on selected models — great for prototypes. Weaviate Sandbox gives 100,000 objects / 1GB memory / 10GB disk / 1 collection / up to 3 tenants, which suits experimenting with hybrid search. Pinecone Starter includes 2GB of storage, 2M WU and 1M RU per month, and up to 5M embedding tokens. Zilliz Cloud also offers a tier you can start on for free, but its limits aren’t published as numbers on the official pricing page, so check them in the console before you compare. If you can run infrastructure yourself, pgvector and self-hosted Qdrant and Milvus are completely free.

Q. People say Pinecone is expensive — what does it actually cost?

Officially, Standard is $16–18 per million RU on reads and $4–4.50 per million WU on writes, storage is $0.33/GB/month, and there’s a $50 monthly minimum spend. Enterprise runs $24–27 per million RU and $6–6.75 per million WU with a $500/month minimum. Figures floating around the internet like “RU $8.25” don’t match the official page, so don’t use them in budget calculations. If your traffic is modest, the flat $20/month Builder plan is the safest choice for cost predictability.

Q. Should I move to Milvus 3.0 right now?

If you already run a data lake, it’s well worth evaluating. The core features are lake-native indexing that queries Parquet, Lance, Iceberg, and Vortex tables without copying them, and Loon, the new storage engine that reduces read amplification. That said, it shipped on 29 July 2026 and is only a week old, with no independent benchmarks. Validate in staging before you migrate, and if stability comes first, the 2.6.x line that went GA on Zilliz Cloud in January 2026 remains a strong choice.

Q. Why is my Weaviate bill higher than I expected?

Because the billing unit is “one million dimensions,” not vector count. It’s computed as vector count × dimensionality, so a 1536-dimension model costs 4x what a 384-dimension model costs for the same number of documents. On top of that, the October 2025 pricing overhaul raised the entry price from $25 to $45. Switching to a lower-dimensional embedding model or applying quantization is the most direct way to cut the bill.

Q. Can I pay in Korean won (KRW)?

None of the five publishes an official KRW price list — worth knowing if you’re budgeting for a Korean-market rollout. Everything is billed in USD, so exchange-rate movement flows straight into your costs. The “₩X per month” figures you see in other comparison articles are arbitrary conversions, not official prices, so it’s safer to write budgets in USD and set aside a separate allowance for FX movement. The same applies to any team billing in a non-USD local currency.

Q. Where do I find Qdrant Cloud’s exact pricing?

Qdrant does not publish concrete unit prices on its official pricing page. All that’s disclosed is the structure: billing dimensions of compute (vCPU), memory (GB), storage (GB), backup storage, and paid inference tokens, calculated hourly. Numbers circulating online like “$0.078/GB-hour” or “from $25/month” can’t be officially verified, so don’t take them at face value. If you need a real budget figure, configure your desired spec in the console or contact sales.

8. Conclusion: The Real Takeaway from This 2026 Vector Database Comparison

The vector database market in August 2026 has already moved past “who’s fastest.” Milvus is solving for querying where the data already lives with lake-native indexing; Qdrant for the same recall on half the memory with quantization; Weaviate for hybrid and multi-tenancy; Pinecone for fully managed operation with zero ops burden; and pgvector for not introducing new infrastructure at all. They aren’t substitutes for each other — the right answer changes with your organization’s situation.

So the practical conclusion of this vector database comparison is this: first work out whether you can start with pgvector, and only move to a dedicated vector database once you’ve confirmed that hybrid search or scale rules it out. A significant share of teams that adopt a flashy dedicated database from day one end up spending their time on operational overhead and sync bugs. Conversely, teams that need hybrid and stubbornly stay on pgvector pay for it in retrieval quality. The deciding factor should be requirements, not preference.

Finally, there’s one thing to do before the day is out. If you’re running pgvector, check your version. Versions 0.6.0 through 0.8.1 are affected by CVE-2026-3172, and 0.8.2 contains the fix. If you take exactly one thing from this article, make it that line rather than any benchmark table.

[Summary: the right pick for your situation]

Already on PostgreSQL + under 10M vectors
  → pgvector (0.8.2 minimum, required / latest is 0.8.6)

No infra staff + cost predictability above all
  → Pinecone Builder ($20/mo flat, 10GB, 5M WU / 2M RU)

Prototyping on a zero budget
  → Qdrant Free (free forever, 0.5 vCPU / 1GB RAM / 4GB disk)

B2B SaaS needing per-customer data isolation
  → Weaviate (multi-tenancy + BM25 alpha hybrid / watch dimension billing)

Enterprise with an existing data lake (Iceberg, Parquet)
  → Milvus 3.0 (lake-native, query without copying / validate in staging first)

Cutting memory cost while holding production RAG quality
  → Qdrant (TurboQuant: half the memory of SQ, up to 8x compression)

10M-100M vectors, no data lake, not on Postgres either
  → Qdrant if you have someone to run it, else Pinecone Standard ($50/mo min)

HIPAA, audit logs and data residency are contractual requirements
  → Pinecone Enterprise (from $500/mo) / Zilliz Business Critical (99.99%)
     / Qdrant Private Cloud - all three clear 99.95% on SLA

⚠️ Applies to all five: no official KRW pricing (USD billing only),
   and public benchmarks all use different conditions — measure it yourself

Take just two candidates and measure them with your data, your dimensionality, and your filter conditions. That half day will give you a more accurate answer than this entire article. 🚀