0Pricing
AI Engineering Academy · Lektion

Vektorspeicher auswählen und benchmarken

Sie vergleichen Pinecone, pgvector, Chroma, Weaviate und Qdrant hinsichtlich Kosten, Latenz, Filterfunktionen und betrieblicher Komplexität, um das passende Tool für Ihren Anwendungsfall auszuwählen.

Vektorspeicher auswählen und benchmarken ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Landschaft der Vektorspeicher

Das Ökosystem der Vektordatenbanken ist in den vergangenen Jahren stark gewachsen. Die Optionen reichen von spezialisierten Cloud-Diensten wie Pinecone über PostgreSQL-Erweiterungen wie pgvector und quelloffene Server wie Chroma, Qdrant und Weaviate bis hin zu In-Memory-Bibliotheken wie FAISS. Die Wahl des richtigen Tools ist wichtig, denn ein späterer Wechsel ist kostspielig, sobald Ihre Daten indexiert sind.

Wichtige Bewertungskriterien

Bewerten Sie beim Vergleich von Vektorspeichern fünf Kriterien: die Abfragelatenz bei der angestrebten Skalierung, den Indexierungsdurchsatz für die Batch-Aufnahme, die Filterfunktionen für die Vorfilterung anhand von Metadaten, die betriebliche Komplexität (verwaltet oder selbst gehostet) sowie die Kosten pro Million gespeicherter und abgefragter Vektoren. Kein einzelnes Tool ist in jeder Kategorie führend.

Pinecone: Einfachheit durch Managed Services

Pinecone ist eine vollständig verwaltete Cloud-Vektordatenbank, die keinerlei Infrastrukturverwaltung erfordert. Sie eignet sich besonders für Workloads mit hoher Nebenläufigkeit, bietet native hybride Sparse-Dense-Suche und liefert bei jeder Skalierung konsistente Abfragen im einstelligen Millisekundenbereich. Der Nachteil sind die Kosten: Pinecone ist teurer als selbst gehostete Optionen und führt zu einer Anbieterabhängigkeit, da sich alle Daten in der Cloud von Pinecone befinden.

import pinecone

pc = pinecone.Pinecone(api_key='YOUR_API_KEY')
index = pc.Index('my-index')

# Query with metadata filter
results = index.query(
    vector=[0.1, 0.2, 0.3],
    top_k=10,
    filter={'category': {'$eq': 'finance'}},
    include_metadata=True
)

pgvector: Embeddings in PostgreSQL

pgvector erweitert PostgreSQL um einen vector-Datentyp und ANN-Indizes (Approximate Nearest Neighbor, Suche nach ungefähren nächsten Nachbarn) mithilfe der Algorithmen HNSW oder IVFFlat. Die Erweiterung ist ideal, wenn Sie PostgreSQL bereits betreiben, da Ihre Embeddings in derselben Datenbank wie Ihre relationalen Daten liegen. Dadurch werden leistungsfähige SQL-Joins zwischen Vektorsuche und strukturierten Filtern ohne zusätzliche Infrastruktur möglich.

-- Create table with embedding column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    category TEXT,
    embedding vector(1536)
);

-- Create HNSW index for fast ANN search
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Query nearest neighbors with SQL filter
SELECT content, 1 - (embedding <=> '[0.1,0.2,...]')
FROM documents
WHERE category = 'finance'
ORDER BY embedding <=> '[0.1,0.2,...]'
LIMIT 10;

Chroma: Entwicklerfreundlich und lokal ausgerichtet

Chroma ist eine quelloffene Embedding-Datenbank für schnelles Prototyping. Für die lokale Entwicklung läuft sie direkt im Prozess (kein Server erforderlich) und unterstützt für den Produktionseinsatz einen persistenten Servermodus. Chroma ist in LangChain-Tutorials wegen seiner äußerst einfachen API beliebt, hat bei großer Skalierung jedoch Einschränkungen: Es gibt keinen verteilten Modus und die Filterung ist schwächer als bei Pinecone oder Qdrant.

