AI

Vector databases compared — pgvector, Qdrant, Pinecone, Chroma

Four vector databases for RAG in 2026 — real free-tier limits, pricing, features, and honest recommendations for when to pick each.

Picking a vector database is the decision that most RAG tutorials skip past. The tutorial uses Chroma or Pinecone in-memory, works fine on 50 docs, and then falls over silently the first time production data hits it. This is a working comparison of the four options that actually cover 95% of use cases in 2026: pgvector, Qdrant, Pinecone, and Chroma. Real free-tier limits, real pricing, and a decision matrix at the bottom.

Prerequisite reading: if RAG itself is new, the 4-step RAG pipeline walkthrough covers what a vector DB does inside the loop before this article picks between them.

The four options in one sentence each

  • pgvector — a Postgres extension. Vectors live in the same database as the rest of your app data.
  • Qdrant — a dedicated open-source vector database, written in Rust, with a generous free cloud tier.
  • Pinecone — a hosted-only, serverless vector database with the strongest managed operations story and the highest lock-in.
  • Chroma — a developer-friendly, local-first vector database that runs in-process for prototypes and scales to Chroma Cloud when needed.

What to optimize for

Before comparing feature grids, decide which one of these matters most for the workload:

  1. Operational surface — can the team handle running a separate database, or should vectors live in Postgres?
  2. Scale target — 10K vectors or 100M?
  3. Query latency budget — 50ms p99 or 500ms is fine?
  4. Metadata filtering complexity — simple tags, or complex boolean expressions?
  5. Cost sensitivity — startup on a ₹5000/mo budget, or funded team?

Picking wrong on axis 1 (operational surface) is the most expensive mistake. Adding a second database to a stack that already has Postgres roughly doubles the on-call surface: another daemon, another backup routine, another auth model. Adding vectors as a Postgres extension avoids all of that at the cost of ceiling on scale.

pgvector — vectors as a Postgres extension

pgvector is a Postgres extension (currently at version 0.8.x as of 2026) that adds a vector column type and two index types: HNSW and IVFFlat. The whole thing is one CREATE EXTENSION vector; statement inside any Postgres instance — self-managed, RDS, Supabase, Neon, or any managed Postgres provider.

Basic use:

CREATE EXTENSION vector;

CREATE TABLE docs (
    id       bigserial PRIMARY KEY,
    content  text,
    metadata jsonb,
    embedding vector(384)
);

CREATE INDEX ON docs USING hnsw (embedding vector_cosine_ops);

Strengths:

  • Vectors live next to the rest of the data, so JOINs, transactions, and row-level security work as normal.
  • HNSW indexes are competitive with dedicated vector databases up to a few tens of millions of vectors.
  • pgvector 0.8 added iterative HNSW scans that cooperate with WHERE filters — earlier versions could return fewer results than requested when filters were selective.
  • No new database to run, back up, or secure.
  • Free-tier hosted Postgres (Supabase, Neon) includes pgvector at no extra cost.

Weaknesses:

  • Index build time is slow at high volume — a 10M-vector HNSW index can take hours to build.
  • Postgres itself has to be sized for both relational and vector workloads, which can lead to noisy-neighbor CPU contention.
  • No native reranking, no built-in hybrid (dense + sparse) search — those layers are add-ons.

Best for: most applications under 20M vectors, especially any product already using Postgres.

Qdrant — dedicated open-source, Rust-fast

Qdrant is a purpose-built vector database written in Rust. Self-host it (Docker image, Kubernetes chart, or binary), or use Qdrant Cloud with a free tier.

Basic use from Python:

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient(url="http://localhost:6333")

client.create_collection(
    collection_name="docs",
    vectors_config=VectorParams(size=384, distance=Distance.COSINE),
)

client.upsert(
    collection_name="docs",
    points=[
        PointStruct(id=1, vector=[0.1] * 384, payload={"topic": "billing"}),
    ],
)

Free tier (Qdrant Cloud) — verified against qdrant.tech/pricing:

  • 1 GB RAM, 4 GB disk, 0.5 vCPU
  • One single-node cluster
  • Roughly 1M vectors at 768 dimensions before RAM caps out

Strengths:

  • Very fast on both indexing and query — competitive with the fastest dedicated stores.
  • Rich payload filtering: nested keys, range queries, boolean expressions.
  • Fully open-source under Apache 2.0 for self-hosting.
  • Hybrid search (dense + sparse) is built in.
  • Free tier is enough for a real early-stage product, not just a toy.

Weaknesses:

  • Separate database to run and secure if self-hosted.
  • Cloud tier scales primarily by picking bigger nodes, not by serverless usage.
  • Ecosystem is smaller than Postgres — fewer ORMs, fewer BI tools that speak to it directly.

Best for: RAG-first products expecting to grow past 10M vectors, or teams that want a dedicated vector store without vendor lock-in.

Pinecone — hosted-only, managed operations

Pinecone is a serverless vector database. There is no self-hosted option. Every operation goes through Pinecone’s API.

Basic use:

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="...")

