Vector Database Vergleich 2026 — ChromaDB vs Pinecone vs Qdrant

Vector Databases sind das Rückgrat von RAG (Retrieval Augmented Generation). Dieser Guide vergleicht alle Top-Optionen für Different Scale & Use Cases.

Schnell-Überblick

Detaillierter Vergleich

Pinecone — Fully Managed (Einfachste Lösung)

Pricing (März 2026):

• Starter (Free): 5 Indexes, 100 Namespaces, 2GB Storage (us-east-1 only)
• Standard Pay-as-you-go:
  • $0.00055 pro 1000 Vectors stored
  • $8.25 pro 1M Read Units
  • $2 pro 1M Write Units
  • Example: 1M Vectors + 10k daily queries = ~$50-100/Mo

Besonderheit: Einzige vollständig managed Cloud-Only Option

Stärken:

• "Einfachste zu deployen" — signup → code → fertig
• Pinecone Pods für Scale-Up
• Serverless Compute Optionen
• Performance ist garantiert (SLA 99.99%)
• Viele Features (Hybrid Search, Metadata Filtering)

Schwächen:

• Kein Self-Hosting (Vendor Lock-In)
• Wird teuer bei sehr großem Scale (100M+ Vectors)
• Starter Plan ist limitierend (nur 2GB)

Kosten-Beispiel:

Startup RAG System:
- 1M Vectors (100MB) = $0.55/Mo
- 10k Read Units/Monat = $0.08/Mo
- Total: ~$0.63/Mo + min charge ($8) = $8/Mo

RAG Integration:

from pinecone import Pinecone
from langchain.vectorstores import Pinecone as PineconeVectorStore

pc = Pinecone(api_key="xxx")
index = pc.Index("my-index")

# Embed & Store
embeddings = OpenAI Embeddings()
documents = load_documents()
vectorstore = PineconeVectorStore.from_documents(documents, embeddings, index_name="my-index")

# Retrieve for RAG
retriever = vectorstore.as_retriever(k=5)

Qdrant — Open-Source Flexibility

Pricing:

• Self-Hosted: Free (Open Source)
• Qdrant Cloud Free: Limited (1GB)
• Qdrant Cloud Standard: ~$150/Mo für 8GB RAM, 2 vCPU
• Self-Hosted VPS: $5-20/Mo (AWS/DigitalOcean)

Besonderheit: Beste Balance zwischen Open-Source + Production-Ready

Stärken:

• Open Source (Rust) — schneller + sicherer als anderen
• Self-Hosting ist first-class citizen
• Hybrid Search (Vector + Keyword)
• Structured Data mit Vectors
• Filtering ist powerful
• Günstiger als Pinecone bei Scale

Schwächen:

• Self-Hosting braucht DevOps Know-How
• Cloud ist teurer als Pinecone bei kleinem Scale
• Kleinere Community als Pinecone

Kosten-Vergleich (1M Vectors, 10k daily queries):

Qdrant Self-Hosted (DigitalOcean App):
- VPS (4GB RAM, 2 vCPU): $15/Mo
- Postgres Backup: $5/Mo
- Bandwidth: ~$2/Mo
Total: $22/Mo

Pinecone Standard:
- Vectors: $0.55/Mo
- Reads: $0.08/Mo
- Min: $8/Mo (but scales to $50-100+)
Total: $8-50+/Mo (depends on actual usage)

Winner: Tie (Qdrant cheaper at extreme scale >10M vectors)

Self-Hosted Setup:

# Docker
docker run -p 6333:6333 qdrant/qdrant:latest

# Dann via Python
from qdrant_client import QdrantClient
client = QdrantClient(url="http://localhost:6333")

ChromaDB — The Easy MVP Path

Pricing:

• Open Source: Free
• Chroma Cloud: ~$10/Mo (managed)
• Self-Hosted via Railway: $5-10/Mo

Besonderheit: Einfachste für Prototyping

Stärken:

• "Fastest to MVP" — code in 5 min
• Python-first API (NumPy-like)
• Embedded Mode (in-process) für kleine Projects
• Very Active Community
• Great für Learning

Schwächen:

