Vergleich von Vektor-Datenbanken

Wählen Sie die richtige Vektordatenbank für Ihre KI-Anwendungen auf Clore.ai GPU-Servern.

Vektordatenbanken speichern und rufen hochdimensionale Embeddings effizient ab — die Kerninfrastruktur für RAG-Systeme, semantische Suche und Empfehlungssysteme. Dieser Leitfaden vergleicht die vier beliebtesten Open-Source-Optionen.

---

Schnelle Entscheidungsübersicht

	ChromaDB	Qdrant	Milvus	Weaviate
Am besten für	Prototyping, lokale Entwicklung	Produktion RAG	Suche in Milliardenmaßstab	Wissensgraphen
Bereitstellung	Eingebettet/Server	Server/Cloud	Server/Cloud	Server/Cloud
Skalierbarkeit	Einzelner Knoten	Mehrere Knoten	Verteilt	Verteilt
GitHub-Sterne	17K+	21K+	31K+	12K+
Lizenz	Apache 2.0	Apache 2.0	Apache 2.0	BSD 3-Klausel
Managed Cloud	Nein	Ja (Qdrant Cloud)	Ja (Zilliz)	Ja (Weaviate Cloud)
Sprache	Python	Rust	Go	Go

---

Übersicht

ChromaDB

ChromaDB ist die einfachste Vektordatenbank — konzipiert für schnelles Prototyping und Anwendungen von klein bis mittelgroß. Sie kann vollständig im Arbeitsspeicher laufen oder auf die Festplatte persistieren.

Philosophie: Keine Konfiguration, maximale Entwicklererfahrung.

import chromadb

client = chromadb.PersistentClient(path="/data/chroma")
collection = client.create_collection("my_docs")

collection.add(
    documents=["Machine learning is great", "Deep learning uses neural networks"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["What is AI?"],
    n_results=2
)

Qdrant

Qdrant ist eine produktionsbereite Vektorsuchmaschine, geschrieben in Rust. Der Fokus liegt auf Leistung, Filterung und operativer Einfachheit.

Philosophie: Produktionsleistung ohne operative Komplexität.

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

client = QdrantClient("localhost", port=6333)
client.create_collection(
    collection_name="my_collection",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="my_collection",
    points=[
        PointStruct(id=1, vector=[...], payload={"text": "document 1"}),
    ]
)

results = client.search(
    collection_name="my_collection",
    query_vector=[...],
    limit=10,
    query_filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="tech"))])
)

Milvus

Milvus ist die skalierbarste Open-Source-Vektordatenbank, entwickelt für Bereitstellungen im Milliardenmaßstab. Sie hat eine verteilte Architektur mit Kubernetes-Unterstützung.

Philosophie: Massive Skalierung, cloud-nativ.

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType

connections.connect("default", host="localhost", port=19530)

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
]
schema = CollectionSchema(fields)
collection = Collection("my_collection", schema)

# Daten einfügen
collection.insert([[1, 2], embeddings, texts])
collection.create_index("embedding", {"metric_type": "COSINE", "index_type": "IVF_FLAT"})
collection.load()

results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "nprobe": 10},
    limit=10
)

Weaviate

Weaviate kombiniert Vektorsuche mit Wissensgraphen und einer GraphQL-API. Es unterstützt Multi-Modal-Suche (Text, Bilder, Audio) von Haus aus.

Philosophie: Schema-reich, multimodal, Wissensgraph-Fähigkeiten.

import weaviate

client = weaviate.Client("http://localhost:8080")

# Schema mit Klassen definieren
client.schema.create_class({
    "class": "Document",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "category", "dataType": ["string"]}
    ]
})

# Einfügen mit automatischer Vektorisierung
client.data_object.create(
    {"content": "Machine learning tutorial", "category": "tech"},
    "Document"
)

# Semantische Suche
result = client.query.get("Document", ["content", "category"])\
    .with_near_text({"concepts": ["artificial intelligence"]})\
    .with_limit(5)\
    .do()

---

Leistungs-Benchmarks

ANN Benchmarks (ann-benchmarks.com, 2024)

