Vektordatenbanken für KI-Agenten

Vektordatenbanken sind das Langzeitgedächtnis von KI-Agenten. Ohne sie sind LLMs auf das angewiesen, was in ihren Trainingsdaten steht — und das ist oft veraltet, unvollständig oder domänenunspezifisch. Mit Vektordatenbanken können Agenten semantisch suchen, sich an frühere Konversationen erinnern und domänenspezifisches Wissen über RAG (Retrieval-Augmented Generation) abrufen.

Wenn Du einen KI-Agenten baust, der mehr kann als “nur chatten”, brauchst Du früher oder später eine Vektordatenbank. Dieser Artikel erklärt die Konzepte, vergleicht die wichtigsten Lösungen und zeigt vollständige Code-Beispiele.

TL;DR — Vektordatenbanken in 90 Sekunden

Was ist eine Vektordatenbank?

Embeddings — Die Grundlage

Bevor wir Vektordatenbanken verstehen, müssen wir Embeddings verstehen. Ein Embedding ist eine numerische Repräsentation von Text — ein Array von Hunderten oder Tausenden von Zahlen, die die “Bedeutung” des Textes erfassen.

from openai import OpenAI
client = OpenAI()

# Text → Vektor (1536 Dimensionen bei text-embedding-3-small)
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Python ist eine Programmiersprache."
)

vector = response.data[0].embedding
print(f"Dimensionen: {len(vector)}")  # z.B. 1536
print(f"Erste 5 Werte: {vector[:5]}")
# [0.012, -0.034, 0.056, 0.078, -0.091, ...]

Das Schlüsselprinzip: Texte mit ähnlicher Bedeutung haben ähnliche Vektoren. “Python ist eine Programmiersprache” und “Python ist eine Skriptsprache” haben Vektoren, die nah beieinander liegen. “Python ist eine Schlange” hat einen weiter entfernten Vektor.

Ähnlichkeitssuche — Wie Vektordatenbanken finden

Vektordatenbanken finden ähnliche Vektoren mit Distanzmetriken:

• Cosine Similarity: Misst den Winkel zwischen Vektoren. Beliebt für Text-Embeddings. Wert 1 = identisch, 0 = unabhängig.
• Euclidean Distance (L2): Gerade Linie zwischen Vektoren. Kleinere Distanz = ähnlicher.
• Dot Product: Schnell, aber weniger aussagekräftig ohne Normalisierung.

# Cosine Similarity manuell berechnet
import numpy as np

def cosine_similarity(v1, v2):
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

sim = cosine_similarity(vector_a, vector_b)
# 0.95 = sehr ähnlich, 0.50 = mäßig ähnlich, 0.10 = kaum ähnlich

Der vollständige Workflow

SPEICHERN:
Text → Embedding-Modell → Vektor [0.12, -0.34, 0.56, ...] 
    → Vektordatenbank (mit Metadaten: Quelle, Datum, Kategorie)

SUCHEN:
Query "Was ist Python?" → Embedding-Modell → Vektor 
    → Ähnlichkeitssuche in DB → Top-K ähnlichste Vektoren 
    → Zugehörige Texte zurückgeben

Warum brauchen KI-Agenten Vektordatenbanken?

1. Langzeitgedächtnis

LLMs haben ein begrenztes Context-Window (z.B. 128K Tokens bei GPT-4o). Konversationen, die länger sind, müssen extern gespeichert werden. Vektordatenbanken ermöglichen es, relevante frühere Konversationen semantisch zu finden und in den Kontext zu laden.

2. RAG — Retrieval-Augmented Generation

Statt das LLM auf Trainingsdaten zu verlassen, suchst Du relevante Dokumente in der Vektordatenbank und gibst sie als Kontext mit:

User-Frage → Vektordatenbank-Suche → Top 5 relevante Dokumente 
    → LLM-Prompt: "Beantworte die Frage basierend auf diesen Dokumenten: ..."

Das ist der Standard-Workflow für domänenspezifische KI-Agenten (z.B. Customer-Support, interne Wissensbasen, Code-Dokumentation).