• Nicht für Production 100M+ Vectors
• Weniger Features als Qdrant/Pinecone
• Skalierungsberechnung ist begrenzt

Best Use: Development, Prototyping, Small Projects (<10M vectors)

Einfache Installation:

import chromadb

# In-Memory (für Testing)
client = chromadb.Client()
collection = client.create_collection("my_docs")

# Add Embeddings
collection.add(
    ids=["id1", "id2"],
    embeddings=[[1.1, 2.3], [4.5, 6.9]],
    documents=["doc1", "doc2"]
)

# Query
results = collection.query(query_embeddings=[[1.1, 2.3]], n_results=10)

Weaviate — Enterprise RAG

Pricing:

• Open Source: Free
• Weaviate Cloud Free: Limited
• Weaviate Cloud Starter: $250/Mo
• Self-Hosted: Free (aber braucht Kubernetes)

Stärken:

• Nativ GraphQL API
• Sehr gutes für Complex Queries
• Multi-Tenancy Support
• Enterprise-Grade Security
• Viele Features (Generative Search, Hybrid, etc.)

Schwächen:

• Schwieriger zu starten als ChromaDB
• Self-Hosting braucht Kubernetes Knowledge
• Learning Curve steiler

Best Use: Enterprise, Complex Queries, GraphQL Users

Milvus — Distributed Scale

Pricing: Free (Open Source)

Besonderheit: Gebaut für Verteilte Systeme (Kubernetes-native)

Stärken:

• "Best für distributed scale" (Millionen Vectors)
• Kubernetes-native
• Sehr schnell (C++ Backend)
• Open Source

Schwächen:

• Steile DevOps-Kurve
• Overkill für kleine Projects
• Setup ist komplex

Best Use: Mega-Scale, Kubernetes Infrastructure, Research

pgvector — PostgreSQL Native

Pricing: Nur Postgres Hosting (z.B. Supabase $25+/Mo)

Stärken:

• SQL-native (kein neues System zu lernen)
• Einfach zu backen mit Relational Data
• Transactions + ACID
• Billig (piggybacked auf Postgres)

Schwächen:

• Nicht spezialisiert (Postgres mit Vector Extension)
• Performance schlechter als dedicated Vector DBs
• Weniger Features

Best Use: PostgreSQL-first Teams, einfache Hybrid Queries

Performance Vergleich

Embedding-Zeit für 1M Vectors (nach Ingest):

| Tool | Speed | Notes |
|------|-------|-------|
| Qdrant | ~2 min | Rust, optimiert |
| Milvus | ~3 min | Distributed |
| Pinecone | ~5 min | Cloud |
| Weaviate | ~8 min | GraphQL Overhead |
| ChromaDB | ~10 min | Single-threaded |
| pgvector | ~15 min | Postgres Limit |

Für RAG: Speed meist nicht kritisch (einmal beim Setup)

RAG Integration Vergleich

LangChain Integration (alle unterstützen)

from langchain.vectorstores import Pinecone  # oder Qdrant, Weaviate, etc.

# Funktioniert gleich für alle
vectorstore = Pinecone.from_documents(docs, embeddings, index="my-index")
retriever = vectorstore.as_retriever(k=5)

LlamaIndex Integration (auch alle)

from llama_index.vector_stores import PineconeVectorStore

vector_store = PineconeVectorStore(index_name="my-index")
index = VectorStoreIndex.from_documents(documents, vector_store=vector_store)

Sizing Guide

Praktische Szenarien

Szenario #1: Startup Building RAG Product

Anforderungen:

• 100k-1M Vectors (Dokumente)
• Simple Semantic Search
• Schnell zu deployen
• Budget: <$50/Mo

Beste Wahl: Qdrant Cloud oder Pinecone Free

• Qdrant: Self-hosted ($15/Mo VPS) für Kontrolle
• Pinecone: Cloud Free Tier + Pay-as-you-go wenn Scale

Workflow:

# Document Ingestion
from langchain.document_loaders import PDFLoader
from langchain.vectorstores import Pinecone

docs = PDFLoader("documents/").load()
embeddings = OpenAI Embeddings()
vectorstore = Pinecone.from_documents(docs, embeddings)