1M Vektoren, 768 Dimensionen, Kosinus-Ähnlichkeit

Datenbank	QPS (1 Thread)	Recall@10	Build-Zeit	Index-Größe
ChromaDB (HNSW)	~2,000	98.5%	45s	2.1GB
Qdrant (HNSW)	~8,500	99.1%	32s	1.8GB
Milvus (HNSW)	~12,000	98.9%	28s	1.9GB
Weaviate (HNSW)	~6,000	98.7%	38s	2.0GB

10M Vektoren (Skalierungstest)

Datenbank	QPS	RAM-Verbrauch	Hinweise
ChromaDB	~800	22GB	Hatte bei großem Maßstab Schwierigkeiten
Qdrant	~5,200	18GB	Gut mit Quantisierung
Milvus	~9,800	15GB (indexiert)	Am besten bei großem Maßstab
Weaviate	~3,500	21GB	Mäßig

Benchmarks sind Richtwerte, kein Evangelium. Die Leistung variiert stark je nach Indextyp, Hardware, Vektordimensionen und Abfragemustern. Führen Sie immer eigene Benchmarks mit Ihren Daten durch.

Filterleistungsfähigkeit (Gefilterte ANN-Suche)

Gefilterte Suche (Vektorähnlichkeit + Metadatenfilter) ist entscheidend für produktive RAG:

Datenbank	Gefilterte QPS	Vorfilter	Nachfilter
ChromaDB	~500	❌	✅
Qdrant	~6,000	✅ (HNSW + Payload-Index)	✅
Milvus	~8,000	✅	✅
Weaviate	~3,000	✅ (invertierter Index)	✅

Gewinner für gefilterte Suche: Qdrant und Milvus, die echtes Vorfiltern unterstützen, ohne Leistungseinbußen durch Nachfilterung.

---

Funktionsvergleich

Speicherung und Indizierung

Funktion	ChromaDB	Qdrant	Milvus	Weaviate
HNSW-Index	✅	✅	✅	✅
IVF-Index	❌	❌	✅	❌
DiskANN	❌	✅	✅	❌
Skalare Quantisierung	❌	✅	✅	✅
Produktquantisierung	❌	✅	✅	❌
Binäre Quantisierung	❌	✅	✅	✅
On-Disk-Speicherung	✅	✅	✅	✅
Mmap	❌	✅	✅	✅

Abfragefähigkeiten

Funktion	ChromaDB	Qdrant	Milvus	Weaviate
Vektorähnlichkeit	✅	✅	✅	✅
Hybride Suche (BM25+Vektor)	❌	✅	✅	✅
Metadatenfilterung	✅ (grundlegend)	✅ (umfangreich)	✅ (umfangreich)	✅ (GraphQL)
Schlüsselwortsuche	❌	✅	✅	✅
Multi-Vektor-Suche	❌	✅	✅	✅
Sparsame Vektoren (SPLADE)	❌	✅	✅	✅
Benannte Vektoren	❌	✅	✅	✅

Betriebliche Funktionen

Funktion	ChromaDB	Qdrant	Milvus	Weaviate
REST-API	✅	✅	✅	✅
gRPC-API	❌	✅	✅	❌
GraphQL-API	❌	❌	❌	✅
Authentifizierung	Grundlegend	✅	✅	✅
RBAC	❌	✅	✅	✅
Horizontale Skalierung	❌	✅	✅	✅
Kubernetes-Unterstützung	❌	✅	✅	✅
Snapshots/Backup	❌	✅	✅	✅
Monitoring (Prometheus)	❌	✅	✅	✅

---

ChromaDB: Tiefgehender Einblick

Stärken

✅ Einfachste Einrichtung — pip install chromadb und Sie sind fertig ✅ Eingebetteter Modus — kein separater Serverprozess ✅ Automatische Embeddings — eingebaute Embedding-Modelle ✅ LangChain/LlamaIndex native Integration ✅ Keine Konfiguration — großartig für Prototyping

Schwächen

