Salt la conținutul principal
Română— Alege o limbă
Meniu

Baze de date vectoriale (Pinecone, Qdrant, Weaviate)

Lecția 8 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. De ce o bază de date vectorială?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma și pgvector
  7. Comparație
  8. Puncte cheie

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

CriteriuPineconeQdrantWeaviateChromapgvector
TipGestionatOpen sourceOpen sourceOpen sourceExtensie
GăzduireCloudSelf-hosted/CloudSelf-hosted/CloudLocal/EmbedPostgreSQL
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ă