Qdrant vs Pinecone vs Chroma: Free Vector DB for RAG

On this page
  1. The 30-Second Answer
  2. What "Free" Actually Means Here
  3. Qdrant: Open-Source Rust + Generous Managed Tier
  4. Pinecone: The Managed-First Default
  5. Chroma: The Local-First Default
  6. Head-to-Head: Free Tier Limits
  7. Decision Tree
  8. Self-Host vs Managed, and the LLM Layer
  9. FAQ
Quick answer: Pick Chroma for a local notebook demo, Pinecone for managed hosting with 2 GB storage and 1M read units/month on Starter, or Qdrant for a free managed prototype cluster with 1 GB RAM and 4 GB disk plus a self-host option. Qdrant Cloud suspends an idle free cluster after one week and deletes it after four weeks without reactivation.

The vector database is the load-bearing piece of a RAG pipeline nobody talks about until it breaks. Embeddings are commoditised (Cohere, OpenAI, Voyage, open models); the harder question is where vectors live, how fast you search them, and how big the bill gets. Qdrant, Pinecone, and Chroma all let you start at $0 with no credit card — but they sit on very different points of the open-source-vs-managed and local-vs-cloud spectrum.

The 30-Second Answer

Database Free path License Free ceiling Best for
Qdrant Free managed cloud cluster, no card; inactivity deletion applies Apache 2.0 1 GB RAM + 4 GB disk on managed; self-host resources depend on your machine Production RAG with hybrid search, payload filters, no vendor lock-in
Pinecone Starter plan: 2 GB storage, 5 indexes, no card Closed-source SaaS 2 GB storage, 1M read units, 2M write units per month Zero-ops managed RAG, fastest first-vector-to-production
Chroma 100% local — pip install chromadb Apache 2.0 Bounded by your laptop's RAM and disk Local prototypes, notebooks, single-tenant desktop apps

What "Free" Actually Means Here

Three meaningfully different shapes of free:

  1. Self-host open source — Apache 2.0 code on your own box (Qdrant, Chroma, Weaviate, Milvus, pgvector). Free as in you do the work.
  2. Managed free tier — a permanent free quota on the vendor's cloud (Pinecone, Qdrant Cloud). Free as in they do the work, within limits.
  3. Trial credits — a one-time $50–$300 wallet (Weaviate Cloud, Zilliz). Fine for evaluation, not for shipping.

Only the first two keep a real project running past month one. That's the focus below.

Qdrant: Open-Source Rust + Generous Managed Tier

Qdrant is a Rust vector database under Apache 2.0 — the rare project with both a production-grade open-source binary and a generous managed free tier from the same team. Prototype on the free cloud, migrate the exact same data to self-host later, never touch a different query language.

The free cloud tier offers a single-node cluster with 0.5 vCPU, 1 GB RAM, and 4 GB disk, without a credit card. It is intended for prototypes. Unused free clusters suspend after one week and are deleted after four weeks of inactivity if not reactivated. Back up data you need to keep. The service exposes REST and gRPC. You get:

  • 1 GB RAM and 4 GB disk; Qdrant estimates about 1 million 768-dimensional vectors, depending on configuration
  • Full HNSW indexing, all distance metrics (cosine, dot, Euclidean, Manhattan)
  • Payload filtering — filter by metadata during the ANN search, not after (Qdrant's headline feature)
  • Hybrid search (dense + sparse in one query) since Qdrant 1.10
  • Snapshots, backups, monitoring dashboard

Self-hosting is one Docker command — no separate metadata store, no Zookeeper, no Kafka:

docker run -p 6333:6333 -p 6334:6334 
    -v $(pwd)/qdrant_storage:/qdrant/storage 
    qdrant/qdrant
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient(url="https://YOUR-CLUSTER.qdrant.io", api_key="...")
client.create_collection(
    "docs",
    vectors_config=VectorParams(size=1024, distance=Distance.COSINE),
)
client.upsert("docs", points=[
    PointStruct(id=1, vector=[...1024 floats...], payload={"title": "Hello"}),
])
hits = client.search("docs", query_vector=[...1024 floats...], limit=5)

What pushes you off: cluster resources and the inactivity deletion rule. The free single-node size is suitable for testing, but a larger workload needs a paid cluster or self-hosting. The current limits are on Qdrant's pricing page.

Pinecone: The Managed-First Default

Pinecone offers managed vector search without a cluster to size. Its Starter plan currently lists 2 GB storage, up to 5 indexes, 1M read units/month and 2M write units/month, with up to 100 namespaces per index. Pinecone says a free account can be created without a credit card.

It is serverless, but unit consumption depends on the request and index size. Use Pinecone's usage metrics to estimate how many queries the 1M monthly read units cover for your workload.

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="...")
pc.create_index(
    name="docs",
    dimension=1024,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)
index = pc.Index("docs")
index.upsert(vectors=[("doc-1", [...1024 floats...], {"title": "Hello"})])
hits = index.query(vector=[...1024 floats...], top_k=5, include_metadata=True)

What pushes you off: storage and monthly read or write limits. A busy app can use the 1M included read units quickly. Check Pinecone's current plan behavior and pricing before designing for overage or upgrading.

Chroma: The Local-First Default

