Przejdź do głównej treści
Polski— Wybierz język
Menu

Bazy danych wektorowych (Pinecone, Qdrant, Weaviate)

Lekcja 8 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Dlaczego baza danych wektorowych?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma i pgvector
  7. Porównanie
  8. Kluczowe wnioski

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

KryteriumPineconeQdrantWeaviateChromapgvector
TypZarządzanyOpen sourceOpen sourceOpen sourceRozszerzenie
HostingChmuraSelf-hosted/ChmuraSelf-hosted/ChmuraLokalny/EmbedPostgreSQL
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