Qdrant: Die Vektordatenbank, die einfach läuft
Praxis

Qdrant: Die Vektordatenbank, die einfach läuft

Qdrant per Docker starten, Dokumente einbetten, nach Bedeutung suchen — plus: welches Embedding-Modell du brauchst und was das wirklich kostet.

Zu viele Fachwörter?→ Im Glossar nachschlagen

In einem früheren Post haben wir geklärt, was ein Vektorstore überhaupt ist: ein Werkzeug, das Texte nach Bedeutung durchsuchbar macht. Schöne Theorie. Heute starten wir einen — und füttern ihn mit echten Dokumenten.

Das Werkzeug heißt Qdrant (gesprochen „Quadrant"). Es ist Open Source, läuft bei dir, und der Einstieg ist ehrlich gesagt unspektakulär einfach.

Was Qdrant ist — und was nicht

Qdrant ist der Vektorstore selbst: die Datenbank, die deine Zahlen-Fingerabdrücke (die Embeddings) speichert und blitzschnell die ähnlichsten findet. Mehr nicht. Es denkt nicht, es chattet nicht, es schreibt keine Texte. Es sucht. Sehr gut und sehr schnell.

Das ist wichtig zu verstehen, weil manche Tools so etwas eingebaut haben, ohne dass man es merkt. OpenWebUI etwa hat eine Wissensdatenbank an Bord. Flowise bringt selbst keinen Vektorstore mit — lässt sich aber per Mausklick mit genau so einem verbinden, etwa mit Qdrant. Qdrant ist also die Schicht darunter — die, die du selbst in die Hand nimmst, wenn du die volle Kontrolle willst.

Installation: ein Befehl

Wenn Docker läuft, ist Qdrant in einer Zeile da:

docker run -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage" \
  qdrant/qdrant

Das war's. Der -v-Teil sorgt nur dafür, dass deine Daten einen Neustart überleben (ohne ihn liegt alles im Container und ist beim nächsten Mal weg).

Im Browser auf http://localhost:6333/dashboard bekommst du sogar eine kleine Oberfläche, in der du deine Sammlungen sehen kannst. Kein Account, keine Cloud, keine Anmeldung.

(Kleiner Hinweis: Qdrant startet ohne Passwort. Für ein Experiment auf dem eigenen Rechner völlig okay — bevor du es ins offene Internet stellst, lies erst das Sicherheitskapitel der Doku.)

Dokumente einbetten — das Beispiel-Skript

Jetzt der Teil, der zeigt, was unter der Haube passiert. Wir zerlegen einen Text, schicken jedes Häppchen an ein Embedding-Modell und legen die Ergebnisse in Qdrant ab. In Python sieht das so aus:

from qdrant_client import QdrantClient, models
from openai import OpenAI

qdrant = QdrantClient(url="http://localhost:6333")
ki = OpenAI()  # API-Key kommt aus der Umgebung

qdrant.recreate_collection(            # Schritt 1: Sammlung anlegen
    "meine-notizen",
    vectors_config=models.VectorParams(size=1536, distance=models.Distance.COSINE),
)  # 1536 = Länge der Zahlenreihe bei diesem Modell

haeppchen = ["Erster Absatz ...", "Zweiter Absatz ...", "..."]
for i, text in enumerate(haeppchen):   # Schritt 2: einbetten und speichern
    vektor = ki.embeddings.create(
        model="text-embedding-3-small", input=text
    ).data[0].embedding
    qdrant.upsert("meine-notizen", [
        models.PointStruct(id=i, vector=vektor, payload={"text": text})
    ])

frage = ki.embeddings.create(          # Schritt 3: nach Bedeutung suchen
    model="text-embedding-3-small", input="Worum ging es nochmal?"
).data[0].embedding
treffer = qdrant.query_points("meine-notizen", query=frage, limit=3)
for t in treffer.points:
    print(t.payload["text"])

Drei Schritte: Sammlung anlegen, Häppchen einbetten, suchen. Genau das Prinzip aus dem Vektorstore-Artikel — nur dass jetzt eine echte Datenbank dahintersteht.

Und jetzt die ehrliche Entwarnung: Dieses Skript musst du in der Praxis selten selbst schreiben. OpenWebUI hat das Einbetten eingebaut; in Flowise klickst du dir einen Qdrant-Baustein dazu — und beide erledigen es dann im Hintergrund. Das Beispiel ist dafür da, dass du verstehst, was die schicken Tools tun. Wer es selbst baut, hat dafür jede Schraube in der Hand.

Was du aus KI-Sicht brauchst

Qdrant speichert die Embeddings — aber erzeugen muss sie ein Embedding-Modell. Das ist eine eigene Sorte KI, spezialisiert aufs Übersetzen von Text in Zahlen (nicht aufs Plaudern). Vier Wege:

  • OpenAI — text-embedding-3-small ist der unaufgeregte Standard. API-Key holen, läuft.
  • Jina AI — gibt es noch, lebt und gedeiht. Sitzt in Berlin, verarbeitet in der EU und schließt auf Wunsch einen AVV (Auftragsverarbeitungsvertrag) ab — für DSGVO-Fragen also angenehm europäisch. (Ehrliche Fußnote: Seit Ende 2025 gehört Jina zum US-Konzern Elastic; die Server bleiben laut Anbieter aber in der EU.) Zum Einstieg gibt's ein kostenloses Kontingent — zum jetzigen Stand rund eine Million Token zum Ausprobieren, nicht-kommerziell.
  • OpenRouter — der Modell-Aggregator kann inzwischen auch Embeddings, mit einem Key Zugriff auf mehrere Anbieter (OpenAI, Mistral, Qwen, Google). Praktisch zum Vergleichen.
  • Komplett lokal — mit Ollama läuft auch das Einbetten auf deinem Rechner. Wichtig: Das ist ein eigenes, aufs Einbetten spezialisiertes Modell — nicht dein Chat-Modell. Solide Kandidaten sind nomic-embed-text (klein und flott) oder bge-m3 (kann viele Sprachen, gut für Deutsch). Kein API-Key, keine Cloud, deine Dokumente verlassen das Haus nie. Nur dran denken: Diese Modelle liefern eine andere Vektorlänge als OpenAI (nomic-embed-text etwa 768 statt 1536) — dann oben im Code einfach die size der Sammlung anpassen. Etwas langsamer, dafür gratis und privat.

Der rote Faden in diesem Blog: Wo es eine offene, selbst gehostete Variante gibt, ist sie einen Blick wert — gerade wenn die Dokumente vertraulich sind.

Was kostet ein Embedding?

Die überraschende Antwort: fast nichts. text-embedding-3-small kostet zum aktuellen Stand etwa 2 Cent pro Million Token (ein Token ist ungefähr eine Silbe).

Was heißt das konkret? Ein dickes Buch mit tausend Seiten einzubetten landet im Bereich von ein, zwei Cent. Eine einzelne Suchanfrage einzubetten ist so billig, dass man es kaum noch in Cent ausdrücken kann. Und lokal über Ollama? Null — außer dem Strom für deinen Rechner.

Embeddings sind der mit Abstand günstigste Teil der ganzen KI-Rechnung. Hier musst du nicht knausern.

Zwei Wege, das einzusetzen

Zoo Code — der Open-Source-Coding-Assistent im Editor kann einen lokalen Qdrant als Gedächtnis für deinen Code nutzen. Statt bei jeder Frage die halbe Codebasis ins Modell zu kippen, sucht er gezielt die passenden Stellen heraus. Spart Token und macht die Antworten treffsicherer.

Flowise — hier klickst du dir einen kompletten KI-Ablauf zusammen, ganz ohne Code: Dokumente rein, Qdrant als Speicher, ein Chat-Modell davor — fertig ist der Chatbot, der deine Inhalte kennt. Wie das Schritt für Schritt geht, ist einen eigenen Artikel wert. Der kommt als Nächstes.

Lohnt sich das für dich?

Wenn du nur ab und zu etwas fragst: nein, dann reicht ein fertiges Tool mit eingebauter Wissensdatenbank. Qdrant selbst zu betreiben lohnt sich, sobald du etwas Eigenes bauen willst — einen Chatbot, ein Code-Gedächtnis, eine durchsuchbare Sammlung, die mit dir wächst und auf deinem Rechner bleibt.

Der Docker-Befehl von oben ist ein gefahrloser Anfang. Starte Qdrant, öffne das Dashboard, schau dich um. Und beim nächsten Mal bauen wir mit Flowise den Chatbot drumherum.