Chroma (also Apache 2.0) is the lightest option. It expects to live inside your Python app the way SQLite lives inside an application as a file. The local install is the free tier — no signup, no cluster, no API key. Chroma now also has a managed Cloud Starter plan with $5 in free credits and usage-based billing beyond those credits. The comparison below uses the self-hosted edition, which has no vendor meter.

import chromadb

client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_or_create_collection("docs")
collection.add(ids=["doc-1"], documents=["Hello world"], metadatas=[{"src": "readme"}])
hits = collection.query(query_texts=["What is hello?"], n_results=5)

Chroma can embed text for you with a default sentence-transformer, so you can pass query_texts instead of pre-computed vectors — brilliant for prototypes, a footgun in production (the bundled embedder is small and English-only). For anything serious, plug in OpenAI, Cohere Embed v3, or a custom embedding function.

What pushes you off: concurrency and operations. In-process mode is single-writer; server mode (chroma run) works but its backup/replication/monitoring story is far less mature than Qdrant's. Best for "working RAG demo in five minutes," a liability once ten concurrent users hit the same index from a deployed app.

Head-to-Head: Free Tier Limits

Limit Qdrant Cloud Free Pinecone Starter Chroma (Local)
Storage 1 GB RAM, 4 GB disk (~1M vectors at 768d, vendor estimate) 2 GB Your disk
Indexes / collections Multiple in 1 cluster 5 indexes Unlimited (your file system)
Reads per month No hard cap (RAM-bound) 1 M read units Unlimited (CPU-bound)
Writes per month No hard cap 2 M write units Unlimited
Hybrid (dense + sparse) Yes Partial (region-limited) No (dense only)
Metadata filtering during ANN Yes (inside HNSW walk) Yes Yes (post-filter)
Self-host option Yes (Apache 2.0) No Yes (Apache 2.0)
Credit card to start No No No (no account needed)

The Chroma row here covers its local open-source edition; Chroma Cloud is a separate managed option. Pinecone and Qdrant Cloud are managed services. Pinecone publishes monthly read and write unit quotas on Starter; Qdrant's Free tier has a fixed small cluster and an inactivity deletion window. Both require monitoring for different reasons.

On performance, for any dataset that fits these free quotas all three should return a top-5 query under ~50 ms with healthy recall — that is the range public benchmarks show; we have not timed them ourselves. At the free tier, pick on developer experience and lock-in, not p99 by 5 ms. The Qdrant vector-db-benchmark repo and ann-benchmarks.com are the reproducible public references if you want to re-run it yourself.

Decision Tree

  • Notebook RAG demo today, no signup → Chroma. Three lines, done.
  • Real product, managed infra, zero ops → Pinecone. Cleanest upgrade path; you pay in vendor lock-in.
  • Managed prototype with a self-host exit door → Qdrant. Keep the free cluster active or move data before its inactivity deletion window.
  • Hybrid search (sparse + dense) without paying → Qdrant supports this in its free cloud and self-hosted editions; Pinecone Starter also supports dense and sparse indexes.
  • Filter by many metadata fields during retrieval → Qdrant. Payload filtering inside the HNSW walk preserves recall on selective filters.
  • Air-gapped customer environment → Qdrant or Chroma. Pinecone is out.

Self-Host vs Managed, and the LLM Layer

Self-hosting is free in money and expensive in attention. Oracle Cloud's always-free ARM tier (two cores, 12 GB RAM since June 2026, $0) comfortably runs Qdrant or Chroma for a small RAG app. What it doesn't give you free: scheduled snapshot-restore, multi-region HA, an on-call rotation, a support contract. For a hobby app those don't matter; for anything with revenue, managed starts to look cheap. Qdrant's edge is that the same query interface works both ways.

All three databases have first-class LangChain and LlamaIndex connectors (langchain-qdrant/-pinecone/-chroma, QdrantVectorStore/PineconeVectorStore/ChromaVectorStore), so integration coverage isn't a differentiator. A possible $0 stack in 2026 uses a free embedding and rerank allowance, Qdrant Cloud or local Chroma for storage, and a free Groq or Gemini model for generation. Check each provider's current allowance before assuming the whole workflow stays free.

FAQ

Is pgvector a better choice than these three?

If you already run PostgreSQL and your collection fits one box, pgvector is a serious option — one fewer service, transactional consistency, mature backups. It loses to Qdrant on filtering performance at scale and on hybrid search, and tops out earlier on throughput. Postgres already in the stack? Start there. New project? The specialised databases are easier to reason about.

Do I need to re-embed everything when I change embedding models?

Yes. Embeddings from different models aren't interoperable — an OpenAI query vector can't be searched against Cohere-embedded documents. This is the single biggest hidden cost of RAG: changing models means re-embedding your entire corpus and re-writing every vector. Plan migrations.

How big does my index need to be before I need a real database?

Rule of thumb: under 100 K vectors, a flat numpy array with cosine similarity beats any database and has zero ops. From 100 K to a few million, an in-process library like Chroma or FAISS is fine. Past 10 M vectors, you want persistence, snapshots, and a binary protocol — Qdrant, Pinecone, or Weaviate.

What is a "read unit" or "write unit" in Pinecone?

Read and write units measure database operations; usage varies by operation, index size, and result size. The Pinecone cost docs explain the calculation. Starter currently includes 1M read units and 2M write units monthly.