Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Vektoradatbázisok (Pinecone, Qdrant, Weaviate)

8. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Miért van szükség vektoradatbázisra?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma és pgvector
  7. Összehasonlítás
  8. Főbb megállapítások

Célok

  • Megérteni, miért van szükség vektoradatbázisokra
  • Összehasonlítani a Pinecone, Qdrant, Weaviate, Chroma és pgvector megoldásokat
  • Keresést implementálni mindegyikkel

Miért van szükség vektoradatbázisra?

Az előző leckében használt NumPy-index néhány ezer dokumentumig tökéletesen működik, mert tízezer vektor kimerítő vizsgálata észrevehetetlen marad. Egymillió vektornál azonban ugyanez a számítás lekérdezésenként egy másodperc késleltetést okoz, és a mátrix már nem fér kényelmesen a memóriába.

Négy igény merül fel egyszerre. Az ANN keresés (Approximate Nearest Neighbors – közelítő legközelebbi szomszédok) feladja a pontos találat garanciáját a milliszekundumos válaszidő érdekében milliónyi vektoron – ez a kompromisszum szinte mindig elfogadható, hiszen a felhasználói élmény szempontjából mindegy, hogy a negyedik helyett az ötödik legjobb dokumentumot kapja vissza a rendszer. A vektorkereséssel kombinált metaadat-szűrés lehetővé teszi, hogy utófeldolgozás nélkül korlátozd a lekérdezést egy adott kategóriára, nyelvre vagy dátumtartományra. A tartósság és a valós idejű frissítések elkerülik, hogy egyetlen dokumentum hozzáadásához újra kelljen építeni egy teljes fájlt. Végül a vízszintes méretezhetőség az, ami megkülönbözteti a prototípust az éles szolgáltatástól.

Pinecone

A Pinecone menedzselt szolgáltatás: nem kell szervereket üzemeltetned, csupán létrehozol egy indexet a dimenzió és a metrika megadásával, a többit pedig a rendszer intézi. Figyeld meg a query hívásnak átadott categorie szűrőt: a vektorkeresés és a szűrés egyszerre fut le, nem egymás után.

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

A létrehozáskor megadott dimenzió végleges: a text-embedding-3-large modellről a text-embedding-3-small modellre való váltáshoz újra kell létrehozni az indexet. Ezért a modellt előre válaszd ki, ne utólag.

Qdrant

A Qdrant nyílt forráskódú, saját hosztolású megoldás, kiváló teljesítménnyel. A szókincs eltér – kollekciókról, pontokról és hasznos adatokról (payload) beszélünk, míg a Pinecone indexekről, vektorokról és metaadatokról –, de a séma ugyanaz marad. Vegyük észre, hogy a példa dokumentumonként hívja meg a beágyazási API-t a cikluson belül: ez három dokumentum esetén elfogadható, de ahogy a korpusz növekszik, gondolkodj el a köteges (batch) műveletekre való visszatérésen.

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

A Weaviate a natív hibrid kereséssel tűnik ki, amire a 9. leckében még visszatérünk. Az adatmodellje strukturáltabb, mint versenytársaié: mielőtt bármit beszúrnál, expliciten deklarálnod kell a tulajdonságokat és típusaikat, ami közelebb hozza a használatát egy klasszikus adatbázis élményéhez.

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 és pgvector

A Chroma a gyors prototípuskészítést célozza meg: egy tartós kliens, amely egy helyi mappára mutat, egy menet közben létrehozott kollekció, és nincs szükség infrastruktúrára. Ez az a lehetőség, amellyel NumPy-indexről valódi adatbázisra válthatsz anélkül, hogy megváltoztatnád a munkakörnyezetedet.

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)

A pgvector egy teljesen más helyzetet kezel: a dokumentumaid már PostgreSQL-ben vannak, a saját joinjaikkal, hozzáférési jogaikkal és biztonsági mentéseikkel. Ahelyett, hogy egy második rendszert vezetnél be a szinkronizáláshoz, a kiegészítés hozzáad egy vector típust és távolságoperátorokat a meglévő adatbázishoz. A <=> operátor kiszámítja a koszinusztávolságot, a HNSW-index pedig azt biztosítja, hogy a lekérdezés néhány ezer sornál is használható maradjon.

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

Összehasonlítás

KritériumPineconeQdrantWeaviateChromapgvector
TípusMenedzseltNyílt forráskódúNyílt forráskódúNyílt forráskódúKiegészítés
HosztolásFelhőSaját hosztolás/FelhőSaját hosztolás/FelhőHelyi/BeágyazottPostgreSQL
Hibrid keresés✅✅✅ Natív❌SQL-en keresztül
Éles környezet✅✅✅⚠️ Prototípus✅
Használhatóság✅✅✅✅✅✅✅

A választás kevésbé függ a nyers teljesítménytől, amely a gyakorlatban nagyon közel van egymáshoz, mint a kontextustól: egy csapatnak, amely már PostgreSQL-t használ, mindenképpen érdemes ennél maradnia; egy csapat, amelynek nincs DevOps erőforrása, a menedzselt megoldást választja; míg egy csapatnak, amelynek szabályozási okokból Európában kell hosztolnia, a saját hosztolású megoldás felé kell fordulnia.

Főbb megállapítások

  • Chroma a gyors prototípuskészítéshez
  • pgvector, ha már van PostgreSQL-ed
  • Pinecone menedzselt, infrastruktúra-mentes megoldáshoz
  • Qdrant nagy teljesítményű saját hosztoláshoz
  • Weaviate natív hibrid kereséshez