# Vergleich von Vektor-Datenbanken

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

{% hint style="info" %}
**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.
{% endhint %}

***

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

```python
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.

```python
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.

```python
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.

```python
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                                    |

{% hint style="info" %}
**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.
{% endhint %}

### 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

```bash
# 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

```bash
# 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)

```yaml
# 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
```

```bash
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

```bash
# 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](https://docs.trychroma.com)
* [Qdrant-Dokumentation](https://qdrant.tech/documentation)
* [Milvus-Dokumentation](https://milvus.io/docs)
* [Weaviate-Dokumentation](https://weaviate.io/developers/weaviate)
* [ANN Benchmarks](https://ann-benchmarks.com)
* [Vector DB Benchmark von Qdrant](https://qdrant.tech/benchmarks)

***

## 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](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/vergleiche/vector-db-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.