pip install chromadb, no signup), Pinecone for zero-ops managed hosting (2 GB Starter, no card), and Qdrant when you want a real free cloud tier (1 GB cluster, free forever) plus the option to self-host the identical Apache-2.0 binary later. Qdrant is the only one of the three with a genuine free tier and a self-host exit door.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 | 1 GB managed cloud cluster, free forever, no card | Apache 2.0 | 1 GB RAM + ~4 GB disk on managed; unlimited self-host | 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, 2M read units, 1M 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:
- Self-host open source — Apache 2.0 code on your own box (Qdrant, Chroma, Weaviate, Milvus, pgvector). Free as in you do the work.
- Managed free tier — a permanent free quota on the vendor's cloud (Pinecone, Qdrant Cloud). Free as in they do the work, within limits.
- 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 gives you one 1 GB cluster, free forever, no card — not a trial, no auto-convert to paid. It's region-pinned, has full TLS, and exposes REST + gRPC. You get:
- 1 GB RAM cluster (~1–3 million 384-dim vectors with default HNSW)
- 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: storage. 1 GB carries a personal knowledge base or internal FAQ, but a SaaS ingesting user content hits the ceiling fast. Next step is a $25 trial credit on a larger cluster, then paid tiers from ~$0.014/hour for 4 GB — or migrate to self-host.
Pinecone: The Managed-First Default
Pinecone is the easiest way to get a production-shaped URL. It's closed-source — you can't run a binary on your own hardware — but there's also no cluster to size, no HNSW params to tune, nothing to break. The Starter plan gives every account a permanent free allowance: 2 GB storage, 5 serverless indexes, 2M read units/month, 1M write units/month, up to 100 namespaces per index, no card.
It's serverless — nothing to pay when idle. One read unit ≈ one small query, one write unit ≈ one vector upserted. 2M read units is on the order of hundreds of thousands of user queries a month.
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: concurrent users, not storage. A B2C app with real traffic burns through 2M read units fast; exceed the allowance and the index is paused (Starter) or you pay overage (Standard starts at $50/month minimum). Features like >100 namespaces and on-prem push you to Enterprise.
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 Cloud is in paid private preview as of late 2025, so for free purposes it's a pure self-host story.
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 (~1–3M vectors at 384d) | 2 GB | Your disk |
| Indexes / collections | Multiple in 1 cluster | 5 indexes | Unlimited (your file system) |
| Reads per month | No hard cap (RAM-bound) | 2 M read units | Unlimited (CPU-bound) |
| Writes per month | No hard cap | 1 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) |
Two things stand out. Chroma isn't really on the same axis — it's a library, not a service. And between the two services, Qdrant's cap is storage only: Pinecone pauses your index if you blow the read-unit budget, while Qdrant Cloud just slows down if you saturate the cluster, but queries keep flowing.
On performance, for any dataset that fits these free quotas all three return a top-5 query under ~50 ms with healthy recall. 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.
- Real free tier you can leave running, with a self-host exit door → Qdrant. Migration to a Docker container is one snapshot restore away.
- Hybrid search (BM25 + dense) without paying → Qdrant, the only one shipping full sparse-dense hybrid free.
- 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 common $0 stack in 2026: Cohere Embed v3 + Rerank v3 for embeddings/rerank, Qdrant Cloud or local Chroma for storage, and Groq Llama 3.3, Gemini 2.5 Flash, or Together AI's free model tier for generation.
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?
One read unit roughly equals one similarity query returning up to 10 results from a small index; one write unit roughly equals one vector upserted. The actual conversion depends on index size and result count — the Pinecone docs have the exact formula. For most chatbot workloads, 2M read units a month covers far more queries than you'd expect.