Qdrant

Hochleistungsfähige Vektordatenbank für semantische Suche und RAG-Anwendungen — GPU-beschleunigte Indexierung

Qdrant ist eine quelloffene, produktionsreife Vektordatenbank, geschrieben in Rust. Sie liefert schnelle, approximative Suche nach den nächsten Nachbarn (ANN) über Milliarden von Vektoren hinweg mit fortschrittlichem Filtern, Payload-Indexierung und Unterstützung für Multi-Vektoren. Sie ist das Rückgrat vieler Produktions-Pipelines für RAG (Retrieval-Augmented Generation) und semantischer Suchanwendungen.

GitHub: qdrant/qdrant — 22K+ ⭐

---

Warum Qdrant?

Funktion	Qdrant	Pinecone	Weaviate	Chroma
Open Source	✅	❌	✅	✅
Rust-Performance	✅	—	❌ Go	❌ Python
Filtern zur Abfragezeit	✅ Erweitert	✅ Grundlegend	✅	✅ Grundlegend
Mehrvektor	✅	❌	✅	❌
HNSW auf Festplattenbasis	✅	✅	✅	❌
Payload-Indexierung	✅	Begrenzt	✅	Begrenzt
gRPC + REST	✅ Beides	✅ REST	✅	REST
Selbst gehostet	✅	❌ Nur Cloud	✅	✅

Qdrant ist in Rust geschrieben — und liefert C-Niveau-Performance bei Speichersicherheit. Benchmark-Tests zeigen, dass Qdrant durchgehend 1,5–3x schneller als Python-basierte Alternativen wie Chroma in Hochlastszenarien.

---

Wichtige Anwendungsfälle

• RAG (Retrieval-Augmented Generation) — relevanten Kontext für LLM-Prompts finden

• Semantische Suche — nach Bedeutung suchen, nicht nur nach Stichwörtern

• Empfehlungssysteme — ähnliche Elemente anhand der Embedding-Ähnlichkeit finden

• Duplikaterkennung — nahezu doppelte Inhalte identifizieren

• Anomalieerkennung — Vektoren finden, die weit von Clusterzentren entfernt sind

• Bild-/Audio-Ähnlichkeitssuche — multimodales Retrieval

---

Voraussetzungen

• Clore.ai-Konto mit GPU-Miete

• Grundlegende Vertrautheit mit REST-APIs oder Python

• Dein Embedding-Modell deiner Wahl (OpenAI, SentenceTransformers usw.)

---

Schritt 1 — Einen Server auf Clore.ai mieten

Qdrant ist für das Bereitstellen hauptsächlich durch CPU/RAM begrenzt, profitiert aber von GPU, wenn:

• Embeddings zusammen mit dem Serving generiert werden (Embedding-Modell auf demselben Server)

• Batch-Indexierungsoperationen im großen Maßstab

1. Gehe zu clore.ai → Marktplatz

2. Für Kombination aus Embeddings + Serving: RTX 3090/4090 mit 32 GB+ RAM

3. Für nur Serving: CPU-optimierter Server mit schnellem NVMe-Speicher

Speicherplanung:

• Jeder float32-Vektor mit 1536 Dimensionen = 6 KB

• 1 Million Vektoren = ~6 GB RAM

• 10 Millionen Vektoren = ~60 GB RAM

• Aktiviere On-Disk-Speicher für sehr große Collections

---

Schritt 2 — Qdrant-Container bereitstellen

Docker-Image:

qdrant/qdrant:latest

Ports:

22
6333
6334

• Port 6333: REST-API (HTTP)

• Port 6334: gRPC-API (höhere Leistung für Massenoperationen)

Umgebungsvariablen:

QDRANT__SERVICE__HTTP_PORT=6333
QDRANT__SERVICE__GRPC_PORT=6334
QDRANT__LOG_LEVEL=INFO
QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage

Volume/Persistenter Speicher: Einbinden /qdrant/storage für die Datenpersistenz. Ohne dies gehen die Daten beim Neustart des Containers verloren.

---

Schritt 3 — Überprüfen, ob Qdrant läuft

ssh root@<server-ip> -p <ssh-port>

