Vektordatabaser (Pinecone, Qdrant, Weaviate)
På denne side
Mål
- Forstå hvorfor vektordatabaser er nødvendige
- Sammenligne Pinecone, Qdrant, Weaviate, Chroma og pgvector
- Implementere søgning med hver af dem
Hvorfor en vektordatabase?
NumPy-indekset fra den forrige lektion fungerer perfekt til nogle få tusinde dokumenter, fordi en udtømmende scanning af ti tusinde vektorer forbliver umærkelig. Ved en million bliver samme beregning til et sekunds ventetid pr. forespørgsel, og matricen passer ikke længere komfortabelt i hukommelsen.
Fire behov opstår samtidigt. ANN-søgning (Approximate Nearest Neighbors) opgiver garantien for et nøjagtigt resultat til fordel for et millisekund-hurtigt svar på millioner af vektorer – et kompromis, der næsten altid er acceptabelt, da det at returnere det femtebedste dokument i stedet for det fjerde ikke ændrer noget for brugeroplevelsen. Metadata-filtrering kombineret med vektorsøgning giver dig mulighed for at begrænse en forespørgsel til en kategori, et sprog eller en datoperiode uden efterbehandling. Persistens og opdateringer i realtid undgår at skulle genopbygge en hel fil blot for at tilføje et dokument. Endelig er horisontal skalering det, der adskiller en prototype fra en produktionstjeneste.
Pinecone
Pinecone er en administreret tjeneste: du klargør ingen servere, du opretter et indeks ved at angive dets dimension og metrik, og resten håndteres for dig. Bemærk filteret categorie, der sendes direkte til query – vektorsøgning og filtrering udføres sammen, ikke den ene efter den anden.
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']}")
Den dimension, der erklæres ved oprettelse, er endelig: skift fra text-embedding-3-large til text-embedding-3-small kræver genoprettelse af indekset. Så beslut dig for modellen før, ikke efter.
Qdrant
Qdrant er open source, selvhostet og tilbyder fremragende ydeevne. Ordforrådet er anderledes – vi taler om samlinger, punkter og payloads, hvor Pinecone taler om indeks, vektorer og metadata – men skemaet forbliver identisk. Bemærk, at eksemplet kalder embedding-API’en dokument for dokument inde i løkken: dette er acceptabelt for tre dokumenter, men husk at skifte tilbage til batches, så snart korpussen vokser.
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 skiller sig ud med sin native hybride søgning, som vi vender tilbage til i lektion 9. Dens datamodel er mere struktureret end konkurrenternes: du erklærer eksplicit egenskaber og deres typer, før du indsætter noget, hvilket bringer oplevelsen tættere på en klassisk database.
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 og pgvector
Chroma sigter mod prototyping: en persistent klient pegende på en lokal mappe, en samling oprettet på farten, ingen infrastruktur. Dette er den mulighed, der tager dig fra et NumPy-indeks til en rigtig database uden at ændre dit arbejdsmiljø.
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 adresserer en helt anden situation: dine dokumenter er allerede i PostgreSQL med deres joins, adgangsrettigheder og sikkerhedskopier. I stedet for at introducere et andet system, der skal synkroniseres, tilføjer udvidelsen en vector-type og afstandoperatorer til den eksisterende database. Operatoren <=> beregner cosinusafstand, og HNSW-indekset er det, der gør forespørgslen brugbar ud over nogle få tusinde rækker.
-- 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;
Sammenligning
| Kriterium | Pinecone | Qdrant | Weaviate | Chroma | pgvector |
|---|---|---|---|---|---|
| Type | Administreret | Open source | Open source | Open source | Udvidelse |
| Hosting | Cloud | Selvhostet/Cloud | Selvhostet/Cloud | Lokal/Embed | PostgreSQL |
| Hybrid søgning | ✅ | ✅ | ✅ Native | ❌ | Via SQL |
| Produktion | ✅ | ✅ | ✅ | ⚠️ Prototyping | ✅ |
| Brugervenlighed | ✅✅ | ✅ | ✅ | ✅✅ | ✅ |
Valget afhænger mindre af rå ydeevne, som i praksis er meget tæt, end af din kontekst: et team, der allerede kører PostgreSQL, har al interesse i at blive ved det, et team uden ops vil vælge administreret, og et team, der skal hoste i Europa af regulatoriske årsager, vil vende sig mod selvhostede løsninger.
Vigtige pointer
- Chroma til hurtig prototyping
- pgvector hvis du allerede har PostgreSQL
- Pinecone til administreret løsning uden infrastruktur
- Qdrant til højtydende selvhosting
- Weaviate til native hybrid søgning