3. Semantische Suche

Traditionelle Suchen brauchen exakte Keywords. Vektordatenbanken finden Bedeutungsähnlichkeit: “Wie programmiere ich eine Schleife?” findet auch “Loop-Implementierung in Python”.

4. Skalierbarkeit

Bei Millionen von Dokumenten ist Keyword-Suche langsam und unpräzise. Vektordatenbanken verwenden Approximate Nearest Neighbor (ANN) Algorithmen, die auch bei Milliarden von Vektoren in Millisekunden suchen.

Die wichtigsten Vektordatenbanken — Im Detail

Qdrant — Hochperformant in Rust

Qdrant ist eine in Rust geschriebene Vektordatenbank, die für Geschwindigkeit und Produktionseinsatz optimiert ist. Sie unterstützt Filtering, Payload-Metadaten und verschiedene Distanzmetriken.

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

# Verbindung (lokal oder Cloud)
client = QdrantClient(host="localhost", port=6333)
# Oder Cloud: QdrantClient(url="https://cluster-url", api_key="...")

# Collection erstellen (wie eine Tabelle in SQL)
client.create_collection(
    "agent_memory",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    # Optional: Optimierung für Produktion
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=0,  # Sofort indexieren
    )
)

# Vektoren mit Metadaten einfügen
client.upsert(
    "agent_memory",
    points=[
        PointStruct(
            id=1,
            vector=[0.12, -0.34, 0.56],  # In Praxis: 1536-dimensional
            payload={
                "text": "Python ist eine Programmiersprache.",
                "category": "programming",
                "source": "wikipedia",
                "date": "2026-07"
            }
        ),
        PointStruct(
            id=2,
            vector=[0.15, -0.31, 0.52],
            payload={
                "text": "Java ist eine objektorientierte Sprache.",
                "category": "programming",
                "source": "oracle-docs",
                "date": "2026-07"
            }
        )
    ]
)

# Semantische Suche mit Filter
results = client.search(
    "agent_memory",
    query_vector=[0.11, -0.32, 0.55],
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="programming"))
        ]
    ),
    limit=5
)

for result in results:
    print(f"Score: {result.score:.4f} - {result.payload['text']}")

Stärken: Sehr schnell (Rust), gut für Produktion, Filtering, Self-Hosting oder Cloud, Open Source. Nachteile: Weniger Community als Pinecone, keine eingebauten Embeddings (externes Modell nötig). Eignung: Produktionssysteme, wo Performance und Self-Hosting wichtig sind.

Weaviate — GraphQL-API mit eingebauten Embeddings

Weaviate ist eine in Go geschriebene Vektordatenbank mit eingebauten Embedding-Modellen. Du musst keine externen Embeddings generieren — Weaviate macht das automatisch.

import weaviate

# Verbindung (lokal)
client = weaviate.connect_to_local()

# Collection mit automatischen Embeddings erstellen
articles = client.collections.create(
    name="Article",
    vectorizer_config=weaviate.Configure.Vectorizer.text2vec_openai(),
    # Weaviate generiert Embeddings automatisch!
)

# Objekt hinzufügen (ohne manuelle Vektoren!)
articles.data.insert({
    "title": "KI-Programmierung 2026",
    "content": "Vollständiger Artikeltext...",
    "category": "programming"
})
# Weaviate generiert den Vektor automatisch

# Semantische Suche (near_text, nicht near_vector!)
results = articles.query.near_text(
    query="Wie funktioniert KI-Programmierung?",
    limit=5,
    filters=Filter.by_property("category").equal("programming")
)

for obj in results.objects:
    print(f"{obj.properties['title']}: {obj.properties['content'][:100]}")

Stärken: Eingebaute Embeddings (kein externes Modell nötig), GraphQL-API, Hybrid Search (Vektor + Keyword), Multi-Modal (Text, Bild, Audio). Nachteile: Komplexer Setup, höherer Ressourcenbedarf, weniger flexibel bei Embedding-Modell-Wahl. Eignung: Projekte, wo Hybrid Search wichtig ist und Du Embeddings nicht selbst verwalten willst.

