Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Vektorové databázy (Pinecone, Qdrant, Weaviate)

Lekcia 8 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Prečo vektorová databáza?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma a pgvector
  7. Porovnanie
  8. Kľúčové poznatky

Ciele

  • Pochopiť, prečo sú vektorové databázy nevyhnutné
  • Porovnať Pinecone, Qdrant, Weaviate, Chroma a pgvector
  • Implementovať vyhľadávanie s každou z nich

Prečo vektorová databáza?

Index NumPy z predchádzajúcej lekcie funguje perfektne pre niekoľko tisíc dokumentov, pretože vyčerpávajúce prehľadanie desaťtisíc vektorov zostáva nepostrehnuteľné. Pri jednom milióne sa ten istý výpočet zmení na sekundu latencie na dotaz a matica sa už pohodlne nezmestí do pamäte.

Vynárajú sa štyri potreby naraz. ANN search (Approximate Nearest Neighbors) sa vzdáva záruky presného výsledku v prospech odozvy v milisekundách na miliónoch vektorov – kompromis, ktorý je takmer vždy prijateľný, keďže vrátenie piateho najlepšieho dokumentu namiesto štvrtého nič nemení na používateľskej skúsenosti. Filtrovanie metadát v kombinácii s vektorovým vyhľadávaním vám umožňuje obmedziť dotaz na kategóriu, jazyk alebo časové rozmedzie bez dodatočného spracovania. Perzistencia a aktualizácie v reálnom čase sa vyhýbajú prestavbe celého súboru len kvôli pridaniu dokumentu. Nakoniec, horizontálne škálovanie je tým, čo odlišuje prototyp od produkčnej služby.

Pinecone

Pinecone je spravovaná služba: neprovisionujete žiadne servery, vytvoríte index určením jeho dimenzie a metriky a o zvyšok sa postará služba za vás. Všimnite si filter categorie odovzdaný priamo do query – vektorové vyhľadávanie a filtrovanie sa vykonávajú spoločne, nie jedno po druhom.

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

Dimenzia deklarovaná pri vytvorení je konečná: prechod z text-embedding-3-large na text-embedding-3-small si vyžaduje znovu vytvorenie indexu. Rozhodni sa teda pre model vopred, nie až potom.

Qdrant

Qdrant je open source, self-hosted riešenie s vynikajúcim výkonom. Slovník sa líši – hovoríme o kolekciách, bodoch a payloadoch, zatiaľ čo Pinecone hovorí o indexoch, vektoroch a metadátach – ale schéma zostáva identická. Všimni si, že príklad volá API pre embeddingy dokument po dokumente vo vnútri slučky: to je prijateľné pre tri dokumenty, ale pomysli na návrat k dávkam (batches), akonáhle korpus narastie.

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 vyniká svojím natívnym hybridným vyhľadávaním, ku ktorému sa vrátime v lekcii 9. Jeho dátový model je štruktúrovanejší než u konkurencie: pred vložením čohokoľvek explicitne deklaruješ vlastnosti a ich typy, čo približuje skúsenosť ku klasickej databáze.

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

Chroma cieli na prototypovanie: perzistentný klient smerujúci na lokálny priečinok, kolekcia vytvorená za behu, žiadna infraštruktúra. Toto je možnosť, ktorá ťa dostane od indexu NumPy k skutočnej databáze bez zmeny pracovného prostredia.

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 rieši úplne inú situáciu: tvoje dokumenty sú už v PostgreSQL, spolu so svojimi joinmi, prístupovými právami a zálohami. Namiesto zavádzania druhého systému na synchronizáciu rozšírenie pridáva typ vector a operátory vzdialenosti do existujúcej databázy. Operátor <=> vypočítava kosínusovú vzdialenosť a index HNSW je tým, čo robí dotaz použiteľným aj beyond niekoľkých tisíc riadkov.

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

Porovnanie

KritériumPineconeQdrantWeaviateChromapgvector
TypSpravovanýOpen sourceOpen sourceOpen sourceRozšírenie
HostingCloudSelf-hosted/CloudSelf-hosted/CloudLokálny/EmbedPostgreSQL
Hybridné vyhľadávanie✅✅✅ Natívne❌Cez SQL
Produkcia✅✅✅⚠️ Prototypovanie✅
Jednoduchosť použitia✅✅✅✅✅✅✅

Výber závisí menej od hrubého výkonu, ktorý je v praxi veľmi podobný, a viac od tvojho kontextu: tím, ktorý už prevádzkuje PostgreSQL, má všetok dôvod v ňom zotrvať, tím bez ops zvolí spravované riešenie a tím, ktorý musí z regulačných dôvodov hostiť v Európe, sa obráti na self-hosted riešenie.

Kľúčové poznatky

  • Chroma na rýchle prototypovanie
  • pgvector, ak už máš PostgreSQL
  • Pinecone pre spravované riešenie bez infraštruktúry
  • Qdrant pre vysoko výkonné self-hosting
  • Weaviate pre natívne hybridné vyhľadávanie