pc.create_index(
    name="docs",
    dimension=384,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

index = pc.Index("docs")
index.upsert(vectors=[("id_1", [0.1] * 384, {"topic": "billing"})])

Free tier (Starter) — verified against pinecone.io pricing:

  • 2 GB storage
  • 2M write units per month
  • 1M read units per month
  • Up to 5 indexes
  • AWS us-east-1 only
  • No RBAC, no SLAs
  • Roughly 350K uncompressed vectors (or ~1.5M with quantization)

Paid usage runs $4 per million write units, $16 per million read units, and $0.33 per GB per month for storage. Standard plan starts at a $50/mo minimum. Enterprise is $500/mo minimum.

Strengths:

  • Zero operational overhead — no cluster to run, no upgrades, no backups.
  • Serverless scales up and down without a config change.
  • Best-in-class managed hybrid search and reranking as first-party features.
  • Well-documented, stable API.

Weaknesses:

  • Highest per-vector cost at scale of the four options here.
  • No self-host escape hatch. Cost trajectory is entirely Pinecone’s to decide.
  • Region availability on the free tier is one region. Latency-sensitive apps outside the US will feel it.
  • Free tier is genuinely small in vector count once real production embeddings land.

Best for: funded teams that want to write zero ops code, tolerate the pricing, and don’t mind the lock-in.

Chroma — local-first, developer-friendly

Chroma is designed to feel like SQLite for vectors — you install a Python package and start using it, no server required.

Basic use covered in detail in the RAG pipeline walkthrough; the summary is one import and three method calls.

Deployment modes:

  • EphemeralClient() — in-memory, cleared on process exit.
  • PersistentClient(path=...) — writes to a local directory.
  • HttpClient(host=..., port=...) — connect to a self-hosted Chroma server.
  • Chroma Cloud — hosted, usage-based pricing.

Chroma Cloud pricing — verified against Chroma Cloud pricing page:

  • Starter tier: $0/month base, $5 in initial credits, usage-based
  • Usage rates: $2.50 per GiB written, $0.33 per GiB-month stored, $0.0075 per TiB queried, $0.09 per GiB egress
  • Team plan: $250/month platform fee
  • Self-host on any small VM: roughly $32-65/month at 1M-10M vectors on EC2

Strengths:

  • Fastest developer experience of any option here — write code, run code, done.
  • Apache 2.0 open source, self-hostable at any scale.
  • API is small and stable; migration from local Chroma to Chroma Cloud is a one-line change.
  • Excellent for prototypes and internal tools.

Weaknesses:

  • Not the fastest at high query volume — Qdrant and Pinecone win on raw throughput.
  • Ecosystem is younger; fewer integrations with observability tools.
  • Chroma Cloud’s Team platform fee is high for small teams that only need a bit more than Starter.

Best for: prototypes, internal tools, and anything under a few million vectors where developer speed beats micro-optimized latency.

Head-to-head at a glance

FeaturepgvectorQdrantPineconeChroma
Self-hostableYes (via Postgres)YesNoYes
Managed cloudVia any Postgres hostQdrant CloudPinecone (only option)Chroma Cloud
Free tierFree with Supabase/Neon1 GB RAM, 4 GB disk2 GB storage$5 credits, then usage-based
Scale ceiling~20M vectors comfortably100M+100M+10M+
Metadata filtersSQL-nativeRich, nestedRichBasic to rich
Hybrid searchAdd-onBuilt-inBuilt-inAdd-on
LicensePostgres + PostgreSQL licenseApache 2.0ProprietaryApache 2.0
Best DX forSQL-first teamsRAG-first teamsOps-averse teamsFast prototyping

Which one to pick

  • Already using Postgres? Start with pgvector. Migrate later only if a scale wall actually shows up.
  • Building a RAG-first product with real growth expected? Qdrant, self-hosted or Cloud, is the best value.
  • Funded team that wants zero ops? Pinecone. Accept the pricing and lock-in as the trade.
  • Prototype or internal tool under a few million vectors? Chroma, local persistent mode. Move to Cloud only when hosting matters.
  • Under a ₹5000/mo budget and want a real free path? Qdrant Cloud free tier, or self-hosted pgvector on Supabase’s free tier.

Two decisions the framework will not make for you: (1) whether the team is prepared to run a second database, and (2) whether vendor lock-in is a real risk for the business. Both answers matter more than any benchmark.

Migration between them

Moving from one vector DB to another is easier than switching relational databases, because the schema is basically (id, embedding, metadata, document_text) everywhere. The typical migration:

  1. Export from source: iterate the collection, serialize each row as JSON.
  2. Rebuild embeddings only if the target uses a different embedding model — otherwise reuse the vectors as-is.
  3. Import into target: use its bulk-insert API (Pinecone upsert, Qdrant upsert, pgvector COPY, Chroma add).
  4. Reindex once at the end, not per row.

For collections under 10M vectors, a full migration usually completes in an afternoon. The harder part is updating the retrieval code — each client’s query API is slightly different, so a thin abstraction over “search N nearest with filter X” pays off before the second migration.

Common mistakes when picking

  • Choosing Pinecone for a prototype. The free tier will feel fine until the app is 50 users deep and the write-unit budget runs out mid-day. Chroma or pgvector is a saner default.
  • Choosing pgvector for a 100M-vector workload. The HNSW index build alone will take days. Dedicated stores exist for a reason once you’re past ~20M vectors.
  • Ignoring the metadata filter story. If the retrieval needs “docs from last 30 days AND tagged changelog AND from customer X”, check that the DB’s filter language handles that in one query without post-filtering — post-filter loses recall.
  • Assuming benchmarks apply. Vendor benchmarks use ideal workloads. Test with actual embeddings and actual query patterns before committing.

Bottom line

For most projects in 2026, the honest ranking is: pgvector if Postgres is already in the stack, Qdrant if not, Chroma for prototypes, and Pinecone only when zero ops is worth the price. Every other vector database on the market — Weaviate, Milvus, Vespa, Redis, Elasticsearch dense-vector — is a variation on those four trade-offs. Pick based on operational surface first, features second, benchmarks last.