❌ Begrenzte Skalierung — gerät jenseits von 1–2M Vektoren ins Straucheln ❌ Kein verteilter Modus — nur Einzelknoten ❌ Begrenzte Filterung — kein Vorfiltern ❌ Keine Quantisierung — höherer Speicherverbrauch ❌ Langsam bei großem Maßstab — Python-basierte Operationen

Bereitstellung auf Clore.ai

# Client/Server-Modus
docker run -d \
  --name chromadb \
  -p 8000:8000 \
  -v $(pwd)/chroma-data:/chroma/chroma \
  chromadb/chroma:latest

# Test
curl http://localhost:8000/api/v1/heartbeat

Am besten für: Jupyter-Notebooks, schnelle RAG-Prototypen, <1M Vektoren

---

Qdrant: Tiefgehender Einblick

Stärken

✅ Beste Filterung — echtes vorgefiltertes Vektorsuchen ✅ Rust-Leistung — extrem schnell, geringe Latenz ✅ Quantisierung — binär/skalar reduziert Speicher 4–32× ✅ Sparsame Vektoren — hybride dichte+spärliche Suche ✅ Einfache Operationen — einzelne Binärdatei, keine Abhängigkeiten ✅ Gute Dokumentation — exzellente Anleitungen und Beispiele

Schwächen

❌ Single-Writer im Free-Tier (keine verteilten Schreibvorgänge) ❌ Kleineres Ökosystem als Milvus ❌ Kein GraphQL — nur REST/gRPC

Bereitstellung auf Clore.ai

# Einfache Bereitstellung
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Mit Authentifizierung
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -e QDRANT__SERVICE__API_KEY=your-secret-key \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Test
curl http://localhost:6333/health

Am besten für: Produktions-RAG, gefilterte Suche, 1–100M Vektoren

---

Milvus: Tiefgehender Einblick

Stärken

✅ Massive Skalierung — getestet mit über 10B Vektoren ✅ Verteilt — cloud-native Kubernetes-Architektur ✅ Die meisten Indextypen — IVF, HNSW, DiskANN, ScaNN ✅ GPU-Beschleunigung — GPU-gestützter Indexaufbau ✅ Enterprise-Funktionen — RBAC, Prüfprotokolle, Verschlüsselung ✅ Zilliz Cloud — vollständig verwaltete Option

Schwächen

❌ Komplexe Bereitstellung — erfordert etcd, MinIO und Pulsar/Kafka ❌ Ressourcenintensiv — mindestens 3 Knoten empfohlen ❌ Steilere Lernkurve — mehr Konzepte zu verstehen ❌ Overkill für kleinen Maßstab — nicht für <1M Vektoren verwenden

Bereitstellung auf Clore.ai (Standalone)

# docker-compose.yml für Milvus Standalone
version: "3.8"
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls=http://0.0.0.0:2379

  minio:
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data --console-address ":9001"

  milvus:
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio

docker compose up -d
# Dauert ~60 Sekunden bis zur vollständigen Startbereitschaft

Am besten für: Großskalige Produktion, 100M+ Vektoren, Enterprise-Bereitstellungen

---

Weaviate: Tiefgehender Einblick

Stärken

✅ Multimodal — Text, Bilder, Audio, Video ✅ Automatische Vektorisierung — eingebaute Modellintegrationen ✅ GraphQL-API — reichhaltige Abfragen mit Graph-Traversal ✅ Modulsystem — einsteckbare Vectorizer und Reader ✅ Hybride Suche — BM25 + Vektor ab Werk ✅ Generative Suche — eingebaute RAG mit Generate-Modul

Schwächen

❌ Höherer Speicherbedarf — schema-bewusste Speicherung ist größer ❌ Kein gRPC — nur GraphQL (bei hoher QPS langsamer) ❌ Komplexes Schema — erfordert vorausgehende Klassendefinition ❌ Langsamer bei extremem Maßstab als Milvus

Bereitstellung auf Clore.ai

# Einfache Bereitstellung
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e DEFAULT_VECTORIZER_MODULE=none \
  -e CLUSTER_HOSTNAME=node1 \
  -v $(pwd)/weaviate-data:/var/lib/weaviate \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

# Mit Transformer-Vectorizer
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -e DEFAULT_VECTORIZER_MODULE=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