# Prüfen, ob Qdrant läuft
curl http://localhost:6333/

# Erwartete Antwort:
# {"title":"qdrant - Vektorsuchmaschine","version":"..."}

# Status prüfen
curl http://localhost:6333/healthz

# Cluster-Info prüfen
curl http://localhost:6333/cluster

---

Schritt 4 — Python-Client installieren

# Qdrant-Python-Client und Embedding-Tools installieren
pip install qdrant-client sentence-transformers openai numpy

# Verbindung überprüfen
python3 << 'EOF'
from qdrant_client import QdrantClient

client = QdrantClient("localhost", port=6333)
print(f"Qdrant verbunden: {client.get_collections()}")
EOF

---

Schritt 5 — Eine Collection erstellen

Eine Collection ist eine benannte Gruppe von Vektoren mit fester Dimensionalität.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance,
    VectorParams,
    HnswConfigDiff,
    OptimizersConfigDiff,
    QuantizationConfig,
    ScalarQuantizationConfig,
    ScalarType
)

client = QdrantClient("localhost", port=6333)

# Collection für OpenAI text-embedding-3-small erstellen (1536 Dimensionen)
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,           # Vektordimension (muss zu deinem Embedding-Modell passen)
        distance=Distance.COSINE,  # Optionen: COSINE, EUCLID, DOT
        on_disk=False        # Auf True setzen für sehr große Collections
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                # HNSW-Graph-Konnektivität (höher = besserer Recall, mehr RAM)
        ef_construct=100,    # Tiefe der Suche zur Build-Zeit (höher = bessere Qualität, langsamere Indexierung)
        full_scan_threshold=10000  # Brute-Force unterhalb dieser Anzahl verwenden
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000  # HNSW-Indexierung nach so vielen Vektoren starten
    ),
    quantization_config=QuantizationConfig(
        scalar=ScalarQuantizationConfig(
            type=ScalarType.INT8,  # Vektoren auf INT8 komprimieren (4-fache Speicherreduktion)
            quantile=0.99,
            always_ram=True        # Quantisierten Index im RAM halten
        )
    )
)

print("Collection erstellt!")
print(client.get_collection("documents"))

Collection für SentenceTransformers (384 Dimensionen)

client.create_collection(
    collection_name="embeddings_384",
    vectors_config=VectorParams(
        size=384,              # Ausgabengröße von all-MiniLM-L6-v2
        distance=Distance.COSINE
    )
)

---

Schritt 6 — Dokumente indexieren

Mit OpenAI-Embeddings

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
from openai import OpenAI
import uuid

client = QdrantClient("localhost", port=6333)
openai_client = OpenAI(api_key="your-openai-api-key")

def get_embeddings(texts: list[str], batch_size: int = 100) -> list[list[float]]:
    """Embeddings in Batches generieren."""
    all_embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        response = openai_client.embeddings.create(
            model="text-embedding-3-small",
            input=batch
        )
        all_embeddings.extend([e.embedding for e in response.data])
    return all_embeddings

# Beispieldokumente
documents = [
    {
        "id": str(uuid.uuid4()),
        "text": "Qdrant ist eine Vektordatenbank, die in Rust für hohe Leistung entwickelt wurde.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Maschinelle Lernmodelle wandeln Text in dichte Vektorrepräsentationen um.",
        "source": "article",
        "category": "ml",
        "year": 2023
    },
    # Weitere Dokumente hinzufügen...
]

# Embeddings generieren
texts = [doc["text"] for doc in documents]
embeddings = get_embeddings(texts)

# In Qdrant einfügen
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding,
        payload={
            "text": doc["text"],
            "source": doc["source"],
            "category": doc["category"],
            "year": doc["year"]
        }
    )
    for doc, embedding in zip(documents, embeddings)
]

client.upsert(
    collection_name="documents",
    points=points,
    wait=True  # Auf Abschluss der Indexierung warten
)

print(f"{len(points)} Dokumente indexiert!")

Mit SentenceTransformers (lokal, GPU-beschleunigt)

from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
import torch
import uuid

# Embedding-Modell auf der GPU laden
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

client = QdrantClient("localhost", port=6333)