# RAG with LangChain
from langchain.chains import RetrievalQA
qa = RetrievalQA.from_chain_type(llm=ChatGPT, retriever=vectorstore.as_retriever())
qa.run("What does X say about Y?")

Cost: $8-15/Mo

Szenario #2: Enterprise Knowledge Base

Anforderungen:

• 10M+ Vectors (große Codebase, Doku)
• Complex Filtering (by department, security level)
• Self-Hosted (Data Privacy)
• High Availability

Beste Wahl: Qdrant Self-Hosted auf Kubernetes

• Full Control über Daten
• Horizontal Scalable
• Günstiger bei Scale

Setup:

helm repo add qdrant https://qdrant.github.io/qdrant-helm
helm install qdrant qdrant/qdrant --values values.yaml

# values.yaml definiert Storage, Replicas, etc.

Cost: $500-2000/Mo Infrastructure

Szenario #3: Rapid Prototyping / Research

Anforderungen:

• Schnell iterieren
• Verschiedene Models testen
• Lokal laufen (offline)
• Free

Beste Wahl: ChromaDB In-Memory

• 5 Minuten Setup
• Zero Cost
• In-Process (super schnell)

import chromadb
client = chromadb.Client()
collection = client.create_collection("research")
# Go!

Szenario #4: Hybrid Search (Semantic + Keyword)

Anforderungen:

• Vectors + Text Search kombinieren
• Ranking basierend auf Relevanz
• Sehr gute Performance

Beste Wahl: Qdrant oder Weaviate

• Qdrant: Schneller, simpler
• Weaviate: More features, GraphQL

# Qdrant Hybrid Search
search_result = client.search(
    collection_name="documents",
    query_vector=embedding,
    query_filter=models.Filter(  # Text filter
        must=[
            models.FieldConditionFilter(
                key="department",
                match=models.MatchValue(value="engineering")
            )
        ]
    )
)

Top-5 Häufige Fehler

Problem #1: "Pinecone ist zu teuer"

• Ursache: Read Units werden unterschätzt
• Lösung: Wechsel zu Qdrant Self-Hosted
• Einsparung: 10x bei 100M+ Vectors

Problem #2: "ChromaDB ist langsam mit 1M Vectors"

• Ursache: ChromaDB ist nicht für große Scale
• Lösung: Migriere zu Qdrant/Pinecone
• Aufwand: ~2 Stunden Code Migration

Problem #3: "Qdrant Self-Hosted lädt nicht"

• Ursache: Zu wenig RAM oder Disk
• Lösung: Check Server Specs oder nutze Cloud
• Minimum: 4GB RAM für 1M Vectors

Problem #4: "Embedding Dimension Mismatch"

• Ursache: ChromaDB 384-dim vs Ollama 1024-dim
• Lösung: Konsistente Embedding Model verwenden

# Immer die gleiche Embedding Function!
embedding_function = "text-embedding-3-small"  # 1536-dim

Problem #5: "Vectors sind nicht aktualisiert"

• Ursache: Caching/Refresh nicht konfiguriert
• Lösung: Set TTL oder implementiere Refresh Logic

# Qdrant: Set TTL auf Payload
client.upsert(
    collection_name="docs",
    points=[Point(id=1, vector=vec, payload={"expires_at": time.time() + 86400})]
)

Migration Path

Wenn du größer wirst:

1. Start: ChromaDB (Free, schnell)
   ↓ (wenn >100k vectors)
2. Scale: Qdrant Cloud oder Pinecone Free
   ↓ (wenn >1M vectors)
3. Production: Qdrant Self oder Pinecone Standard
   ↓ (wenn >10M vectors)
4. Enterprise: Qdrant Cluster oder Milvus

Migration ist einfach (nur Daten neu ingest via LangChain)

Budget nach Profil

Ressourcen

• Pinecone Official
• Qdrant GitHub
• ChromaDB Official
• Weaviate Official
• Milvus Official

Letzte Aktualisierung: 21.03.2026 | Nächste Überprüfung: Juni 2026

Quellen und Links

• Chroma
• Weaviate
• Qdrant
• Milvus