import chromadb

client = chromadb.PersistentClient(path='./chroma_db')
collection = client.get_or_create_collection('my_docs')

# Add documents
collection.add(
    documents=['text one', 'text two'],
    metadatas=[{'source': 'doc1'}, {'source': 'doc2'}],
    ids=['id1', 'id2']
)

# Query
results = collection.query(
    query_texts=['search query'],
    n_results=5
)

Qdrant: Filterung und Payload-Suche

Qdrant ist eine in Rust geschriebene quelloffene Vektordatenbank, die sich besonders für komplexe Metadatenfilter eignet. Anders als Datenbanken, die Filter erst nach der ANN-Suche anwenden, filtert Qdrant Kandidatenvektoren anhand von Payload-Feldern vor der Bewertung vor. Dadurch verbessert sich die Präzision bei selektiven Filtern erheblich. Qdrant unterstützt HNSW-Indizes auf der Festplatte und eignet sich somit für Datensätze, die nicht in den Arbeitsspeicher passen.

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

client = QdrantClient(url='http://localhost:6333')

# Search with payload filter
results = client.search(
    collection_name='documents',
    query_vector=[0.1, 0.2, 0.3],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='category',
                match=MatchValue(value='finance')
            )
        ]
    ),
    limit=10
)

Weaviate: GraphQL und multimodale Daten

Weaviate ist eine quelloffene Vektordatenbank mit einer einzigartigen GraphQL-API und integrierter Unterstützung für multimodale Objekte (Text, Bilder, Audio). Über Module lässt sie sich direkt in Anbieter von Embedding-Modellen integrieren. So können Sie Rohtext aufnehmen und Weaviate automatisch die Embedding-API aufrufen lassen. Dieser Komfort geht mit einer komplexeren Einrichtung im Vergleich zu Chroma oder Qdrant einher.

import weaviate

client = weaviate.Client('http://localhost:8080')

# Near-text search using built-in vectorizer
result = client.query.get(
    'Document', ['content', 'category']
).with_near_text(
    {'concepts': ['financial analysis']}
).with_where({
    'path': ['category'],
    'operator': 'Equal',
    'valueString': 'finance'
}).with_limit(10).do()

FAISS: In-Memory-Suche in großem Maßstab

FAISS (Facebook AI Similarity Search) ist eine C++-Bibliothek mit Python-Bindings, die extrem schnelle In-Memory-Vektorsuchen ermöglicht. FAISS ist keine Datenbank (ohne Persistenz oder Server), kann aber mit GPU-Beschleunigung Ähnlichkeitssuchen im Maßstab von Milliarden von Vektoren auf einer einzigen Maschine durchführen. FAISS ist die richtige Wahl für leseintensive Offline-Batch-Suchen, bei denen Sie den gesamten Stack kontrollieren.

import faiss
import numpy as np

dimension = 1536
vectors = np.random.random((100000, dimension)).astype('float32')

# Normalize for cosine similarity
faiss.normalize_L2(vectors)

# Build HNSW index
index = faiss.IndexHNSWFlat(dimension, 32)  # M=32 neighbors
index.add(vectors)

# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
D, I = index.search(query, k=10)  # top-10 results

Einen Benchmark-Test erstellen

Die einzige Möglichkeit, eine fundierte Entscheidung zu treffen, besteht darin, Ihre eigenen Daten zu benchmarken. Ein guter Benchmark misst: (1) die Indexierungszeit für den vollständigen Datensatz, (2) die Abfragelatenz bei den Perzentilen p50, p95 und p99 unter gleichzeitiger Last, (3) recall@K durch den Vergleich von ANN-Ergebnissen mit exakten Ergebnissen per Brute-Force-Suche sowie (4) den Speicherbedarf und die Kosten bei der angestrebten Skalierung. Führen Sie dieselben Abfragen für jeden infrage kommenden Vektorspeicher aus.

import time
import numpy as np