documents = [
    {"text": "Wie richte ich Qdrant auf einem GPU-Server ein?", "tag": "setup"},
    {"text": "Vektordatenbanken speichern hochdimensionale Embeddings für die Ähnlichkeitssuche.", "tag": "concept"},
    {"text": "Der HNSW-Algorithmus ermöglicht eine approximative Suche nach den nächsten Nachbarn.", "tag": "algorithm"},
    # ... weitere Dokumente
]

# GPU-beschleunigte Batch-Codierung
texts = [doc["text"] for doc in documents]
embeddings = model.encode(
    texts,
    batch_size=256,       # Große Batch-Größe für GPU-Effizienz
    show_progress_bar=True,
    normalize_embeddings=True  # Für Kosinus-Ähnlichkeit normalisieren
)

# In Qdrant indexieren
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding.tolist(),
        payload=doc
    )
    for doc, embedding in zip(documents, embeddings)
]

# Batch-Upsert (effizienter)
BATCH_SIZE = 1000
for i in range(0, len(points), BATCH_SIZE):
    batch = points[i:i + BATCH_SIZE]
    client.upsert(collection_name="embeddings_384", points=batch)
    print(f"Indexed {min(i + BATCH_SIZE, len(points))}/{len(points)}")

---

Schritt 7 — Suchen und Abfragen

Einfache semantische Suche

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer

client = QdrantClient("localhost", port=6333)
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, limit: int = 5, collection: str = "embeddings_384"):
    # Abfrage-Embedding generieren
    query_vector = model.encode(query, normalize_embeddings=True).tolist()
    
    # Suchen
    results = client.search(
        collection_name=collection,
        query_vector=query_vector,
        limit=limit,
        with_payload=True,
        with_vectors=False    # Keine Vektoren zurückgeben (spart Bandbreite)
    )
    
    return results

# Suche testen
results = search("Leistung von Vektordatenbanken")
for r in results:
    print(f"Score: {r.score:.4f} | {r.payload['text'][:100]}")

Gefilterte Suche (Metadaten + Vektor)

from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

# Mit Metadatenfiltern suchen
results = client.search(
    collection_name="documents",
    query_vector=query_vector,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="database")
            ),
            FieldCondition(
                key="year",
                range=Range(gte=2023)  # Jahr >= 2023
            )
        ]
    ),
    limit=10,
    with_payload=True
)

Batch-/Multi-Abfrage-Suche

from qdrant_client.models import SearchRequest

queries = [
    "wie man eine Vektordatenbank installiert",
    "Optimierung der Inferenz im maschinellen Lernen",
    "RAG-Pipeline-Architektur"
]

query_vectors = model.encode(queries, normalize_embeddings=True)

# Batch-Suche (ein API-Aufruf für alle Abfragen)
results = client.search_batch(
    collection_name="embeddings_384",
    requests=[
        SearchRequest(
            vector=vec.tolist(),
            limit=5,
            with_payload=True
        )
        for vec in query_vectors
    ]
)

for query, res in zip(queries, results):
    print(f"\nAbfrage: {query}")
    for r in res:
        print(f"  {r.score:.3f}: {r.payload['text'][:80]}")

---

Schritt 8 — Eine RAG-Pipeline aufbauen

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer
from openai import OpenAI

# Clients initialisieren
qdrant = QdrantClient("localhost", port=6333)
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key="your-openai-key")

def rag_query(question: str, n_context: int = 5) -> str:
    # Schritt 1: Die Frage einbetten
    query_vector = embedder.encode(question, normalize_embeddings=True).tolist()
    
    # Schritt 2: Relevanten Kontext aus Qdrant abrufen
    search_results = qdrant.search(
        collection_name="documents",
        query_vector=query_vector,
        limit=n_context,
        with_payload=True
    )
    
    # Schritt 3: Kontext-String erstellen
    context = "\n\n".join([
        f"[Quelle: {r.payload.get('source', 'unknown')}]\n{r.payload['text']}"
        for r in search_results
        if r.score > 0.5  # Ergebnisse mit geringer Sicherheit filtern
    ])
    
    # Schritt 4: Antwort mit dem LLM generieren
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Beantworte Fragen auf Basis des bereitgestellten Kontexts. Sei prägnant und präzise."
            },
            {
                "role": "user",
                "content": f"Kontext:\n{context}\n\nFrage: {question}"
            }
        ],
        temperature=0.1
    )
    
    return response.choices[0].message.content

