Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

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

Lekce 8 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Proč vektorová databáze?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma a pgvector
  7. Srovnání
  8. Klíčové poznatky

Cíle

  • Pochopit, proč jsou vektorové databáze nezbytné
  • Porovnat Pinecone, Qdrant, Weaviate, Chroma a pgvector
  • Implementovat vyhledávání s každou z nich

Proč vektorová databáze?

Index NumPy z předchozí lekce funguje perfektně pro několik tisíc dokumentů, protože vyčerpávající prohledání deseti tisíc vektorů zůstane nepostřehnutelné. Při jednom milionu se stejný výpočet změní na sekundu latence na dotaz a matrice se již pohodlně nevejde do paměti.

Vyvstanou čtyři potřeby najednou. ANN search (Approximate Nearest Neighbors) se vzdává záruky přesného výsledku ve prospěch odezvy v řádu milisekund u milionů vektorů – kompromis, který je téměř vždy přijatelný, protože vrácení pátého nejlepšího dokumentu místo čtvrtého nic nemění na uživatelské zkušenosti. Filtrování metadat v kombinaci s vektorovým vyhledáváním ti umožní omezit dotaz na kategorii, jazyk nebo časové rozmezí bez nutnosti dodatečného zpracování. Perzistence a aktualizace v reálném čase zabrání přestavbě celého souboru jen kvůli přidání jednoho dokumentu. Nakonec horizontální škálování je tím, co odlišuje prototyp od produkční služby.

Pinecone

Pinecone je spravovaná služba: neprovozuj žádné servery, vytvoříš index zadáním jeho dimenze a metriky a o zbytek se postará systém za tebe. Všimni si filtru categorie předaného přímo do query – vektorové vyhledávání a filtrování se provádějí společně, nikoliv jedno po druhém.

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

Dimenze deklarovaná při vytvoření je konečná: přechod z text-embedding-3-large na text-embedding-3-small vyžaduje znovuvytvoření indexu. Rozhodni se tedy pro model předem, nikoliv až poté.

Qdrant

Qdrant je open source, hostuješ si ho sám a nabízí vynikající výkon. Slovník se liší – mluvíme o kolekcích, bodech a datových užitečných载荷 (payloads), zatímco Pinecone používá indexy, vektory a metadata – ale schéma zůstává totožné. Všimni si, že příklad volá API pro embedding dokument po dokumentu uvnitř smyčky: to je přijatelné pro tři dokumenty, ale jakmile corpus poroste, mysli na návrat k dávkovému zpracování.

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á svým nativním hybridním vyhledáváním, ke kterému se vrátíme v lekci 9. Jeho datový model je strukturovanější než u konkurence: před vložením čehokoliv explicitně deklaruješ vlastnosti a jejich typy, což přibližuje zkušenost práci s klasickou databází.

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 cílí na prototypování: perzistentní klient ukazující na lokální složku, kolekce vytvořená za běhu, žádná infrastruktura. Je to volba, která tě dostane od indexu NumPy ke skutečné databázi bez změny tvého pracovního prostředí.

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 řeší zcela odlišnou situaci: tvé dokumenty již jsou v PostgreSQL, včetně jejich joinů, přístupových práv a záloh. Místo zavádění druhého systému, který by bylo třeba synchronizovat, rozšíření přidá do stávající databáze typ vector a operátory vzdálenosti. Operátor <=> počítá kosinovou vzdálenost a index HNSW je tím, co činí dotaz použitelným i pro více než několik tisíc řádků.

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

Srovnání

KritériumPineconeQdrantWeaviateChromapgvector
TypSpravovanýOpen sourceOpen sourceOpen sourceRozšíření
HostingCloudVlastní hosting/CloudVlastní hosting/CloudLokální/VnořenýPostgreSQL
Hybridní vyhledávání✅✅✅ Nativní❌Přes SQL
Produkce✅✅✅⚠️ Prototypování✅
Snadnost použití✅✅✅✅✅✅✅

Volba závisí méně na hrubém výkonu, který je v praxi velmi podobný, než na tvém kontextu: tým, který již provozuje PostgreSQL, má všechen zájem v něm setrvat; tým bez ops zvolí spravované řešení a tým, který musí z regulačních důvodů hostit v Evropě, se obrátí na vlastní hosting.

Klíčové poznatky

  • Chroma pro rychlé prototypování
  • pgvector, pokud již máš PostgreSQL
  • Pinecone pro spravované řešení bez infrastruktury
  • Qdrant pro vysoce výkonný vlastní hosting
  • Weaviate pro nativní hybridní vyhledávání