Tutorials
Vector Database Showdown: Pinecone vs Weaviate vs Chroma
A hands-on Python tutorial comparing Pinecone, Weaviate, and Chroma. Get working code for all three vector databases and find out which one actually fits your project.
April 7, 2026
What You'll Learn
A growing majority of production RAG pipelines now rely on a dedicated vector database. And if you're building anything with AI in 2026, you're going to need one.
By the end of this tutorial, you'll have working Python code for all three major vector databases — Pinecone, Weaviate, and Chroma. You'll understand how they differ in practice (not just on paper), and you'll know exactly which one fits your project. We're building a simple semantic search system with each database so you can compare the developer experience side by side.
This hands-on vector database comparison gives you working code you can actually run, not just read.
Prerequisites
Before we start, you'll need:
- Python 3.10 or later
- An OpenAI API key for generating embeddings (or any embedding provider)
- A free Pinecone account
- About 30 minutes
Basic Python knowledge is assumed. If you've used pip install before, you're good.
Why Vector Databases Matter for AI Apps
Large language models don't have memory. They can't search your company's documents, your product catalog, or your codebase without help. A vector database solves this by storing text as numerical representations called embeddings, then finding similar items at speed.
Think of it this way. A traditional database finds rows where city = "Austin". A vector database finds documents that mean something similar to "warm tech cities in Texas" — even if those exact words never appear anywhere in your data.
Which vector database should you use? For quick prototyping, Chroma wins — it runs in-memory with zero configuration. For managed production workloads, Pinecone removes all infrastructure burden. For maximum flexibility with self-hosting options, Weaviate gives you the most control.
Vector databases are the backbone of every serious RAG pipeline in 2026. If you're building AI-powered apps, picking the right one matters more than picking the right LLM.
As of April 7, 2026, Pinecone, Weaviate, and Chroma are the three most popular choices among developers — and they're surprisingly different under the hood. (For a broader look at the field, see our ranking of the 8 best vector databases.)
Step 1: Install the Python Clients
First, install all three clients:
Bash
pip install pinecone weaviate-client chromadb openai
The openai package is for generating embeddings. You can swap in any embedding model later — the vector database doesn't care where the numbers come from.
Step 2: Set Up Pinecone (Managed Cloud)
Pinecone is the fully managed option. No infrastructure, no servers, no Docker. You sign up, grab an API key, and start inserting vectors.
Python
from pinecone import Pinecone, ServerlessSpec
import openai
# Initialize Pinecone
pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")
# Create a serverless index (do this once)
pc.create_index(
name="tutorial-index",
dimension=1536,
metric="cosine",
spec=ServerlessSpec(cloud="aws", region="us-east-1")
)
Python
index = pc.Index("tutorial-index")
# Generate an embedding
response = openai.embeddings.create(
input="Vector databases store embeddings for fast retrieval",
model="text-embedding-3-small"
)
embedding = response.data[0].embedding
# Upsert with metadata
index.upsert(vectors=[
{"id": "doc1", "values": embedding, "metadata": {"source": "blog", "topic": "ai"}}
])
# Query for similar vectors
query_embedding = openai.embeddings.create(
input="how do embedding databases work",
model="text-embedding-3-small"
).data[0].embedding
results = index.query(vector=query_embedding, top_k=5, include_metadata=True)
for match in results.matches:
print(f"{match.id}: {match.score:.3f}")
Pinecone's API is dead simple. That's its biggest selling point. But you're locked into their cloud — there's no self-hosted option. For teams that need data residency control, that's a dealbreaker.
When to Pick Pinecone
Pick Pinecone when you want zero ops overhead and you're okay paying for a managed service. It's excellent for startups that need to ship fast. As of April 7, 2026, Pinecone offers a free tier generous enough for prototyping — check their pricing page for current limits.
Step 3: Set Up Weaviate (The Flexible Middle Ground)
Weaviate is open-source and runs anywhere — your laptop, Docker, Kubernetes, or their managed cloud. It also has a killer feature: built-in vectorization. You feed it raw text and it generates embeddings automatically.
First, spin up Weaviate locally:
Bash
docker run -d --name weaviate \
-p 8080:8080 -p 50051:50051 \
cr.weaviate.io/semitechnologies/weaviate:latest
Then connect and start building:
Python
import weaviate
import weaviate.classes as wvc
client = weaviate.connect_to_local()
# Create a collection with auto-vectorization
client.collections.create(
name="Document",
vectorizer_config=wvc.config.Configure.Vectorizer.text2vec_openai(),
properties=[
wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
wvc.config.Property(name="source", data_type=wvc.config.DataType.TEXT),
]
)
collection = client.collections.get("Document")
# Insert data — Weaviate handles the embedding
collection.data.insert(
{"content": "Vector databases store embeddings for fast retrieval", "source": "tutorial"}
)
collection.data.insert(
{"content": "Traditional databases use exact match queries", "source": "tutorial"}
)
# Semantic search
results = collection.query.near_text(
query="how do embedding databases work",
limit=5
)
Python
for item in results.objects:
print(item.properties["content"])
client.close()
Notice that you never touched an embedding vector directly. Weaviate handled it (and that's fewer things to break in production). But Weaviate has a steeper learning curve. The schema system, modules, and configuration options can feel overwhelming when all you want is to store some vectors and query them.
So if you're the kind of developer who wants full control and doesn't mind reading docs, Weaviate is your best bet.
Step 4: Set Up Chroma (The Prototyping Champion)
Chroma is the lightweight option. It runs in-memory by default, requires zero configuration, and feels like working with a Python dictionary that happens to understand semantic similarity.
Python
import chromadb
# In-memory client — zero config
client = chromadb.Client()
# Or persist to disk between sessions
# client = chromadb.PersistentClient(path="./chroma_data")
collection = client.create_collection("my_documents")
# Add documents — Chroma generates embeddings automatically
collection.add(
documents=[
"Vector databases store embeddings for fast retrieval",
"Traditional databases use exact match queries",
"RAG pipelines combine retrieval with generation"
],
ids=["doc1", "doc2", "doc3"]
)
# Query with natural language
results = collection.query(
query_texts=["how do embedding databases work"],
n_results=2
)
print(results["documents"])
That's it. No API keys for the database, no Docker, no cloud account. You pip install chromadb and start building.
Chroma is the SQLite of vector databases. When you need something that just works for development, nothing else comes close.
But there's a catch. Chroma's simplicity comes with trade-offs. It wasn't designed for production workloads with hundreds of millions of vectors. And its query capabilities are more limited compared to Weaviate's hybrid search or Pinecone's advanced metadata filtering.
Step 5: Head-to-Head Comparison
Now that you've seen all three in action, this is how they stack up:
| Feature | Pinecone | Weaviate | Chroma |
|---|---|---|---|
| Open Source | No | Yes (BSD-3) | Yes (Apache 2.0) |
| Self-Hosted | No | Yes | Yes |
| Managed Cloud | Yes | Yes | Yes |
| Built-in Vectorization | Yes (hosted models) | Yes (multiple providers) | Yes (default model) |
| Hybrid Search | Yes | Yes (BM25 + vector) | Metadata filtering only |
| Approximate Scale | Billions of vectors | Billions (clustered) | Millions |
| Setup Time | ~2 minutes | 10-15 minutes | ~30 seconds |
| Best For | Production SaaS | Flexible production apps | Prototyping and small apps |
My honest take: Pinecone is hard to beat on query latency at scale because that's literally all they do. Weaviate gives you the most features per dollar. Chroma gets you from zero to working prototype faster than anything else. For a deeper analysis, read our Pinecone vs Weaviate vs Chroma comparison.
Tips and Common Pitfalls
Don't skip dimensionality planning. Your embedding model determines your vector dimensions. OpenAI's text-embedding-3-small outputs 1536 dimensions. Create an index with the wrong dimension count and nothing works — the error messages aren't always obvious.
Batch your inserts. All three databases perform dramatically better with batch operations. Never insert one vector at a time in a loop.
Python
# Bad — painfully slow
for doc in documents:
collection.add(documents=[doc], ids=[doc.id])
# Good — dramatically faster
collection.add(documents=all_docs, ids=all_ids)
Start with Chroma, graduate later. Build your RAG pipeline with Chroma first. Get the retrieval logic right. Then swap in Pinecone or Weaviate when you need to scale. The mental model transfers directly between all three — insert vectors, query by similarity, filter by metadata.
Watch your embedding costs. As of April 7, 2026, generating embeddings through OpenAI or Cohere costs money. Embedding a million documents adds up fast. Consider open-source embedding models like those on HuggingFace if cost is a concern.
The biggest mistake developers make with vector databases? Over-engineering the setup before validating that semantic search actually solves their problem.
Testing Your Setup
Here's a quick smoke test that works with Chroma (adapt for the others):
Python
test_queries = [
"What are embeddings?",
"How does similarity search work?",
"Tell me about database indexing"
]
for query in test_queries:
results = collection.query(query_texts=[query], n_results=2)
print(f"Query: {query}")
print(f"Top result: {results['documents'][0][0][:100]}...")
print("---")
If your top results are semantically related to each query — not just keyword matches — your vector database is working correctly. If results seem random, double-check that your embeddings are being generated properly.
Which One Should You Actually Pick?
Let me save you the analysis paralysis:
- Building a quick prototype or learning? Chroma. No contest.
- Production app that needs managed infrastructure? Pinecone. Pay for the convenience.
- Production app where you want control and flexibility? Weaviate. The extra setup time pays for itself.
- Enterprise with strict data residency requirements? Weaviate self-hosted or Chroma embedded.
So don't overthink this. Pick one, build something, and switch later if you need to. The embedding concepts and query patterns transfer directly between all three. And if you're weighing RAG against fine-tuning, our RAG vs Fine-Tuning comparison breaks down when each approach wins.
Next Steps
Once you've picked your vector database:
- Connect it to an LLM like Claude Sonnet 4.6 or GPT-4.1 to build a full RAG pipeline
- Experiment with different embedding models — your choice of embeddings matters more than your choice of database
- Add metadata filtering to make your queries more precise
- Explore the official docs for advanced features: Pinecone, Weaviate, Chroma
Sources