Chroma — Einfachste Integration für Python

Chroma (früher ChromaDB) ist die einfachste Vektordatenbank für Python. Sie ist in Python geschrieben und benötigt keinen separaten Server — alles läuft im Prozess.

import chromadb

# In-Memory oder persistent
client = chromadb.PersistentClient(path="./chroma_data")
# Oder In-Memory: client = chromadb.Client()

# Collection erstellen
collection = client.create_collection(
    name="agent_memory",
    metadata={"description": "Langzeitgedächtnis des KI-Agenten"}
)

# Hinzufügen (Chroma generiert Embeddings automatisch mit Default-Modell!)
collection.add(
    documents=["Python ist eine Programmiersprache."],
    metadatas=[{"source": "wiki", "category": "programming"}],
    ids=["1"]
)

# Oder mit eigenen Embeddings:
# collection.add(embeddings=[[0.12, ...]], documents=[...], ids=[...])

# Semantische Suche
results = collection.query(
    query_texts=["Was ist Python?"],
    n_results=5,
    where={"category": "programming"}  # Metadaten-Filter
)

for doc, score, meta in zip(
    results["documents"][0],
    results["distances"][0],
    results["metadatas"][0]
):
    print(f"Score: {score:.4f} - {doc} (Source: {meta['source']})")

Stärken: Einfachste Integration (3 Zeilen Code), kostenlos, kein Server nötig, automatische Embeddings mit Default-Modell. Nachteile: Nicht für große Skalierung gedacht (Millionen+ Vektoren), weniger Features als Qdrant/Weaviate. Eignung: Prototypen, Entwicklung, kleine Projekte, lokale Tests.

Pinecone — Managed Cloud-Vektordatenbank

Pinecone ist eine vollständig gemanagte Cloud-Vektordatenbank. Keine Infrastruktur, keine Wartung, keine Skalierungsprobleme — aber kostenpflichtig.

from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
index = pc.Index("agent-memory")

# Upsert
index.upsert(
    vectors=[
        {
            "id": "1",
            "values": [0.12, -0.34, 0.56],  # 1536-dimensional
            "metadata": {"text": "Python ist eine Programmiersprache.", "category": "programming"}
        }
    ]
)

# Query mit Filter
results = index.query(
    vector=[0.11, -0.32, 0.55],
    top_k=5,
    include_metadata=True,
    filter={"category": {"$eq": "programming"}}
)

for match in results["matches"]:
    print(f"Score: {match['score']:.4f} - {match['metadata']['text']}")

Stärken: Vollständig gemanagt, skalierbar (Milliarden Vektoren), keine Infrastruktur, Serverless-Option. Nachteile: Kosten (ab ~70$/Monat), Vendor Lock-in, Daten verlassen das eigene System (Cloud). Eignung: Enterprise, wenn Du keine Infrastruktur betreiben willst und Budget vorhanden ist.

Vergleich

Feature	Qdrant	Weaviate	Chroma	Pinecone
Hosting	Self/Cloud	Self/Cloud	Self/Local	Cloud only
Sprache	Rust	Go	Python	Go
Embeddings	Extern	Eingebaut	Extern/Default	Extern
Hybrid Search	Ja	Ja	Nein	Ja
Skalierbarkeit	Hoch	Hoch	Mittel	Sehr hoch
Kosten	OSS/Cloud	OSS/Cloud	Kostenlos	Ab ~70$/Monat
Filtering	Ja (Payload)	Ja (GraphQL)	Ja (where)	Ja (metadata)
Multi-Modal	Nein	Ja (Text/Bild/Audio)	Nein	Nein
Eignung	Produktion	Komplex/Hybrid	Prototyp	Enterprise

Meine Empfehlung:

