Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Baze podatkov vektorjev (Pinecone, Qdrant, Weaviate)

Lekcija 8 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Zakaj baza podatkov vektorjev?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma in pgvector
  7. Primerjava
  8. Ključne ugotovitve

Cilji

  • Razumevanje, zakaj so baze podatkov vektorjev nujne
  • Primerjava rešitev Pinecone, Qdrant, Weaviate, Chroma in pgvector
  • Implementacija iskanja z uporabo vsake od njih

Zakaj baza podatkov vektorjev?

Indeks NumPy iz prejšnje lekcije deluje brezhibno za nekaj tisoč dokumentov, saj celovito pregledovanje desetih tisoč vektorjev ostane neopazno. Pri milijonu vektorjev isti izračun povzroči zamik ene sekunde na poizvedbo, matrika pa se ne prilega več udobno v pomnilnik.

Pojavijo se štiri ključne potrebe. Iskanje ANN (Approximate Nearest Neighbors) opusti zagotovilo točnega rezultata v korist odziva v milisekundah pri milijonih vektorjev – kompromis, ki je skoraj vedno sprejemljiv, saj vračanje petega najboljšega dokumenta namesto četrtega za uporabniško izkušnjo ne spremeni ničesar. Filtriranje metapodatkov v kombinaciji z iskanjem vektorjev vam omogoča omejitev poizvedbe na kategorijo, jezik ali časovno obdobje brez naknadne obdelave. Trajnost in posodobitve v realnem času preprečujejo ponovno gradnjo celotne datoteke zgolj zaradi dodajanja dokumenta. Končno je horizontalno skaliranje tisto, kar loči prototip od storitve za produkcijsko okolje.

Pinecone

Pinecone je upravljana storitev: ne pripravljate strežnikov, ustvarite indeks z določitvijo njegove dimenzije in metrike, ostalo pa je opravljeno namesto vas. Opazite filter categorie, ki je podan neposredno funkciji query – iskanje vektorjev in filtriranje se izvedeta hkrati, ne zaporedno.

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']}")

Dimenzija, določena ob ustvarjanju, je dokončna: prehod z text-embedding-3-large na text-embedding-3-small zahteva ponovno ustvarjanje indeksa. Zato se za model odločite vnaprej, ne naknadno.

Qdrant

Qdrant je odprtokoden, gostite ga lahko sami in ponuja odlične zmogljivosti. Besedišče se razlikuje – govorimo o zbirkah, točkah in vsebinah (payloads), medtem ko Pinecone uporablja izraze indeksi, vektorji in metapodatki – a shema ostaja enaka. Upoštevajte, da primer klice API-ja za vdelave (embeddings) dokument za dokumentom znotraj zanke: to je sprejemljivo za tri dokumente, a pomislite na prehod nazaj na serije (batches), takoj ko korpus zraste.

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 izstopa zaradi svojega izvornega hibridnega iskanja, ki ga bomo ponovno obravnavali v lekciji 9. Njegov podatkovni model je bolj strukturiran od modelov konkurence: pred vstavljanjem česar koli eksplicitno deklarirate lastnosti in njihove tipe, kar izkušnjo približa klasični bazi podatkov.

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 in pgvector

Chroma je namenjen hitremu prototipiranju: trajni odjemalec, usmerjen v lokalno mapo, zbirka, ustvarjena sproti, brez infrastrukture. To je možnost, ki vas popelje od indeksa NumPy do prave baze podatkov brez spreminjanja delovnega okolja.

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 naslavlja povsem drugačen scenarij: vaši dokumenti so že v PostgreSQL, s svojimi spoji, pravicami dostopa in varnostnimi kopijami. Namesto uvajanja drugega sistema za sinhronizacijo razširitev doda tip vector in operatorje razdalje obstoječi bazi podatkov. Operator <=> izračuna kosinusno razdaljo, indeks HNSW pa je tisti, ki omogoča uporabnost poizvedbe tudi pri več kot nekaj tisoč vrsticah.

-- 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;

Primerjava

MeriloPineconeQdrantWeaviateChromapgvector
VrstaUpravljanoOdprtokodnoOdprtokodnoOdprtokodnoRazširitev
GostovanjeOblakSamostojno/OblakSamostojno/OblakLokalno/VdelanoPostgreSQL
Hibridno iskanje✅✅✅ Izvorno❌Prek SQL
Produkcijsko okolje✅✅✅⚠️ Prototipiranje✅
Enostavnost uporabe✅✅✅✅✅✅✅

Izbira je manj odvisna od surovih zmogljivosti, ki so v praksi zelo podobne, in bolj od vašega konteksta: ekipa, ki že uporablja PostgreSQL, ima vse razloge, da ostane pri njem; ekipa brez operativne podpore bo izbrala upravljano rešitev; ekipa, ki mora zaradi regulativnih razlogov gostovati v Evropi, pa se bo obrnila na samostojno gostovanje.

Ključne ugotovitve

  • Chroma za hitro prototipiranje
  • pgvector, če že uporabljate PostgreSQL
  • Pinecone za upravljano rešitev brez infrastrukture
  • Qdrant za zmogljivo samostojno gostovanje
  • Weaviate za izvorno hibridno iskanje