Am besten für: Multi-modale Suche, Wissensgraphen, generative Suche

---

Wann welches verwenden

Skalierungsbasierte Entscheidung

< 100K Vektoren    → ChromaDB (eingebettet)
100K - 10M         → Qdrant (beste Balance)
10M - 1B           → Milvus oder Qdrant (geclustert)
1B+                → Milvus (verteilt)

Entscheidung nach Anwendungsfall

Anwendungsfall	Beste Wahl	Warum
RAG-Prototyp	ChromaDB	Null Setup, einfache API
Produktion RAG	Qdrant	Schnelles Filtern, einfache Operationen
Semantische Suche	Qdrant oder Milvus	Beste Leistung
Multimodal	Weaviate	Eingebaute Bild-/Audio-Unterstützung
Wissensgraph	Weaviate	Graph-Traversal-Abfragen
Milliarden-Skala	Milvus	Verteilte Architektur
Hybride Suche	Qdrant oder Weaviate	BM25 + Vektor
Enterprise	Milvus oder Weaviate	RBAC, Prüfprotokolle

---

Speicheranforderungen auf Clore.ai

RAM-Schätzformel

Benötigter RAM ≈ (Vektoren × Dimensionen × 4 Bytes) × 1,5 (Overhead)

Beispiel: 1M Vektoren × 1536 Dims × 4 Bytes × 1,5 = 9,2GB RAM

Mit Quantisierung (Qdrant binär):
1M × 1536 / 8 × 1,5 = 0,29GB RAM (32× Kompression!)

Empfohlene Serverspezifikationen

Datensatzgröße	ChromaDB	Qdrant	Milvus	Weaviate
1M Vektoren	16GB RAM	8GB RAM	32GB RAM	16GB RAM
10M Vektoren	❌	32GB RAM	64GB RAM	48GB RAM
100M Vektoren	❌	128GB+	256GB+	256GB+

---

Kurzer Vergleich: Docker-Setup-Zeit

Datenbank	docker run bis einsatzbereit	Abhängigkeiten
ChromaDB	~5 Sekunden	Keiner
Qdrant	~3 Sekunden	Keiner
Milvus	~60 Sekunden	etcd + MinIO
Weaviate	~15 Sekunden	Keine (Standalone)

---

Preise (Self-Hosted auf Clore.ai)

Alle vier Datenbanken sind kostenlos zum Selbst-Hosten. Kosten entstehen nur durch die Clore.ai Servermiete:

Beispiel: RAG-System mit 1M Vektoren
- Qdrant: 8GB RAM Server ~0,10$/Std.
- ChromaDB: 16GB RAM Server ~0,15$/Std.  
- Weaviate: 16GB RAM Server ~0,15$/Std.
- Milvus: 32GB RAM Server ~0,30$/Std. (+ Overhead für etcd/MinIO)

---

Nützliche Links

• ChromaDB-Dokumentation

• Qdrant-Dokumentation

• Milvus-Dokumentation

• Weaviate-Dokumentation

• ANN Benchmarks

• Vector DB Benchmark von Qdrant

---

Zusammenfassung

Beginnen Sie mit...	Wenn Sie benötigen...
ChromaDB	Schneller Prototyp, <1M Vektoren, minimale Einrichtung
Qdrant	Produktions-RAG, hervorragende Filterung, operative Einfachheit
Milvus	Milliardenmaßstab, Enterprise, verteilte Architektur
Weaviate	Multimodal, Wissensgraphen, GraphQL-Abfragen

Für die meisten produktiven RAG-Anwendungen auf Clore.ai, Qdrant bietet die beste Balance aus Leistung, Funktionen und operativer Einfachheit. Für großskalige oder Enterprise-Anforderungen, Milvus ist der Industriestandard.

---

Clore.ai GPU-Empfehlungen

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten auf Clore.ai
Entwicklung/Tests	RTX 3090 (24GB)	~$0.12/gpu/hr
Produktion	RTX 4090 (24GB)	~$0.70/gpu/hr
Großmaßstab	A100 80GB	~$1.20/gpu/hr

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.