Baze de date vectoriale (Pinecone, Qdrant, Weaviate)
Pe această pagină
Obiective
- Să înțelegeți de ce sunt necesare bazele de date vectoriale
- Să comparați Pinecone, Qdrant, Weaviate, Chroma și pgvector
- Să implementați căutarea cu fiecare dintre ele
De ce o bază de date vectorială?
Indexul NumPy din lecția anterioară funcționează perfect pentru câteva mii de documente, deoarece o scanare exhaustivă a zece mii de vectori rămâne imperceptibilă. La un milion, același calcul devine o secundă de latență per interogare, iar matricea nu mai încapă confortabil în memorie.
Patru nevoi emerg simultan. Căutarea ANN (Approximate Nearest Neighbors) renunță la garanția unui rezultat exact în favoarea unui răspuns în milisecunde pentru milioane de vectori—un compromis aproape întotdeauna acceptabil, deoarece returnarea celui de-al cincilea cel mai bun document în loc de al patrulea nu schimbă nimic pentru experiența utilizatorului. Filtrarea pe metadate combinată cu căutarea vectorială vă permite să restricționați o interogare la o categorie, limbă sau interval de date fără post-procesare. Persistența și actualizările în timp real evită reconstruirea unui întreg fișier doar pentru a adăuga un document. În final, scalarea orizontală este ceea ce distinge un prototip de un serviciu de producție.
Pinecone
Pinecone este un serviciu gestionat: nu provisionați servere, creați un index specificând dimensiunea și metrica sa, iar restul este gestionat pentru dumneavoastră. Observați filtrul categorie transmis direct către query—căutarea vectorială și filtrarea se execută împreună, nu una după alta.
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']}")
Dimensiunea declarată la creare este finală: trecerea de la text-embedding-3-large la text-embedding-3-small necesită recrearea indexului. Așadar, decideți modelul înainte, nu după.
Qdrant
Qdrant este open source, găzduit propriu (self-hosted) și oferă performanțe excelente. Vocabularul diferă—vorbim despre colecții, puncte și payload-uri acolo unde Pinecone vorbește despre indici, vectori și metadate—dar schema rămâne identică. Rețineți că exemplul apelează API-ul de embedding document cu document în interiorul buclei: acest lucru este acceptabil pentru trei documente, dar gândiți-vă să reveniți la loturi (batches) imediat ce corpusul crește.
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 se distinge prin căutarea hibridă nativă, pe care o vom revisita în lecția 9. Modelul său de date este mai structurat decât cel al competitorilor: declarați explicit proprietățile și tipurile lor înainte de a insera orice, ceea ce aduce experiența mai aproape de cea a unei baze de date clasice.
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 și pgvector
Chroma vizează prototiparea rapidă: un client persistent indicat către un folder local, o colecție creată din mers, fără infrastructură. Aceasta este opțiunea care vă duce de la un index NumPy la o bază de date reală fără a vă schimba mediul de lucru.
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 abordează o situație foarte diferită: documentele dumneavoastră sunt deja în PostgreSQL, cu join-urile, drepturile de acces și backup-urile lor. În loc să introduceți un al doilea sistem de sincronizat, extensia adaugă un tip vector și operatori de distanță bazei de date existente. Operatorul <=> calculează distanța cosinus, iar indexul HNSW este ceea ce face interogarea utilizabilă dincolo de câteva mii de rânduri.
-- 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;
Comparație
| Criteriu | Pinecone | Qdrant | Weaviate | Chroma | pgvector |
|---|---|---|---|---|---|
| Tip | Gestionat | Open source | Open source | Open source | Extensie |
| Găzduire | Cloud | Self-hosted/Cloud | Self-hosted/Cloud | Local/Embed | PostgreSQL |
| Căutare hibridă | ✅ | ✅ | ✅ Nativ | ❌ | Via SQL |
| Producție | ✅ | ✅ | ✅ | ⚠️ Prototipare | ✅ |
| Ușurință în utilizare | ✅✅ | ✅ | ✅ | ✅✅ | ✅ |
Alegerea depinde mai puțin de performanța brută, care este foarte apropiată în practică, decât de contextul dumneavoastră: o echipă care rulează deja PostgreSQL are tot interesul să rămână cu el, o echipă fără operațiuni (ops) va alege varianta gestionată, iar o echipă care trebuie să găzduiască în Europa din motive de reglementare se va orienta către soluțiile self-hosted.
Puncte cheie
- Chroma pentru prototipare rapidă
- pgvector dacă aveți deja PostgreSQL
- Pinecone pentru soluții gestionate, fără infrastructură
- Qdrant pentru găzduire proprie (self-hosted) de înaltă performanță
- Weaviate pentru căutare hibridă nativă