Bazy danych wektorowych (Pinecone, Qdrant, Weaviate)
Na tej stronie
Cele
- Zrozumienie, dlaczego bazy danych wektorowych są niezbędne
- Porównanie Pinecone, Qdrant, Weaviate, Chroma i pgvector
- Implementacja wyszukiwania z wykorzystaniem każdego z nich
Dlaczego baza danych wektorowych?
Indeks NumPy z poprzedniej lekcji działa doskonale dla kilku tysięcy dokumentów, ponieważ wyczerpujące przeszukanie dziesięciu tysięcy wektorów pozostaje niezauważalne. Przy milionie rekordów to samo obliczenie generuje sekundę opóźnienia na zapytanie, a macierz przestaje wygodnie mieścić się w pamięci.
Pojawiają się cztery kluczowe potrzeby. Wyszukiwanie ANN (Approximate Nearest Neighbors) rezygnuje z gwarancji wyniku dokładnego na rzecz odpowiedzi w milisekundach dla milionów wektorów – jest to kompromis prawie zawsze akceptowalny, ponieważ zwrócenie piątego najlepszego dokumentu zamiast czwartego nic nie zmienia w doświadczeniu użytkownika. Filtrowanie metadanych połączone z wyszukiwaniem wektorowym pozwala ograniczyć zapytanie do kategorii, języka lub zakresu dat bez konieczności post-processingu. Trwałość i aktualizacje w czasie rzeczywistym pozwalają uniknąć przebudowywania całego pliku tylko po to, by dodać jeden dokument. Wreszcie, poziome skalowanie to cecha odróżniająca prototyp od usługi produkcyjnej.
Pinecone
Pinecone to usługa zarządzana: nie uruchamiasz żadnych serwerów, tworzysz indeks, określając jego wymiar i metrykę, a resztą zajmuje się dostawca. Zwróć uwagę na filtr categorie przekazany bezpośrednio do metody query – wyszukiwanie wektorowe i filtrowanie wykonują się razem, a nie jedno po drugim.
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']}")
Wymiar zadeklarowany podczas tworzenia jest ostateczny: przejście z text-embedding-3-large na text-embedding-3-small wymaga recreation indeksu. Dlatego zdecyduj o modelu przed, a nie po.
Qdrant
Qdrant jest open source, hostowany samodzielnie i oferuje doskonałą wydajność. Słownictwo jest inne – mówimy o kolekcjach, punktach i ładunkach (payloads), tam gdzie Pinecone używa terminów indeksy, wektory i metadane – ale schemat pozostaje identyczny. Zauważ, że przykład wywołuje API embeddingów dokument po dokumencie wewnątrz pętli: jest to akceptowalne dla trzech dokumentów, ale pomyśl o powrocie do wsadów (batches), gdy tylko korpus urośnie.
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 wyróżnia się natywnym wyszukiwaniem hybrydowym, do którego wrócimy w lekcji 9. Jego model danych jest bardziej ustrukturyzowany niż u konkurencji: przed wstawieniem czegokolwiek jawnie deklarujesz właściwości i ich typy, co zbliża doświadczenie do pracy z klasyczną bazą danych.
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 celuje w szybkie prototypowanie: trwały klient wskazujący na lokalny folder, kolekcja tworzona w locie, brak infrastruktury. To opcja, która przenosi Cię z indeksu NumPy do prawdziwej bazy danych bez zmiany środowiska pracy.
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 rozwiązuje zupełnie inną sytuację: Twoje dokumenty znajdują się już w PostgreSQL, wraz z ich relacjami (joins), uprawnieniami dostępu i kopiami zapasowymi. Zamiast wprowadzać drugi system do synchronizacji, rozszerzenie dodaje typ vector i operatory odległości do istniejącej bazy danych. Operator <=> oblicza odległość kosinusową, a indeks HNSW sprawia, że zapytanie jest wykonalne poza skalą kilku tysięcy wierszy.
-- 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;
Porównanie
| Kryterium | Pinecone | Qdrant | Weaviate | Chroma | pgvector |
|---|---|---|---|---|---|
| Typ | Zarządzany | Open source | Open source | Open source | Rozszerzenie |
| Hosting | Chmura | Self-hosted/Chmura | Self-hosted/Chmura | Lokalny/Embed | PostgreSQL |
| Wyszukiwanie hybrydowe | ✅ | ✅ | ✅ Natywne | ❌ | Przez SQL |
| Produkcja | ✅ | ✅ | ✅ | ⚠️ Prototypowanie | ✅ |
| Łatwość użycia | ✅✅ | ✅ | ✅ | ✅✅ | ✅ |
Wybór zależy mniej od surowej wydajności, która w praktyce jest bardzo zbliżona, a bardziej od Twojego kontekstu: zespół, który już korzysta z PostgreSQL, powinien w nim pozostać; zespół bez działu operacyjnego (ops) wybierze rozwiązanie zarządzane, a zespół, który musi hostować dane w Europie ze względów regulacyjnych, zwróci się ku rozwiązaniom self-hosted.
Kluczowe wnioski
- Chroma do szybkiego prototypowania
- pgvector, jeśli już używasz PostgreSQL
- Pinecone dla rozwiązań zarządzanych, bez infrastruktury
- Qdrant dla wydajnego hostingu własnego (self-hosted)
- Weaviate dla natywnego wyszukiwania hybrydowego