def benchmark_store(store, queries, k=10):
    latencies = []
    for q in queries:
        start = time.perf_counter()
        store.search(q, k)
        latencies.append(time.perf_counter() - start)
    latencies.sort()
    n = len(latencies)
    print(f'p50: {latencies[n//2]*1000:.1f}ms')
    print(f'p95: {latencies[int(n*0.95)]*1000:.1f}ms')
    print(f'p99: {latencies[int(n*0.99)]*1000:.1f}ms')

Kompromiss zwischen Trefferquote und Latenz messen

ANN-Indizes tauschen Trefferquote gegen Geschwindigkeit. Ein höherer HNSW-Parameter ef_search findet genauere Nachbarn, benötigt dafür aber mehr Zeit. Messen Sie recall@10 (den Anteil der tatsächlich besten 10 Nachbarn, die zurückgegeben werden) bei verschiedenen Parametereinstellungen und tragen Sie Trefferquote und Latenz grafisch gegeneinander auf. Die meisten Produktionssysteme streben eine Trefferquote von 95–99 % an. Eine Trefferquote unter 90 % bedeutet, dass Benutzer irrelevante Textabschnitte erhalten, selbst wenn die Abfragen schnell sind.

def compute_recall(approx_ids, exact_ids):
    '''Compute recall@K for one query'''
    return len(set(approx_ids) & set(exact_ids)) / len(exact_ids)

def benchmark_recall(index, brute_force, queries, k=10):
    recalls = []
    for q in queries:
        approx = index.search(q, k)
        exact = brute_force.search(q, k)
        recalls.append(compute_recall(approx, exact))
    print(f'Mean recall@{k}: {sum(recalls)/len(recalls):.3f}')

Entscheidungsrahmen für die Auswahl

Verwenden Sie diesen Entscheidungsbaum: Wenn Sie keine Infrastruktur verwalten möchten und das Budget keine Einschränkung darstellt, wählen Sie Pinecone. Wenn Sie PostgreSQL bereits betreiben und Ihr Datensatz weniger als 10 Millionen Vektoren umfasst, fügen Sie pgvector hinzu. Für eine quelloffene, selbst gehostete Lösung mit komplexer Payload-Filterung wählen Sie Qdrant. Für schnelles Prototyping und lokale Entwicklung beginnen Sie mit Chroma und migrieren Sie später. Für Offline-Batch-Jobs im Maßstab von Milliarden Vektoren verwenden Sie FAISS.

Schnelltest

Testen Sie Ihr Verständnis der Konzepte aus dem Bereich AI Engineering, die in dieser Lektion behandelt wurden.

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: die Landschaft der Vektorspeicher mit Pinecone, pgvector, Chroma, Qdrant, Weaviate und FAISS, die fünf Bewertungskriterien Latenz, Durchsatz, Filterung, Komplexität und Kosten sowie einen praxisnahen Entscheidungsrahmen für die Auswahl des richtigen Vektorspeichers auf Grundlage Ihrer Infrastruktur- und Skalierungsanforderungen. Als Nächstes sehen wir uns das Problem an, zu dessen Lösung RAG entwickelt wurde.

Häufig gestellte Fragen

Ist die Lektion „Vektorspeicher auswählen und benchmarken“ kostenlos?

Ja — der vollständige Text von „Vektorspeicher auswählen und benchmarken“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Vektorspeicher auswählen und benchmarken“?

Sie vergleichen Pinecone, pgvector, Chroma, Weaviate und Qdrant hinsichtlich Kosten, Latenz, Filterfunktionen und betrieblicher Komplexität, um das passende Tool für Ihren Anwendungsfall auszuwählen. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Vektorspeicher auswählen und benchmarken“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Warum Sie eine Vektordatenbank benötigen
  2. Erste Schritte mit Pinecone
  3. pgvector: Embeddings in PostgreSQL
  4. Vektorspeicher auswählen und benchmarken
← Zurück zu AI Engineering Academy