Vector databases (Pinecone, Qdrant, Weaviate)
Op deze pagina
Doelstellingen
- Begrijpen waarom vectordatabases noodzakelijk zijn
- Pinecone, Qdrant, Weaviate, Chroma en pgvector vergelijken
- Zoekopdrachten implementeren met elk van deze systemen
Waarom een vectordatabase?
De NumPy-index uit de vorige les werkt perfect voor een paar duizend documenten, omdat een exhaustieve scan van tienduizend vectoren onmerkbaar blijft. Bij één miljoen wordt diezelfde berekening echter een seconde latentie per query, en past de matrix niet meer comfortabel in het geheugen.
Er doen zich vier behoeften tegelijk voor. ANN-zoekopdrachten (Approximate Nearest Neighbors) laten de garantie op een exact resultaat varen ten gunste van een respons in milliseconden op miljoenen vectoren; een compromis dat bijna altijd aanvaardbaar is, aangezien het teruggeven van het op vier na beste document in plaats van het op drie na beste niets verandert aan de gebruikerservaring. Metadatfiltering in combinatie met vectorzoekopdrachten stelt u in staat een query te beperken tot een categorie, taal of datumbereik zonder nabewerking. Persistentie en realtime-updates voorkomen dat u een heel bestand opnieuw moet opbouwen om slechts één document toe te voegen. Tot slot is horizontale schaling wat een prototype onderscheidt van een productiedienst.
Pinecone
Pinecone is een beheerde dienst: u hoeft geen servers in te richten, u maakt een index aan door de dimensie en metriek op te geven, en de rest wordt voor u afgehandeld. Merk op dat het filter categorie direct wordt doorgegeven aan query; vectorzoekopdrachten en filtering worden samen uitgevoerd, niet na elkaar.
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']}")
De bij het aanmaken gedeclareerde dimensie is definitief: overstappen van text-embedding-3-large naar text-embedding-3-small vereist het opnieuw aanmaken van de index. Beslis dus vooraf over het model, niet achteraf.
Qdrant
Qdrant is open source, self-hosted en biedt uitstekende prestaties. De terminologie verschilt: we spreken over collecties, punten en payloads waar Pinecone het heeft over indexen, vectoren en metadata, maar het schema blijft identiek. Merk op dat het voorbeeld de embedding-API document voor document aanroept binnen de lus: dit is aanvaardbaar voor drie documenten, maar denk eraan om terug te schakelen naar batches zodra het corpus groeit.
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
Weaviate onderscheidt zich door zijn native hybride zoekfunctie, waarop we in les 9 terugkomen. Het datamodel is gestructureerder dan dat van zijn concurrenten: u declareert expliciet eigenschappen en hun typen voordat u iets invoegt, wat de ervaring dichter bij die van een klassieke database brengt.
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 en pgvector
Chroma richt zich op prototyping: een persistente client die naar een lokale map wijst, een collectie die on-the-fly wordt aangemaakt, geen infrastructuur. Dit is de optie die u van een NumPy-index naar een echte database brengt zonder uw werkomgeving te wijzigen.
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)
pgvector adresseert een heel andere situatie: uw documenten staan al in PostgreSQL, met hun joins, toegangsrechten en back-ups. In plaats van een tweede systeem te introduceren dat gesynchroniseerd moet worden, voegt de extensie een vector-type en afstandoperators toe aan de bestaande database. De operator <=> berekent de cosinusafstand, en de HNSW-index is wat de query bruikbaar maakt voor meer dan een paar duizend rijen.
-- 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;
Vergelijking
| Criterium | Pinecone | Qdrant | Weaviate | Chroma | pgvector |
|---|---|---|---|---|---|
| Type | Beheerd | Open source | Open source | Open source | Extensie |
| Hosting | Cloud | Self-hosted/Cloud | Self-hosted/Cloud | Lokaal/Embed | PostgreSQL |
| Hybride zoeken | ✅ | ✅ | ✅ Native | ❌ | Via SQL |
| Productie | ✅ | ✅ | ✅ | ⚠️ Prototyping | ✅ |
| Gebruiksgemak | ✅✅ | ✅ | ✅ | ✅✅ | ✅ |
De keuze hangt minder af van de ruwe prestaties, die in de praktijk zeer dicht bij elkaar liggen, dan van uw context: een team dat al PostgreSQL draait, heeft er alle belang bij daarbij te blijven, een team zonder ops-kennis kiest voor een beheerde oplossing, en een team dat om regelgevende redenen in Europa moet hosten, zal kiezen voor self-hosting.
Belangrijkste punten
- Chroma voor snel prototyping
- pgvector als u al PostgreSQL heeft
- Pinecone voor een beheerde oplossing zonder infrastructuur
- Qdrant voor high-performance self-hosting
- Weaviate voor native hybride zoekopdrachten