# RAG-Pipeline testen
answer = rag_query("Was ist Qdrant und wie funktioniert es?")
print(answer)

---

Schritt 9 — Collections überwachen und verwalten

# Collection-Statistiken
info = client.get_collection("documents")
print(f"Vektoranzahl: {info.vectors_count:,}")
print(f"Punktanzahl: {info.points_count:,}")
print(f"Indexierte Vektoren: {info.indexed_vectors_count:,}")
print(f"Status: {info.status}")
print(f"Festplattennutzung: {info.disk_data_size / 1024 / 1024:.1f} MB")

# Alle Collections auflisten
collections = client.get_collections()
for c in collections.collections:
    print(f" - {c.name}")

# Punkte nach Filter löschen
client.delete(
    collection_name="documents",
    points_selector=Filter(
        must=[FieldCondition(key="source", match=MatchValue(value="old_source"))]
    )
)

# Collection optimieren (Indexaufbau erzwingen)
client.update_collection(
    collection_name="documents",
    optimizer_config=OptimizersConfigDiff(indexing_threshold=0)  # Sofortige Indexierung erzwingen
)

---

Fehlerbehebung

Verbindung verweigert

# Prüfen, ob Qdrant läuft
docker ps | grep qdrant
# Oder den Prozess prüfen
ps aux | grep qdrant

# Prüfen, ob die Ports offen sind
curl http://localhost:6333/
netstat -tlnp | grep 6333

Langsame Suchleistung

# HNSW-Parameter für besseren Recall optimieren
client.update_collection(
    collection_name="documents",
    hnsw_config=HnswConfigDiff(ef=128)  # ef zur Suchzeit erhöhen (Standard 100)
)

# INT8-Quantisierung verwenden, um mehr Vektoren in den RAM zu bekommen

Hohe Speicherauslastung

# On-Disk-Speicher für große Collections aktivieren
client.create_collection(
    collection_name="large_collection",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE,
        on_disk=True  # Vektoren auf der Festplatte statt im RAM speichern
    )
)

---

Kurzübersicht der REST-API

# Collections auflisten
curl http://localhost:6333/collections

# Collection erstellen
curl -X PUT http://localhost:6333/collections/my_collection \\
    -H "Content-Type: application/json" \\
    -d '{"vectors": {"size": 384, "distance": "Cosine"}}'

# Punkte zählen
curl http://localhost:6333/collections/my_collection/points/count

# Suchen
curl -X POST http://localhost:6333/collections/my_collection/points/search \\
    -H "Content-Type: application/json" \\
    -d '{
        "vector": [0.1, 0.2, ...],
        "limit": 5,
        "with_payload": true
    }'

# Sammlung löschen
curl -X DELETE http://localhost:6333/collections/my_collection

---

Kostenschätzung auf Clore.ai

Einrichtung	Server	Monatliche Kosten	Kapazität
Kleines RAG	RTX 3090, 32 GB RAM	~60–80 $	~5 Mio. Vektoren
Mittlere Suche	RTX 4090, 64 GB RAM	~120–150 $	~15 Mio. Vektoren
Großer Maßstab	A100, 128 GB RAM	~250–350 $	~30 Mio. Vektoren

---

Zusätzliche Ressourcen

• Qdrant-Dokumentation

• Qdrant GitHub

• Qdrant Python-Client

• Qdrant-Beispiele

• Benchmarks für Vektordatenbanken

• Sentence Transformers

---

Qdrant auf Clore.ai bietet Ihnen eine selbst gehostete, leistungsstarke Vektordatenbank ohne die pro Abfrage anfallenden Kosten von Pinecone oder Weaviate Cloud. Perfekt für RAG-Pipelines, die Millionen von Dokumenten verarbeiten.

---

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
Produktionsrecherche in Vektoren	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Embedding mit hohem Durchsatz	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde

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