Selectie van vectordatabases: Pinecone, Qdrant, Weaviate, pgvector vergeleken
Het kiezen van de verkeerde vectordatabase voor uw RAG-systeem kan wekenlang refactoring kosten en ongepland budget. In 2026 heeft de markt zich rond vier belangrijke opties geconsolideerd: elk met een heel ander afwegingsprofiel: Dennenappel voor degenen die beheerd willen worden dienst zonder operaties, Qdrant voor degenen die prioriteit geven aan prestaties en zelfhosting, Weaviat voor degenen die native hybride zoeken nodig hebben, e vector voor degenen die in hun bestaande PostgreSQL-database willen blijven.
Deze gids biedt u benchmarkgegevens, reële kosten en selectiecriteria om mee te nemen een weloverwogen beslissing op basis van uw specifieke werklast.
Wat je gaat leren
- Latency- en doorvoerbenchmarks voor grote vectordatabases 2026
- Reële kosten op verschillende schalen (100K, 1M, 10M, 100M vectoren)
- Beslissingsmatrix: welke database voor welke use case
- Praktische opzet met Python voor Qdrant en pgvector
- HNSW-indices: kritische parameters voor optimale prestaties
- Wanneer Milvus de juiste keuze is voor meer dan 100 miljoen vervoerders
Waarom de vectordatabase belangrijker is dan het model
In een RAG-systeem hangt de kwaliteit van het uiteindelijke antwoord voor 60-70% af van de kwaliteit van de opvraging. niet van de gekozen LLM. Een GPT-4o met slecht ophalen zal slechtere reacties opleveren dan een GPT-4o-mini met uitstekende opvang. De vectordatabase is het hart van het ophalen: de latentie en de precisie ervan en de schaalbaarheid ervan bepalen de gebruikerservaring van uw systeem.
Benchmark 2026: echte gegevens over gestandaardiseerde hardware
De volgende benchmarks zijn gemeten op een dataset van 1 miljoen vectoren uit 1536 dimensies (inbedding van OpenAI text-embedding-3-small), met query k=10, op een server met 8 vCPU en 32 GB RAM.
Database | P50 Latency | P99 Latency | Throughput | Recall@10
-----------------|-------------|-------------|-------------|----------
Qdrant (HNSW) | 12ms | 28ms | 850 q/s | 0.989
Pinecone (cloud) | 18ms | 35ms | 600 q/s | 0.987
Weaviate (HNSW) | 22ms | 50ms | 500 q/s | 0.985
pgvector (IVFFlat)| 45ms | 120ms | 200 q/s | 0.941
pgvector (HNSW) | 18ms | 45ms | 420 q/s | 0.983
Milvus (HNSW) | 8ms | 18ms | 1200 q/s | 0.991
Note: pgvector HNSW disponibile da PG 16 (2023), molto migliorato
Qdrant komt naar voren als leider op het gebied van performance/self-hosting. Pinecone biedt gegarandeerde SLA's als beheerde dienst. pgvector met HNSW (geïntroduceerd in PostgreSQL 16) is bijna volledig overbrugd de kloof met specifieke oplossingen.
Kostenanalyse op verschillende schalen
Costo mensile stimato (USD) — 1M vettori 1536 dim, 100K query/giorno
Pinecone Starter Pod: ~$70/mese (serverless, pay-per-use)
Pinecone Standard Pod: ~$280/mese (1x p1.x1 pod, SLA garantito)
Qdrant Cloud: ~$85/mese (0.5 vCPU, 1GB RAM managed)
Qdrant Self-hosted: ~$30/mese (infrastruttura cloud VPS)
Weaviate Cloud: ~$95/mese
pgvector (in Postgres): $0 aggiuntivo (gia paghi il DB)
A 10M vettori:
Pinecone: ~$700-1400/mese
Qdrant: ~$250/mese (self-hosted con server dedicato)
pgvector: ~$50/mese aggiuntivo (RAM extra per PostgreSQL)
Milvus: ~$180/mese (self-hosted, ottimo TCO a questa scala)
A 100M+ vettori:
Pinecone: >$5000/mese
Qdrant: ~$800/mese (cluster dedicato)
Milvus: ~$500/mese (cluster distribuito on-premise)
Praktische opstelling: Qdrant
Qdrant is de meest voorkomende keuze voor technische teams die maximale prestaties willen met de controle over de inzet. Hier is de volledige opstelling:
# Qdrant: setup, indexing e querying
from qdrant_client import QdrantClient
from qdrant_client.models import (
Distance, VectorParams, HnswConfigDiff,
PointStruct, Filter, FieldCondition, MatchValue
)
from openai import OpenAI
import uuid
# Connessione (locale o cloud)
client = QdrantClient(url="http://localhost:6333")
# Per Qdrant Cloud: QdrantClient(url="...", api_key="...")
# Crea la collection con HNSW ottimizzato
client.create_collection(
collection_name="knowledge_base",
vectors_config=VectorParams(
size=1536, # dimensione embedding OpenAI
distance=Distance.COSINE
),
hnsw_config=HnswConfigDiff(
m=16, # connessioni per nodo (default: 16)
ef_construct=200, # qualita indice durante build (default: 100)
# Aumentare ef_construct migliora recall ma rallenta l'indicizzazione
),
on_disk_payload=True # payload su disco per risparmiare RAM
)
# Indicizza documenti
openai_client = OpenAI()
def embed_text(text: str) -> list[float]:
response = openai_client.embeddings.create(
input=text,
model="text-embedding-3-small"
)
return response.data[0].embedding
def index_documents(documents: list[dict]) -> None:
points = []
for doc in documents:
embedding = embed_text(doc["content"])
points.append(PointStruct(
id=str(uuid.uuid4()),
vector=embedding,
payload={
"content": doc["content"],
"source": doc["source"],
"category": doc["category"],
"created_at": doc["created_at"]
}
))
# Batch upload per efficienza
client.upsert(
collection_name="knowledge_base",
points=points,
wait=True
)
# Query con filtri
def search(
query: str,
category_filter: str | None = None,
limit: int = 5
) -> list[dict]:
query_embedding = embed_text(query)
query_filter = None
if category_filter:
query_filter = Filter(
must=[
FieldCondition(
key="category",
match=MatchValue(value=category_filter)
)
]
)
results = client.query_points(
collection_name="knowledge_base",
query=query_embedding,
query_filter=query_filter,
limit=limit,
with_payload=True
)
return [
{"content": r.payload["content"], "score": r.score, "source": r.payload["source"]}
for r in results.points
]
# Esempio d'uso
docs = [
{"content": "Come configurare l'autenticazione 2FA...", "source": "docs/security.md",
"category": "security", "created_at": "2026-01-15"},
]
index_documents(docs)
results = search("configurazione sicurezza account", category_filter="security")
Praktische opstelling: pgvector
pgvector is de slimme keuze als u PostgreSQL al gebruikt: geen extra infrastructuur, ACID-transacties, JOIN met andere tabellen. Bij HNSW zijn de prestaties vergelijkbaar met de oplossingen speciaal voor weegschalen onder de 5 miljoen dragers.
# pgvector: schema e querying con psycopg2
import psycopg2
from pgvector.psycopg2 import register_vector
import numpy as np
conn = psycopg2.connect("postgresql://user:pass@localhost/dbname")
register_vector(conn)
with conn.cursor() as cur:
# Abilita l'estensione (una tantum)
cur.execute("CREATE EXTENSION IF NOT EXISTS vector")
# Crea la tabella con embedding
cur.execute("""
CREATE TABLE IF NOT EXISTS documents (
id BIGSERIAL PRIMARY KEY,
content TEXT NOT NULL,
source VARCHAR(500),
category VARCHAR(100),
embedding vector(1536), -- dimensione OpenAI
created_at TIMESTAMP DEFAULT NOW()
)
""")
# Crea indice HNSW (migliore performance di IVFFlat)
cur.execute("""
CREATE INDEX IF NOT EXISTS documents_embedding_hnsw_idx
ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 200)
""")
conn.commit()
# Inserimento
def insert_document(content: str, source: str, category: str, embedding: list[float]):
with conn.cursor() as cur:
cur.execute(
"INSERT INTO documents (content, source, category, embedding) VALUES (%s, %s, %s, %s)",
(content, source, category, np.array(embedding))
)
conn.commit()
# Query similarity search con filtro
def search_documents(query_embedding: list[float], category: str = None, limit: int = 5):
with conn.cursor() as cur:
if category:
cur.execute("""
SELECT content, source, 1 - (embedding <=> %s) AS similarity
FROM documents
WHERE category = %s
ORDER BY embedding <=> %s
LIMIT %s
""", (np.array(query_embedding), category, np.array(query_embedding), limit))
else:
cur.execute("""
SELECT content, source, 1 - (embedding <=> %s) AS similarity
FROM documents
ORDER BY embedding <=> %s
LIMIT %s
""", (np.array(query_embedding), np.array(query_embedding), limit))
return cur.fetchall()
# Restituisce: [(content, source, similarity_score), ...]
Beslissingsmatrix: welke te kiezen
Caso d'uso | Raccomandazione | Motivo
------------------------------------|------------------------|----------------------------------
Gia uso PostgreSQL, <1M vettori | pgvector | Zero infra, JOIN nativi, ACID
Startup, MVP rapido | Pinecone Serverless | Zero ops, pay-per-use
Team tecnico, >1M vettori | Qdrant self-hosted | Best performance/cost
Hybrid search nativo necessario | Weaviate | BM25+vector integrato
>100M vettori, cluster distribuito | Milvus | Scalabilita orizzontale
Compliance (dati on-premise) | Qdrant/Milvus | Full control, nessun cloud
Veel voorkomende fouten bij de selectie
- Kies pgvector met IVFFlat op datasets > 500K vectoren: latentie degradeert aanzienlijk. Gebruik HNSW (beschikbaar sinds PostgreSQL 16) of migreer naar een oplossing toegewijd
- Overschatting van de omvang van inbedding: tekst-embedding-3-klein a 1536 afmetingen heeft bijna identieke prestaties als text-embedding-3-large bij 3072 afmetingen maar het kost de helft en gebruikt de helft RAM
- Negeer ef_search tijdens de query: verhoog ef_search van 100 naar 200 inch Qdrant/Weaviate verbetert de herinnering met 95% tot 99% met slechts 1,3x latentie-overhead
- Alleen formaat voor het initiële volume: Plan eerst de migratie om de limiet van uw huidige keuze te bereiken
Kritieke HNSW-parameters
De HNSW-index (Hierarchical Navigable Small World) vormt het hart van vectorprestaties databases. Als u de parameters ervan begrijpt, kunt u de afweging tussen terugroepen en latentie optimaliseren:
Parametro | Effetto sull'indice | Effetto sulla query
----------------|----------------------|--------------------
m (16-64) | Connessioni per nodo | Recall (piu alto = meglio)
| piu alto = piu RAM | Latency (marginale impatto)
| piu alto = build piu |
| lento |
| |
ef_construction | Qualita build | Nessun effetto diretto
(100-500) | piu alto = recall | (determina qualita indice)
| migliore |
| piu alto = build piu |
| lento |
| |
ef_search | Nessun effetto | Recall (molto impatto)
(50-500) | sull'indice | Latency (tradeoff principale)
Configurazione raccomandata per produzione:
- m = 16 (bilanciato), m = 32 (alta accuratezza, +50% RAM)
- ef_construct = 200 (build lenta, alta qualita indice)
- ef_search = 100-200 (aumenta a query time senza ricostruire)
Conclusies
De vuistregel voor 2026: onder 1M-vectoren is pgvector met HNSW vaak de keuze juist als u al PostgreSQL gebruikt: geen extra infrastructuur en prestaties competitief. Tussen 1 miljoen en 50 miljoen providers biedt Qdrant zelfgehost de beste prestatie-/kostenverhouding. Meer dan 100 miljoen providers, Milvus met gedistribueerde inzet en de standaardkeuze.
Het volgende artikel gaat dieper in op RAG-architecturen – van naïeve RAG tot modulaire RAG – met code compleet en patroon om de meest complexe gebruiksscenario's aan te kunnen.