Vektoradatbázisok (Pinecone, Qdrant, Weaviate)
Ezen az oldalon
Célok
- Megérteni, miért van szükség vektoradatbázisokra
- Összehasonlítani a Pinecone, Qdrant, Weaviate, Chroma és pgvector megoldásokat
- Keresést implementálni mindegyikkel
Miért van szükség vektoradatbázisra?
Az előző leckében használt NumPy-index néhány ezer dokumentumig tökéletesen működik, mert tízezer vektor kimerítő vizsgálata észrevehetetlen marad. Egymillió vektornál azonban ugyanez a számítás lekérdezésenként egy másodperc késleltetést okoz, és a mátrix már nem fér kényelmesen a memóriába.
Négy igény merül fel egyszerre. Az ANN keresés (Approximate Nearest Neighbors – közelítő legközelebbi szomszédok) feladja a pontos találat garanciáját a milliszekundumos válaszidő érdekében milliónyi vektoron – ez a kompromisszum szinte mindig elfogadható, hiszen a felhasználói élmény szempontjából mindegy, hogy a negyedik helyett az ötödik legjobb dokumentumot kapja vissza a rendszer. A vektorkereséssel kombinált metaadat-szűrés lehetővé teszi, hogy utófeldolgozás nélkül korlátozd a lekérdezést egy adott kategóriára, nyelvre vagy dátumtartományra. A tartósság és a valós idejű frissítések elkerülik, hogy egyetlen dokumentum hozzáadásához újra kelljen építeni egy teljes fájlt. Végül a vízszintes méretezhetőség az, ami megkülönbözteti a prototípust az éles szolgáltatástól.
Pinecone
A Pinecone menedzselt szolgáltatás: nem kell szervereket üzemeltetned, csupán létrehozol egy indexet a dimenzió és a metrika megadásával, a többit pedig a rendszer intézi. Figyeld meg a query hívásnak átadott categorie szűrőt: a vektorkeresés és a szűrés egyszerre fut le, nem egymás után.
from pinecone import Pinecone
from openai import OpenAI
pc = Pinecone(api_key="your-pinecone-key")
openai_client = OpenAI()
# Create an index
pc.create_index(
name="my-corpus",
dimension=3072,
metric="cosine",
spec={"serverless": {"cloud": "aws", "region": "eu-west-1"}}
)
index = pc.Index("my-corpus")
# Index documents
documents = [
{"id": "doc1", "texte": "Python Installation Guide",
"categorie": "tutorial"},
{"id": "doc2", "texte": "Deploying a Flask Application",
"categorie": "tutorial"},
{"id": "doc3", "texte": "Q1 2026 Quarterly Report",
"categorie": "report"},
]
# Generate embeddings
textes = [d["texte"] for d in documents]
response = openai_client.embeddings.create(
input=textes,
model="text-embedding-3-large"
)
# Upsert into Pinecone
vecteurs = [
{
"id": doc["id"],
"values": emb.embedding,
"metadata": {"texte": doc["texte"], "categorie": doc["categorie"]}
}
for doc, emb in zip(documents, response.data)
]
index.upsert(vectors=vecteurs)
# Search
query_emb = openai_client.embeddings.create(
input="how to install Python",
model="text-embedding-3-large"
).data[0].embedding
resultats = index.query(
vector=query_emb,
top_k=3,
include_metadata=True,
filter={"categorie": {"$eq": "tutorial"}}
)
for match in resultats.matches:
print(f"[{match.score:.3f}] {match.metadata['texte']}")
A létrehozáskor megadott dimenzió végleges: a text-embedding-3-large modellről a text-embedding-3-small modellre való váltáshoz újra kell létrehozni az indexet. Ezért a modellt előre válaszd ki, ne utólag.
Qdrant
A Qdrant nyílt forráskódú, saját hosztolású megoldás, kiváló teljesítménnyel. A szókincs eltér – kollekciókról, pontokról és hasznos adatokról (payload) beszélünk, míg a Pinecone indexekről, vektorokról és metaadatokról –, de a séma ugyanaz marad. Vegyük észre, hogy a példa dokumentumonként hívja meg a beágyazási API-t a cikluson belül: ez három dokumentum esetén elfogadható, de ahogy a korpusz növekszik, gondolkodj el a köteges (batch) műveletekre való visszatérésen.
from qdrant_client import QdrantClient
from qdrant_client.models import (
Distance, VectorParams, PointStruct, Filter,
FieldCondition, MatchValue
)
from openai import OpenAI
qclient = QdrantClient(url="http://localhost:6333")
openai_client = OpenAI()
# Create a collection
qclient.create_collection(
collection_name="my-corpus",
vectors_config=VectorParams(
size=3072,
distance=Distance.COSINE
)
)
# Index documents
points = []
for i, doc in enumerate(documents):
emb = openai_client.embeddings.create(
input=doc["texte"],
model="text-embedding-3-large"
).data[0].embedding
points.append(PointStruct(
id=i,
vector=emb,
payload={"texte": doc["texte"], "categorie": doc["categorie"]}
))
qclient.upsert(collection_name="my-corpus", points=points)
# Search with filter
query_emb = openai_client.embeddings.create(
input="deploy a web application",
model="text-embedding-3-large"
).data[0].embedding
resultats = qclient.search(
collection_name="my-corpus",
query_vector=query_emb,
limit=3,
query_filter=Filter(
must=[FieldCondition(
key="categorie",
match=MatchValue(value="tutorial")
)]
)
)
for r in resultats:
print(f"[{r.score:.3f}] {r.payload['texte']}")
Weaviate
A Weaviate a natív hibrid kereséssel tűnik ki, amire a 9. leckében még visszatérünk. Az adatmodellje strukturáltabb, mint versenytársaié: mielőtt bármit beszúrnál, expliciten deklarálnod kell a tulajdonságokat és típusaikat, ami közelebb hozza a használatát egy klasszikus adatbázis élményéhez.
import weaviate
from openai import OpenAI
wclient = weaviate.connect_to_local()
openai_client = OpenAI()
# Create a collection
from weaviate.classes.config import Property, DataType
collection = wclient.collections.create(
name="Document",
properties=[
Property(name="texte", data_type=DataType.TEXT),
Property(name="categorie", data_type=DataType.TEXT),
]
)
# Index
for doc in documents:
emb = openai_client.embeddings.create(
input=doc["texte"],
model="text-embedding-3-large"
).data[0].embedding
collection.data.insert(
properties={"texte": doc["texte"], "categorie": doc["categorie"]},
vector=emb
)
# Search
query_emb = openai_client.embeddings.create(
input="install Python",
model="text-embedding-3-large"
).data[0].embedding
resultats = collection.query.near_vector(
near_vector=query_emb,
limit=3
)
Chroma és pgvector
A Chroma a gyors prototípuskészítést célozza meg: egy tartós kliens, amely egy helyi mappára mutat, egy menet közben létrehozott kollekció, és nincs szükség infrastruktúrára. Ez az a lehetőség, amellyel NumPy-indexről valódi adatbázisra válthatsz anélkül, hogy megváltoztatnád a munkakörnyezetedet.
import chromadb
from openai import OpenAI
chroma = chromadb.PersistentClient(path="./chroma_db")
openai_client = OpenAI()
collection = chroma.get_or_create_collection("my-corpus")
# Index
for doc in documents:
emb = openai_client.embeddings.create(
input=doc["texte"],
model="text-embedding-3-large"
).data[0].embedding
collection.add(
ids=[doc["id"]],
embeddings=[emb],
documents=[doc["texte"]],
metadatas=[{"categorie": doc["categorie"]}]
)
# Search
query_emb = openai_client.embeddings.create(
input="how to install Python",
model="text-embedding-3-large"
).data[0].embedding
resultats = collection.query(query_embeddings=[query_emb], n_results=3)
A pgvector egy teljesen más helyzetet kezel: a dokumentumaid már PostgreSQL-ben vannak, a saját joinjaikkal, hozzáférési jogaikkal és biztonsági mentéseikkel. Ahelyett, hogy egy második rendszert vezetnél be a szinkronizáláshoz, a kiegészítés hozzáad egy vector típust és távolságoperátorokat a meglévő adatbázishoz. A <=> operátor kiszámítja a koszinusztávolságot, a HNSW-index pedig azt biztosítja, hogy a lekérdezés néhány ezer sornál is használható maradjon.
-- pgvector extension
CREATE EXTENSION vector;
CREATE TABLE documents (
id SERIAL PRIMARY KEY,
texte TEXT,
categorie TEXT,
embedding vector(3072)
);
-- HNSW index for performance
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);
-- Search for the 5 nearest neighbors
SELECT id, texte, 1 - (embedding <=> $1::vector) AS score
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT 5;
Összehasonlítás
| Kritérium | Pinecone | Qdrant | Weaviate | Chroma | pgvector |
|---|---|---|---|---|---|
| Típus | Menedzselt | Nyílt forráskódú | Nyílt forráskódú | Nyílt forráskódú | Kiegészítés |
| Hosztolás | Felhő | Saját hosztolás/Felhő | Saját hosztolás/Felhő | Helyi/Beágyazott | PostgreSQL |
| Hibrid keresés | ✅ | ✅ | ✅ Natív | ❌ | SQL-en keresztül |
| Éles környezet | ✅ | ✅ | ✅ | ⚠️ Prototípus | ✅ |
| Használhatóság | ✅✅ | ✅ | ✅ | ✅✅ | ✅ |
A választás kevésbé függ a nyers teljesítménytől, amely a gyakorlatban nagyon közel van egymáshoz, mint a kontextustól: egy csapatnak, amely már PostgreSQL-t használ, mindenképpen érdemes ennél maradnia; egy csapat, amelynek nincs DevOps erőforrása, a menedzselt megoldást választja; míg egy csapatnak, amelynek szabályozási okokból Európában kell hosztolnia, a saját hosztolású megoldás felé kell fordulnia.
Főbb megállapítások
- Chroma a gyors prototípuskészítéshez
- pgvector, ha már van PostgreSQL-ed
- Pinecone menedzselt, infrastruktúra-mentes megoldáshoz
- Qdrant nagy teljesítményű saját hosztoláshoz
- Weaviate natív hibrid kereséshez