• Entwicklung/Prototyp: Chroma — 3 Zeilen Code, kostenlos, kein Server
• Produktion (Self-Hosted): Qdrant — schnell, Rust, Open Source, gut dokumentiert
• Produktion (Managed): Pinecone — keine Infrastruktur, wenn Budget vorhanden
• Hybrid Search nötig: Weaviate — einzige mit echter Vektor + Keyword Hybrid Search

RAG-Pipeline mit Vektordatenbanken

RAG (Retrieval-Augmented Generation) ist der häufigste Use Case für Vektordatenbanken in KI-Agenten. Hier ist eine vollständige Pipeline:

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_qdrant import QdrantVectorStore
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. Dokumente laden und chunken
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # 500 Tokens pro Chunk
    chunk_overlap=100,     # 100 Token Overlap zwischen Chunks
    separators=["\n\n", "\n", ". ", " "]
)
chunks = text_splitter.split_text(document_text)
# chunks = ["Erster Abschnitt...", "Zweiter Abschnitt...", ...]

# 2. Embeddings generieren und in Qdrant speichern
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = QdrantVectorStore.from_texts(
    chunks,
    embeddings,
    url="http://localhost:6333",
    collection_name="knowledge_base"
)

# 3. RAG-Query: Relevante Dokumente finden
llm = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = vector_store.as_retriever(search_kwargs={"k": 5})

# 4. Antwort generieren mit gefundenen Dokumenten als Kontext
from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True  # Zeigt, welche Dokumente verwendet wurden
)

result = qa_chain.invoke({"query": "Was ist KI-Programmierung?"})
print(f"Antwort: {result['result']}")
print(f"Quellen: {len(result['source_documents'])} Dokumente verwendet")

Was hier passiert:

1. Chunking: Der Dokumenttext wird in 500-Token-Stücke geschnitten (mit 100 Token Overlap, damit Kontext nicht verloren geht)
2. Embedding + Speichern: Jeder Chunk wird zu einem Vektor und in Qdrant gespeichert
3. Retrieval: Die User-Frage wird zu einem Vektor, und Qdrant findet die 5 ähnlichsten Chunks
4. Generation: Das LLM bekommt die Frage + die 5 gefundenen Chunks als Kontext und generiert eine Antwort

RAG in Multi-Agent-Systemen

In einem Multi-Agent-System kann jeder Agent seine eigene Vektordatenbank haben:

# Research Agent: Sucht in Web-Scraping-Daten
research_db = QdrantVectorStore(collection_name="web_research", ...)

# Code Agent: Sucht in Code-Dokumentation
code_db = QdrantVectorStore(collection_name="code_docs", ...)

# Support Agent: Sucht in Knowledge-Base
support_db = QdrantVectorStore(collection_name="kb_articles", ...)

Best Practices

1. Chunk-Größe optimieren

Die Chunk-Größe ist der wichtigste Parameter für RAG-Qualität:

• Zu klein (100 Tokens): Verliert Kontext — der Chunk allein macht keinen Sinn
• Zu groß (2000 Tokens): Unpräzise Suche — der Vektor repräsentiert zu viele Themen
• Empfehlung: 500-1000 Tokens, mit 100-200 Token Overlap

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100,
    separators=["\n\n", "\n", ". ", " "]  # Natürliche Trennpunkte
)

2. Metadaten nutzen

Metadaten ermöglichen Filtering — kritisch für große Datenbanken:

# Metadaten beim Speichern
collection.add(
    documents=["Artikel über Python"],
    metadatas=[{
        "category": "programming",
        "date": "2026-07",
        "author": "IRC",
        "source": "wiki",
        "language": "de"
    }],
    ids=["1"]
)

# Gefilterte Suche: Nur deutsche Programmier-Artikel
results = collection.query(
    query_texts=["Python"],
    where={"$and": [
        {"category": {"$eq": "programming"}},
        {"language": {"$eq": "de"}}
    ]},
    n_results=5
)

3. Embedding-Modell wählen

