Vergleich von Vektordatenbanken

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 Entscheidungsmatrix

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

---

Überblick

ChromaDB

ChromaDB ist die einfachste Vektordatenbank — entwickelt für schnelles Prototyping und Anwendungen im kleinen bis mittleren Maßstab. Sie kann vollständig im Speicher laufen oder auf der Festplatte persistiert werden.

Philosophie: Keine Konfiguration, maximale Entwicklererfahrung.

import chromadb

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

collection.add(
    documents=["Maschinelles Lernen ist großartig", "Deep Learning verwendet neuronale Netze"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["Was ist KI?"],
    n_results=2
)

Qdrant

Qdrant ist eine produktionsreife Vektorsuchmaschine, geschrieben in Rust. Sie konzentriert sich auf Leistung, Filterung und betriebliche Einfachheit.

Philosophie: Produktionsleistung ohne betriebliche 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": "Dokument 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 am besten skalierbare Open-Source-Vektordatenbank, entwickelt für Bereitstellungen im Milliardenmaßstab. Sie verfügt über 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) standardmäßig.

Philosophie: schema-reich, multimodal, Fähigkeiten für Wissensgraphen.

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"]}
    ]
})

# Mit Auto-Vektorisierung
client.data_object.create(
    {"content": "Tutorial zu maschinellem Lernen", "category": "tech"},
    "Document"
)

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

---

Leistungsbenchmarks

ANN Benchmarks (ann-benchmarks.com, 2024)

1 Mio. Vektoren, 768 Dimensionen, Kosinus-Ähnlichkeit

Datenbank	QPS (1 Thread)	Recall@10	Erstellungszeit	Indexgröße
ChromaDB (HNSW)	~2,000	98.5%	45 s	2,1 GB
Qdrant (HNSW)	~8,500	99.1%	32 s	1,8 GB
Milvus (HNSW)	~12,000	98.9%	28 s	1,9 GB
Weaviate (HNSW)	~6,000	98.7%	38 s	2,0 GB

10 Mio. Vektoren (Skalierbarkeitstest)

Datenbank	QPS	RAM-Nutzung	Hinweise
ChromaDB	~800	22 GB	Hat Probleme im großen Maßstab
Qdrant	~5,200	18 GB	Gut mit Quantisierung
Milvus	~9,800	15 GB (indexiert)	Am besten im großen Maßstab
Weaviate	~3,500	21 GB	Mittel

Benchmarks sind Leitlinien, kein Evangelium. Die Leistung variiert stark je nach Indextyp, Hardware, Vektordimensionen und Abfragemustern. Benchmarken Sie immer mit Ihren eigenen Daten.

Leistungsfähigkeit beim Filtern (gefilterte ANN-Suche)

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

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

Gewinner bei gefilterter Suche: Qdrant und Milvus, die echtes Vorfiltern ohne Leistungseinbußen durch Nachfiltern unterstützen.

---

Funktionsvergleich

Speicherung und Indexierung

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

Abfragefunktionen

Funktion	ChromaDB	Qdrant	Milvus	Weaviate
Vektorähnlichkeit	✅	✅	✅	✅
Hybridsuche (BM25+Vektor)	❌	✅	✅	✅
Metadatenfilterung	✅ (einfach)	✅ (umfangreich)	✅ (umfangreich)	✅ (GraphQL)
Schlüsselwortsuche	❌	✅	✅	✅
Mehrvektor-Suche	❌	✅	✅	✅
Sparse Vektoren (SPLADE)	❌	✅	✅	✅
Benannte Vektoren	❌	✅	✅	✅

Betriebsfunktionen

Funktion	ChromaDB	Qdrant	Milvus	Weaviate
REST-API	✅	✅	✅	✅
gRPC-API	❌	✅	✅	❌
GraphQL-API	❌	❌	❌	✅
Authentifizierung	Einfach	✅	✅	✅
RBAC	❌	✅	✅	✅
Horizontale Skalierung	❌	✅	✅	✅
Kubernetes-Unterstützung	❌	✅	✅	✅
Snapshots/Backups	❌	✅	✅	✅
Überwachung (Prometheus)	❌	✅	✅	✅

---

ChromaDB: Tiefgang

Stärken

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

Schwächen

❌ Begrenzte Skalierung — kommt über 1–2 Mio. Vektoren an seine Grenzen ❌ Kein verteilter Modus — nur Einzelknoten ❌ Begrenzte Filterung — keine Vorfilterung ❌ Keine Quantisierung — höherer Speicherverbrauch ❌ Langsam im großen 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 geeignet für: Jupyter-Notebooks, schnelle RAG-Prototypen, <1 Mio. Vektoren

