Výběr vektorové databáze: Pinecone, Qdrant, Weaviate, pgvector Porovnání
Výběr špatné vektorové databáze pro váš systém RAG může stát týdny refaktoringu a neplánovaný rozpočet. V roce 2026 se trh zkonsolidoval kolem čtyř hlavních možností, každý s velmi odlišným kompromisním profilem: Borová šiška pro ty, kteří chtějí spravovat služba bez ops, Qdrant pro ty, kteří upřednostňují výkon a vlastní hostování, Weaviate pro ty, kteří potřebují nativní hybridní vyhledávání, např pgvector pro ty, kteří chtějí zůstat ve své stávající databázi PostgreSQL.
Tato příručka vám poskytuje srovnávací údaje, skutečné náklady a výběrová kritéria informované rozhodnutí na základě vaší konkrétní pracovní zátěže.
Co se naučíte
- Srovnávací testy latence a propustnosti pro hlavní vektorové databáze 2026
- Skutečné náklady v různých měřítcích (100 000, 1M, 10M, 100M vektory)
- Rozhodovací matice: která databáze pro který případ použití
- Praktické nastavení s Pythonem pro Qdrant a pgvector
- HNSW indexy: kritické parametry pro optimální výkon
- Když je Milvus tou správnou volbou pro nosiče 100M+
Proč je vektorová databáze důležitější než model
V systému RAG závisí kvalita konečné odezvy 60–70 % na kvalitě vyhledávání, ne z vybrané LLM. GPT-4o se špatným vyhledáváním bude mít horší odezvy než GPT-4o-mini s výborným dohledáváním. Vektorová databáze je srdcem vyhledávání: její latence, její přesnost a jeho škálovatelnost určuje uživatelskou zkušenost vašeho systému.
Benchmark 2026: Skutečná data o standardizovaném hardwaru
Následující benchmarky byly měřeny na datovém souboru 1 milionu vektorů z 1536 dimenzí (vložení OpenAI text-embedding-3-small), s dotazem k=10, na serveru s 8 vCPU a 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 se ukazuje jako lídr v oblasti výkonu / self-hosting. Šiška nabízí garantované SLA jako řízená služba. pgvector s HNSW (zavedený v PostgreSQL 16) se téměř úplně přemostil mezera s vyhrazenými řešeními.
Analýza nákladů v různých měřítcích
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)
Praktické nastavení: Qdrant
Qdrant je nejběžnější volbou pro technické týmy, které chtějí maximální výkon kontrola nad nasazením. Zde je kompletní nastavení:
# 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")
Praktické nastavení: pgvector
pgvector je chytrá volba, když již používáte PostgreSQL: žádná další infrastruktura, ACID transakce, JOIN s ostatními tabulkami. S HNSW je výkon srovnatelný s řešeními určené pro váhy pod 5M nosiče.
# 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), ...]
Rozhodovací matice: Kterou si vybrat
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
Časté chyby při výběru
- Vyberte pgvector s IVFFlat na datových sadách > 500 kB vektorů: latence výrazně degraduje. Použijte HNSW (dostupné od PostgreSQL 16) nebo migrujte na řešení oddaný
- Nadhodnocování velikosti vložení: text-embedding-3-small a Rozměry 1536 mají téměř identický výkon jako vkládání textu-3-velký při rozměrech 3072 ale stojí polovinu a využívá polovinu RAM
- Ignorujte ef_search v době dotazu: zvýšení ef_search ze 100 na 200 palců Qdrant/Weaviate zlepšuje vybavování o 95 % až 99 % s pouze 1,3x režií latence
- Velikost pouze pro počáteční objem: Nejprve naplánujte migraci abyste dosáhli limitu vaší aktuální volby
Kritické parametry HNSW
Index HNSW (Hierarchical Navigable Small World) je srdcem vektorového výkonu databází. Pochopení jeho parametrů vám umožní optimalizovat kompromis mezi odvoláním a latencí:
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)
Závěry
Základní pravidlo pro rok 2026: pod 1M vektory je často volbou pgvector s HNSW správně pokud již používáte PostgreSQL – žádná další infrastruktura a výkon konkurenční. Mezi 1 milionem a 50 miliony operátorů nabízí Qdrant self-hosted nejlepší poměr výkon/cena. Více než 100 milionů nosičů, Milvus s distribuovaným nasazením a standardní volbou.
Další článek se ponoří do RAG architektur – od Naive RAG po Modular RAG – s kódem kompletní a vzor pro zvládnutí nejsložitějších případů použití.