pgvector vs Qdrant vs Pinecone: Which Vector DB for RAG?

On pgvector vs Qdrant vs Pinecone, the short answer is: start with pgvector if your app already runs on Postgres, move to Qdrant when vector search becomes a workload of its own that you want to tune or self-host, and choose Pinecone when nobody on your team should be operating a database at all. All three store embeddings and return nearest neighbours well enough for RAG; they differ in who runs them, how they filter and what makes the bill grow.

Based on the vendors' documentation and pricing pages, checked October 2026: the pgvector README, Supabase pricing and compute sizing guide, Qdrant pricing, capacity planning and filtering docs, and Pinecone pricing, cost and limits docs. We did not benchmark the three ourselves: cost figures are arithmetic on list prices, and any speed figure is credited to the vendor that published it.

That is a deliberate limit. A latency chart from someone else's dataset tells you little about yours, and this page would rather give you the sums and the questions than a number you cannot reproduce. For what the model side of a RAG system costs, see our LLM API pricing comparison, the hub for this topic.

pgvector vs Qdrant vs Pinecone at a glance

Two axes explain most of that table: whether the thing is a general database or built only for vectors, and whether you run it or somebody else does.

pgvector: the vector store you already have

pgvector is the right first choice when your application data is already in Postgres. It adds a vector column type, distance operators and two approximate indexes, HNSW and IVFFlat, so retrieval is a SQL query that can join, filter and respect the same permissions as the rest of your tables.

• Strengths. One database, one backup, one set of access rules. A chunk and its embedding are written in the same transaction, so there is nothing to keep in sync. With Row Level Security, a user's search can only return rows they may read.
• Limits. HNSW and IVFFlat index up to 2,000 dimensions (4,000 with the halfvec type). Filters are applied after the approximate index scan, so a selective filter can return fewer rows than asked; version 0.8.0 added iterative scans to compensate. And the index wants to live in RAM, which is what sets the price.
• Price, checked October 2026. The extension is free. On Supabase you pay for the instance: Pro is $25 a month with $10 of compute credit, and compute runs from $10 (Micro, 1 GB) through $110 (Large, 8 GB) to $410 (2XL, 32 GB) a month.

Our pgvector on Supabase guide has the schema, the match function and the index choices in runnable SQL.

Qdrant: an engine built for vector search

Qdrant is the pick when vector search is the product, or a large enough part of it to deserve its own tuning. It is open source, runs in a container on your own servers or as a managed cluster, and exposes the knobs that pgvector hides or lacks.

• Strengths. Filtering happens during the graph search rather than after it: Qdrant builds extra links between points that share an indexed value, so a filtered query still returns a full result set. Quantization and per-structure memory tiers let you keep a compressed copy in RAM and the originals on disk. Its docs put a single node's ceiling at around 100 million vectors, with sharding and replication beyond that.
• Limits. It is a second system. Your app database remains the source of truth, and you write the code that keeps the two in step. Filters only work well on fields you indexed, ideally before loading data. For high availability the docs recommend at least three nodes with a replication factor of two or more.
• Price, checked October 2026. Self-hosting is free. Qdrant Cloud has a free-forever cluster (0.5 vCPU, 1 GB RAM, 4 GB disk) and a Standard tier billed hourly for vCPU, memory and storage. The pricing page points to a calculator instead of a rate card, so there is no list price to quote here.

pgvector vs Pinecone: what you trade

Pinecone is the opposite bet from pgvector: nothing to size, nothing to tune, and a bill that follows usage instead of hardware. You create an index, pick a cloud region and send vectors.

• Strengths. No instance to size and no index build settings to manage. Namespaces split one index per tenant, which also cuts query cost because a query is billed on the size of the namespace it searches. Hosted embedding and reranking models are available from the same API.
• Limits. It cannot be self-hosted. It is eventually consistent, so a record you just upserted may not be searchable for a moment. The free Starter plan is limited to one AWS region. And cost scales with every query, which is pleasant at low volume and needs watching at high volume.
• Price, checked October 2026. Starter is free. Builder is $20 a month flat with caps (10 GB storage, 5M write units, 2M read units). Standard has a $50 monthly minimum, then $0.33 per GB of storage, $4 to $4.50 per million write units and $16 to $18 per million read units depending on region. Enterprise has a $500 monthly minimum.

Monthly cost at one million vectors

Here is the same illustrative workload priced three ways: one million chunks, 1,536-dimension float vectors, about 1 KB of text and metadata per chunk, 100,000 queries a month, one region and no replicas.

How the numbers are built, so you can redo them:

• pgvector. Supabase's sizing table lists one million 1,536-dimension vectors with HNSW on a 2XL instance: $25 plan plus $410 compute, less the $10 credit. At 384 dimensions the same count is listed on a Large ($110), which is why shortening vectors is the first thing to try.
• Qdrant. Its formula is vectors times dimensions times 4 bytes, plus the HNSW graph and an ID tracker, plus 20% headroom: about 7.1 GB of RAM here. With 4-bit quantization kept in RAM and the originals on disk, about 1.1 GB.
• Pinecone. Each record is roughly 7.15 KB, so the index is 7.15 GB: $2.36 a month of storage. A query costs one read unit per GB of namespace, so about 7 read units, and 100,000 queries cost $11 to $13. That is under the $50 minimum, so you pay $50.

The interesting part is where the lines cross. Pinecone's bill grows with every query; the Supabase instance costs the same whether you run one query or millions. On these inputs Pinecone's read units alone reach $425 at roughly 3.3 to 3.7 million queries a month. Below that, Pinecone is cheaper on paper. Above it, or if that Postgres instance is also serving the rest of your app, pgvector is. Two notes on the Builder plan: its usage beyond the caps is blocked rather than billed, and the initial load of about 7.1 million write units exceeds its 5 million monthly allowance, so loading takes two months or a spell on Standard.

Qdrant vs pgvector performance: what the published numbers show

There is no neutral benchmark of these three on one dataset, and we have not run one. What exists is each vendor measuring itself.

• pgvector. Supabase reports one million OpenAI embeddings with HNSW on its 2XL instance at 560 queries per second, 0.036 seconds mean latency and 0.99 accuracy, and 950 queries per second on a 4XL.
• Qdrant. Qdrant maintains an open-source benchmark suite comparing several engines on identical machines. The page was last updated in 2024 and does not include pgvector or Pinecone.
• Pinecone. Serverless has no instance to size, so there is no figure to compare. For steady high read volume it offers Dedicated Read Nodes on the Standard plan.

Which one to pick: a decision tree by scale

Work down the list and stop at the first line that describes you. The thresholds come from the vendors' own sizing documents.

Whichever you pick, keep the chunk text and document IDs in your own database and treat the vector store as an index you could rebuild. That makes the choice reversible, and it is the reason starting on pgvector costs you so little: when you outgrow it, the data is already where a migration script can read it.

Two alternatives sit outside this comparison. If your queries are mostly exact terms, product codes or names, Postgres full-text search may serve better than embeddings, and Supabase documents a hybrid of the two. And if the whole corpus fits in a model's context window, none of this is needed; our RAG vs fine-tuning guide covers that decision. For agents rather than documents, see AI agent memory options compared. The AI SaaS Builder program takes the pgvector route on Supabase and builds retrieval into a working product.

pgvector vs Qdrant vs Pinecone: FAQ