---

Qdrant: Tiefgang

Stärken

✅ Beste Filterung — echte vorgefilterte Vektorsuche ✅ Rust-Performance — extrem schnell, geringe Latenz ✅ Quantisierung — Binär-/Skalarquantisierung reduziert den Speicher um das 4–32-Fache ✅ Sparse Vektoren — hybride dichte+sparse Suche ✅ Einfacher Betrieb — eine einzige Binärdatei, keine Abhängigkeiten ✅ Gute Dokumentation — hervorragende Anleitungen und Beispiele

Schwächen

❌ Einzelschreiber in der kostenlosen Stufe (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 geeignet für: Produktions-RAG, gefilterte Suche, 1–100 Mio. Vektoren

---

Milvus: Tiefgang

Stärken

✅ Massive Skalierung — getestet mit über 10 Mrd. Vektoren ✅ Verteilt — cloud-native Kubernetes-Architektur ✅ Die meisten Indextypen — IVF, HNSW, DiskANN, ScaNN ✅ GPU-Beschleunigung — GPU-gestützte Indexerstellung ✅ Enterprise-Funktionen — RBAC, Audit-Logs, 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 ❌ Überdimensioniert für kleine Maßstäbe — nicht für <1 Mio. 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 etwa 60 Sekunden bis zum vollständigen Start

Am besten geeignet für: Große Produktion, 100 Mio.+ Vektoren, Enterprise-Bereitstellungen

---

Weaviate: Tiefgang

Stärken

✅ Multimodal — Text, Bilder, Audio, Video ✅ Automatische Vektorisierung — integrierte Modellintegrationen ✅ GraphQL-API — umfangreiche Abfragen mit Graph-Traversierung ✅ Modulsystem — austauschbare Vektorisierer und Reader ✅ Hybride Suche — BM25 + Vektor standardmäßig ✅ Generative Suche — integriertes RAG mit Generate-Modul

Schwächen

❌ Höherer Speicherbedarf — schema-bewusste Speicherung ist größer ❌ Kein gRPC — nur GraphQL (langsamer bei hoher QPS) ❌ Komplexes Schema — erfordert vorab definierte Klassen ❌ Langsamer bei extremer Skalierung 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-Vektorisierer
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 geeignet für: Multi-Modal-Suche, Wissensgraphen, generative Suche

---

Wann welches verwenden

Skalierungsbasierte Entscheidung

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

Entscheidung nach Anwendungsfall

Anwendungsfall	Beste Wahl	Warum
RAG-Prototyp	ChromaDB	Keine Einrichtung, einfache API
RAG in der Produktion	Qdrant	Schnelle Filterung, einfacher Betrieb
Semantische Suche	Qdrant oder Milvus	Beste Leistung
Multimodal	Weaviate	Integrierte Bild-/Audio-Unterstützung
Wissensgraph	Weaviate	Graph-Traversierungsabfragen
Im Milliardenmaßstab	Milvus	Verteilte Architektur
Hybride Suche	Qdrant oder Weaviate	BM25 + Vektor
Unternehmen	Milvus oder Weaviate	RBAC, Audit-Logs

---

Speicheranforderungen auf Clore.ai

RAM-Schätzformel

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

Beispiel: 1 Mio. Vektoren × 1536 Dimensionen × 4 Byte × 1,5 = 9,2 GB RAM

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

Empfohlene Server-Spezifikationen

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

---

Schneller Vergleich: Docker-Setup-Zeit

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

---

Preise (selbst gehostet auf Clore.ai)

Alle vier Datenbanken sind kostenlos zum Selbsthosten. Die Kosten bestehen nur aus der Servermiete bei Clore.ai:

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

---

Nützliche Links

• ChromaDB-Dokumentation

• Qdrant-Dokumentation

• Milvus-Dokumentation

• Weaviate-Dokumentation

• ANN-Benchmarks

• Vektor-Datenbank-Benchmark von Qdrant

---

Zusammenfassung

Beginnen Sie mit...	Wenn Sie brauchen...
ChromaDB	Schnelles Prototyping, <1 Mio. Vektoren, minimale Einrichtung
Qdrant	Produktionsreifes RAG, hervorragendes Filtern, 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 betrieblicher Einfachheit. Für groß angelegte oder Enterprise-Anforderungen Milvus ist der Industriestandard.

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktion	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Großflächig	A100 80GB	Bare Metal

💡 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.