Modell	Dimensionen	Kosten	Eignung
text-embedding-3-small	1536	$0.02/M tokens	Standard, schnell
text-embedding-3-large	3072	$0.13/M tokens	Höhere Qualität
sentence-transformers (lokal)	384-768	Kostenlos	Entwicklung, Privacy

Wichtig: Wenn Du das Embedding-Modell wechselst, müssen alle Vektoren neu generiert werden (Re-Embedding). Verschiedene Modelle produzieren inkompatible Vektoren.

4. Monitoring

• Query-Latenz überwachen: Sollte unter 100ms liegen für gute UX
• Recall-Quality messen: Test-Set mit bekannten Query-Document-Pairs
• Speicherbedarf tracken: Vektoren brauchen Speicher (1536 Dimensionen × 4 Bytes = ~6KB pro Vektor)
• Index-Größe: Qdrant und Pinecone zeigen Index-Statistiken

5. Re-Embedding Strategy

Wenn Du das Embedding-Modell aktualisierst:

1. Neue Collection erstellen
2. Alle Dokumente neu embedden und in neue Collection speichern
3. Tests auf neuer Collection durchführen
4. Alias von alter auf neue Collection umleiten
5. Alte Collection löschen

Prüfungsrelevante Punkte

• Vektordatenbank: Speichert Embeddings (numerische Vektoren) für semantische Suche
• Embeddings: Numerische Repräsentation von Text, generiert von Embedding-Modellen (z.B. OpenAI text-embedding-3-small, 1536 Dimensionen)
• Ähnlichkeitssuche: Cosine Similarity, Euclidean Distance, Dot Product
• RAG: Retrieval-Augmented Generation — LLM bekommt relevante Dokumente aus Vektordatenbank als Kontext
• Chunking: Text in Stücke schneiden (500-1000 Tokens, 100-200 Overlap)
• Tools: Qdrant (Rust, Produktion), Weaviate (Go, Hybrid Search, eingebaute Embeddings), Chroma (Python, Prototypen), Pinecone (Cloud, Enterprise)
• Best Practices: Chunk-Größe optimieren, Metadaten für Filtering, Embedding-Modell bewusst wählen, Monitoring, Re-Embedding bei Modellwechsel

FAQ

Welche Vektordatenbank für den Anfang? Chroma für Prototypen — 3 Zeilen Code, kostenlos, kein Server. Qdrant für Produktion — schnell, Open Source, Self-Hosting oder Cloud.

Brauche ich Vektordatenbanken für jeden KI-Agenten? Nein. Nur wenn der Agent auf großen Wissensbasen suchen muss, Langzeitgedächtnis braucht, oder RAG für domänenspezifische Antworten nutzt. Für einfache Chatbots reicht das LLM-Context-Window.

Kann ich Vektordatenbanken lokal betreiben? Ja. Qdrant (Docker), Weaviate (Docker) und Chroma (Python-Prozess) können lokal betrieben werden. Pinecone ist Cloud-only.

Wie viele Vektoren passen in eine Vektordatenbank? Qdrant und Pinecone: Milliarden. Weaviate: Millionen. Chroma: Hunderttausende (danach wird es langsam). Die Grenze ist meist Speicherplatz, nicht die Software.

Was kostet der Betrieb einer Vektordatenbank?

• Chroma: Kostenlos (Self-Hosted)
• Qdrant: Kostenlos (Self-Hosted) oder Cloud ab ~25$/Monat
• Weaviate: Kostenlos (Self-Hosted) oder Cloud ab ~25$/Monat
• Pinecone: Ab ~70$/Monat (Cloud only)
• Embedding-Kosten: text-embedding-3-small kostet $0.02 pro 1M Tokens

Kann ich Vektordatenbanken mit lokalen Embedding-Modellen verwenden? Ja. Mit sentence-transformers (z.B. all-MiniLM-L6-v2) kannst Du kostenlos lokal embedden. Die Vektoren sind kleiner (384 Dimensionen) und die Qualität etwas geringer als OpenAI, aber für viele Use Cases ausreichend. Ideal für Privacy-sensitive Daten.

Empfohlene Literatur