> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/vergleiche/vector-db-comparison.md).

# Vergleich von Vektordatenbanken

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

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

```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": "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.

```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) standardmäßig.

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

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

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

{% hint style="info" %}
**Benchmarks sind Leitlinien, kein Evangelium.** Die Leistung variiert stark je nach Indextyp, Hardware, Vektordimensionen und Abfragemustern. Benchmarken Sie immer mit Ihren eigenen Daten.
{% endhint %}

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

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

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

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

```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-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](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)
* [Vektor-Datenbank-Benchmark von Qdrant](https://qdrant.tech/benchmarks)

***

## 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](https://clore.ai/bare-metal) |

> 💡 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.