Vektoradatbázisok összehasonlítása 2026-ban: Pinecone, Qdrant, Weaviate, Chroma és Milvus a gyakorlatban

2026-ra a vektoradatbázis-piac, hogy úgy mondjam, teljesen kiforrott. Ha RAG-rendszert (retrieval-augmented generation) építesz, az embedding-modell mellett a vektoradatbázis-választás a leghosszabb távú architekturális döntés, amit meghozol – és tényleg ez fogja meghatározni a havi infrastruktúra-számlát, a p99 latenciát, a karbantartási terhet, és azt is, hogy 50 millió vektor fölé skálázható-e a rendszer újratervezés nélkül. Ebben az útmutatóban öt domináns megoldást – Pinecone, Qdrant, Weaviate, Chroma és Milvus – hasonlítok össze friss 2026-os adatokkal, valós árazással, és ugyanazt a RAG-feladatot megvalósító kódpéldákkal mind az ötben.

Miért fontos a vektoradatbázis-választás 2026-ban?

A klasszikus dokumentumkeresés három évvel ezelőtti kérdés volt. 2026-ban a vektoradatbázis már nem csak hasonlósági keresést szolgál ki – hanem multi-tenant SaaS-RAG-et, ágens-memóriát, képkeresést, hibrid (BM25 + vektor) keresést, és sok esetben strukturált metaadat-szűréssel kombinált szemantikus keresést is támogatnia kell.

A választás alapvetően négy dimenzió mentén dől el:

• Üzemeltetési modell – fully managed (Pinecone, Zilliz Cloud), self-hosted open source (Qdrant, Weaviate, Milvus, Chroma) vagy hibrid.
• Skála – 1 millió vektor alatt szinte minden megoldás megfelelő; 100 millió fölött drasztikusan szűkül a mezőny.
• Lekérdezési mintázat – tisztán vektoros kNN, hibrid keresés, mély metaadat-szűrés, multi-tenant izoláció.
• Költségmodell – fix havi díj, használat-alapú (read/write unit), vagy kapacitás-alapú (CU).

Őszintén szólva, a leggyakoribb hiba 2026-ban is ugyanaz, ami 2024-ben volt: a csapatok egy benchmark-grafikon vagy egy népszerű YouTube-tutorial alapján választanak, ahelyett, hogy a saját szűrési igényeiket, lekérdezési volumenüket és biztonsági modelljüket modelleznék. Ez később fáj.

Gyors döntési mátrix

Ha csak egy táblázatot olvasol el az egész cikkből, ez legyen az:

Eset	Ajánlott megoldás	Ok
MVP, < 1M vektor, lokális fejlesztés	Chroma	pip install, embedded mód, nulla setup
Zero-ops, gyors piacra lépés	Pinecone	Serverless, auto-scaling, SLA
Self-hosted, legjobb ár-érték arány	Qdrant	Rust, p50 4ms, kvantálás beépítve
Hibrid keresés + multi-tenant SaaS	Weaviate	BM25 + vektor + tenant izoláció
Milliárdos skála, GPU-gyorsítás	Milvus / Zilliz	DiskANN, GPU index, Cardinal engine
Postgres-stack, < 10M vektor	pgvector	ACID, egy adatbázis SQL + vektor

1. Pinecone – a managed RAG sztenderd

A Pinecone 2024-ben felszámolta a régi "pod"-alapú árazást, és teljesen serverless modellre váltott. 2026-ban ez a legkönnyebb úton bevethető vektoradatbázis – feltéve, hogy nem érzékeny rád a vendor lock-in.

Erősségek

• Nulla üzemeltetés: nincs Kubernetes, nincs HNSW-paraméterhangolás, nincs sharding (és ez sokat ér).
• Serverless auto-scaling: a forgalmi csúcsok nem generálnak pager-riasztást hajnal 3-kor.
• p99 latencia ~7 ms milliárdos vektorszám mellett is.
• Vállalati funkciók: SSO, RBAC, dedikált infrastruktúra, SOC 2.

Gyengeségek

• Vendor lock-in – nincs self-hosted opció, és pont.
• Magas QPS mellett a Read Unit számla lineárisan nő (1000 QPS könnyen havi több ezer dolláros tétel).
• Korlátozott testreszabhatóság az index szintjén.

Árazás (2026, serverless)

• Storage: 0,33 USD / GB / hónap
• Read Units: 8,25 USD / 1M RU
• Write Units: 2,00 USD / 1M WU
• Free tier: 100k vektor
• 10M vektor + közepes forgalom: tipikusan 200–400 USD / hónap

Pinecone Python kliens 2026

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="YOUR_API_KEY")

# Index létrehozása (egyszer)
pc.create_index(
    name="rag-docs",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

index = pc.Index("rag-docs")

# Upsert
index.upsert(vectors=[
    {"id": "doc-1", "values": embedding, "metadata": {"source": "kb", "lang": "hu"}},
])

# Lekérdezés metaadat-szűréssel
results = index.query(
    vector=query_embedding,
    top_k=5,
    filter={"lang": {"$eq": "hu"}},
    include_metadata=True,
)

2. Qdrant – a teljesítmény-bajnok

A Rust-ban írt Qdrant 2026-ra a független benchmarkok stabil élén áll, mind p50 latencia, mind QPS terén. És nem, az 1500 QPS és a 4–8 ms-os p50 nem marketing-szám: a memóriabiztos Rust runtime és a beépített skaláris/binary kvantálás teszi lehetővé.

Személyes véleményem: ha most kezdenék egy RAG projektet és nem érdekelne, hogy ki üzemelteti az infrát, valószínűleg ezt választanám a sebesség-ár arány miatt.

Erősségek

• A leggyorsabb open-source vektoradatbázis a piacon (p50 ~4–8 ms).
• Beépített kvantálás (scalar, product, binary) – akár 32× memóriacsökkentés.
• Rendkívül erős JSON payload-szűrés: range, geo, lista, full-text.
• Free tier: 1 GB tárhely örökre, hitelkártya nélkül. Ez ritka manapság.
• Self-hosted egyszerűség: egyetlen Docker konténer, nincs Kubernetes-kötelezettség.

Gyengeségek

• A beépített vektorizációs modulok gyengébbek, mint a Weaviate-é – külön embedding-pipeline kell.
• Multi-tenant izoláció megoldható, de nem olyan first-class, mint Weaviate-ben.

Árazás (2026, Qdrant Cloud)

• Free tier: 1 GB örökre
• Managed plánok: ~25 USD / hónap-tól
• 10M vektor managed hosting: ~100–250 USD / hónap
• Self-hosted: csak az infrastruktúra ára (egy 4 vCPU / 16 GB RAM VPS bőven elég 5M vektorhoz HNSW + scalar quantization mellett).

Qdrant Python kliens 2026

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct, Filter, FieldCondition, MatchValue

client = QdrantClient(url="http://localhost:6333")

client.recreate_collection(
    collection_name="rag-docs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)

client.upsert(
    collection_name="rag-docs",
    points=[
        PointStruct(id=1, vector=embedding, payload={"source": "kb", "lang": "hu"}),
    ],
)

results = client.search(
    collection_name="rag-docs",
    query_vector=query_embedding,
    query_filter=Filter(must=[FieldCondition(key="lang", match=MatchValue(value="hu"))]),
    limit=5,
)

3. Weaviate – a hibrid keresés királya

A Weaviate 2026-ban két területen veri a mezőnyt: a kiforrott hibrid keresés (BM25 + vektor + reciprocal rank fusion) és a multi-tenant izoláció. Ha SaaS-terméket építesz, ahol minden ügyfél a saját adathalmazán keres, a Weaviate tenant-modellje gyakorlatilag versenytárs nélkül áll.

Erősségek

• Beépített hibrid keresés egy lekérdezésben (BM25 + vektor).
• First-class multi-tenancy: tenantonként külön shard, dinamikus aktivizálás/szundi.
• Beépített vektorizációs modulok (text2vec-openai, text2vec-cohere stb.) – nyers szöveget is be lehet szúrni, és magától embedeli.
• Multimodális indexelés (kép, szöveg) first-class.

Gyengeségek

• 100M vektor fölött a memóriaigény ugrásszerűen nő – kapacitástervezés kötelező.
• 14 napos próbaidőszak – a legszűkebb a top-tier között.
• A GraphQL-alapú API egyesek számára szokatlan (REST is van, ne aggódj).

Árazás (2026, Weaviate Cloud)

• 14 napos ingyenes próba
• Sandbox: ~25 USD / hónap-tól
• 10M vektor managed: ~150–300 USD / hónap
• Enterprise: dedikált cluster, SSO, SOC 2

Weaviate hibrid keresés példa

import weaviate
from weaviate.classes.query import HybridFusion

client = weaviate.connect_to_local()

collection = client.collections.get("RagDocs")

# Hibrid keresés: 50% BM25, 50% vektor, RRF fúzióval
results = collection.query.hybrid(
    query="hogyan működik a RAG csővezeték",
    alpha=0.5,
    fusion_type=HybridFusion.RELATIVE_SCORE,
    limit=5,
    filters=weaviate.classes.query.Filter.by_property("lang").equal("hu"),
)

for obj in results.objects:
    print(obj.properties["title"], obj.metadata.score)

4. Chroma – a prototípus-bajnok

Lássuk be: a Chroma nem vetélytársa a Pinecone-nak vagy a Qdrantnek production skálán – és nem is annak épült. Az ereje a "pip install chromadb és kész" élményben van. RAG-tutorialok, hackathonok, lokális AI-asszisztensek és < 1 millió vektor méretű alkalmazások számára 2026-ban is a leggyorsabb út a működő demóig.

Erősségek

• Embedded mód: nincs külön szerver, közvetlenül a Python folyamatban fut.
• A legalacsonyabb belépési küszöb a piacon. Pont.
• Beépített embedding-funkciók (OpenAI, Cohere, sentence-transformers).
• 2025 óta kliens-szerver mód is van komolyabb deployment-hez.

Gyengeségek

• 10M vektor fölött komoly teljesítményproblémák.
• Korlátozott index-tuning és kvantálás.
• Kevésbé kiforrott vállalati funkciók (RBAC, multi-tenancy).

Árazás

• Open source, ingyenes
• Chroma Cloud (2025-ös beta): használat-alapú, ~25 USD / hónap-tól

Chroma kódpélda

import chromadb

client = chromadb.PersistentClient(path="./chroma-data")
collection = client.get_or_create_collection(
    name="rag-docs",
    metadata={"hnsw:space": "cosine"},
)

collection.add(
    ids=["doc-1"],
    embeddings=[embedding],
    metadatas=[{"source": "kb", "lang": "hu"}],
    documents=["A RAG egy retrieval-augmented generation csővezeték..."],
)

results = collection.query(
    query_embeddings=[query_embedding],
    n_results=5,
    where={"lang": "hu"},
)

5. Milvus – a milliárdos skála

A Milvus (és managed verziója, a Zilliz Cloud) 2026-ban az egyetlen open-source vektoradatbázis, amelyik milliárdos vektorszám mellett is kiszámíthatóan teljesít. A DiskANN és a GPU-gyorsított IVF-PQ indexek olyan árszinten teszik lehetővé a nagy skálát, amit egyik versenytárs sem tud követni.

Erősségek

• A legszélesebb index-paletta: HNSW, IVF, DiskANN, GPU IVF, SCANN.
• DiskANN: vektorok SSD-n, indexek RAM-ban – 10× olcsóbb tárolás nagy skálán.
• Cardinal engine (Zilliz Cloud) az open-source Milvusnál ~10× gyorsabb.
• Igazi distributed architektúra (proxy, query node, data node, index node).

Gyengeségek

• A legkomplexebb deployment a mezőnyben (Kubernetes ajánlott production-höz, ne kerülgesd).
• A tanulási görbe meredek; az index-paraméterek hangolása mély tudást igényel.
• 100k vektor alatt overkill – egy Qdrant vagy Chroma sokkal egyszerűbb.

Árazás (Zilliz Cloud, 2026)

• Compute Unit alapú: ~0,15 USD / CU / óra
• Free tier: 2 dedikált CU, korlátozott tárhely
• Self-hosted Milvus: csak az infrastruktúra ára

Milvus / pymilvus kódpélda

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")

schema = client.create_schema(auto_id=False, enable_dynamic_field=True)
schema.add_field("id", DataType.INT64, is_primary=True)
schema.add_field("vector", DataType.FLOAT_VECTOR, dim=1536)
schema.add_field("lang", DataType.VARCHAR, max_length=8)

client.create_collection(collection_name="rag_docs", schema=schema)

client.create_index(
    collection_name="rag_docs",
    index_params=client.prepare_index_params(
        field_name="vector",
        index_type="HNSW",
        metric_type="COSINE",
        params={"M": 16, "efConstruction": 200},
    ),
)

client.insert(collection_name="rag_docs", data=[
    {"id": 1, "vector": embedding, "lang": "hu"},
])

results = client.search(
    collection_name="rag_docs",
    data=[query_embedding],
    filter='lang == "hu"',
    limit=5,
)

Teljesítmény-benchmark – friss 2026-os adatok

A számok független mérésekből származnak (768d embedding, 10M vektor, m5.2xlarge AWS instance, top-k = 10):

Mutató	Pinecone	Qdrant	Weaviate	Milvus	Chroma
Lekérdezés p50	20 ms	4–8 ms	15 ms	12 ms	~80 ms
Lekérdezés p99	~7 ms (serverless)	25 ms	40 ms	35 ms	~250 ms
QPS (1 node)	500	1500	800	1200	~100
Index építés (1M vektor)	5 perc	4 perc	8 perc	6 perc	~12 perc
Memóriahatékonyság (kvantálással)	n/a	kiváló	jó	kiváló	gyenge

Egy fontos figyelmeztetés: a benchmarkok érzékenyek a konfigurációra. A Pinecone serverless p99-e azért nézhet ki feltűnően jónak, mert a managed szolgáltatás eleve túlméretezett kapacitáson fut. Self-hosted teljesítmény-összehasonlításnál a Qdrant és a Milvus dominál.

Költségmodell-elemzés – 10M vektor, 200 QPS

Egy tipikus production RAG-rendszerhez (10M dokumentum-chunk, 1536d OpenAI embedding, 200 QPS) a havi költség így alakul:

Megoldás	Üzemeltetés	Havi költség (becslés)
Pinecone Serverless	Managed	250–450 USD
Qdrant Cloud	Managed	120–250 USD
Qdrant self-hosted	Saját VPS	40–80 USD (+ DevOps idő)
Weaviate Cloud	Managed	180–320 USD
Zilliz Cloud (Milvus)	Managed	200–400 USD
Milvus self-hosted	Saját K8s	80–150 USD (+ jelentős DevOps)

50M vektor alatt a managed SaaS általában olcsóbb, mint a self-hosted – egyszerűen azért, mert a rejtett DevOps-költség (oncall, backup, upgrade, monitoring) felfalja a számokon látszó megtakarítást. 100M fölött ez fordul: a Qdrant vagy Milvus self-hosted akár 5–10× olcsóbb is lehet.

Hibrid keresés és metaadat-szűrés – kit válassz?

2026-ban a tisztán vektoros kNN-keresés ritka. A legtöbb production RAG-rendszer kombinálja a szemantikus keresést kulcsszó-alapú (BM25) kereséssel és metaadat-szűréssel (dátum, nyelv, szerző, jogosultság).

• Hibrid keresés natívan: Weaviate > Milvus > Qdrant. A Pinecone-ban külön sparse-dense index kell.
• Mély metaadat-szűrés: Qdrant > Weaviate > Milvus > Pinecone. A Qdrant payload-szűrője 2026-ban a legkifejezőbb (geo, range, full-text, nested).
• Prefiltering vs postfiltering: a Qdrant és a Milvus helyesen prefilterelnek (a szűrés a HNSW-bejárás alatt fut), így nem veszítesz találatot. A Pinecone postfilteringet használ, ami selektív szűrőknél (top_k = 5, de a szűrő után csak 1 marad) találat-éhességet okozhat.

Migráció és vendor lock-in – mire figyelj?

A vektoradatbázis-migráció 2026-ban már nem reménytelen. De drága. Néhány gyakorlati tanács, amit én is megtanultam a saját bőrömön:

• Tárold külön az embedding-eket. Ha az embedding-eket S3-ra (vagy hasonló blob-tárba) is elmented Parquet formátumban, bármikor újraindexelhetsz egy másik adatbázisban újra-embeddelés nélkül. Ez egyszer már megmentett egy projektet nálam.
• Kerüld a vendor-specifikus extra funkciókat (pl. Pinecone-os reranking) a kritikus útvonalon, ha esélyes a migráció.
• Használj absztrakciós réteget – a LangChain és a LlamaIndex 2026-os verziói szinte minden fenti adatbázishoz egységes interfészt adnak.
• Tervezz reindex-ablakot: 100M vektor újraindexelése 4–24 óra a célrendszertől függően.

Az embedding-modell fontosabb, mint az adatbázis

A 2026-os friss elemzések egyértelműek: a retrieval-minőséget az embedding-modell sokkal erősebben befolyásolja, mint a vektoradatbázis választása. Az OpenAI text-embedding-3-large, a Cohere embed-v4, a Voyage-3-Large és a nyílt forrású Nomic-embed-v2 közötti különbség egy adott domainen 10–25%-os recall-eltérést is jelenthet – miközben a Pinecone vs. Qdrant retrieval-minőség különbsége azonos paraméterek mellett 1–2% alatt marad.

Tehát a sorrend: (1) válassz jó embedding-modellt, mérd a saját evaluation-setteden, és (2) csak utána optimalizáld az adatbázist latenciára és költségre. Ennyi.

Gyakran ismételt kérdések (FAQ)

Melyik a legjobb vektoradatbázis 2026-ban RAG-hez?

Nincs egyetlen "legjobb" – a workloadtól függ. Pinecone, ha zero-ops kell és mindegy az ár; Qdrant, ha a legjobb teljesítmény-ár arányt keresed és vállalod a self-hostingot; Weaviate, ha hibrid keresést és multi-tenant izolációt akarsz; Milvus, ha milliárdos skálán dolgozol; Chroma, ha < 1M vektor és prototípus-fázisban vagy.

Pinecone vs Qdrant – melyiket válasszam?

Ha a csapatodnak nincs DevOps-kapacitása és a piacra jutási sebesség a fontos, válaszd a Pinecone-t. Ha számít a költség, fontos a vendor lock-in elkerülése, és van valaki, aki egy Docker konténert tud üzemeltetni, válaszd a Qdrantot. Tisztán teljesítményben (latencia, QPS) a Qdrant nyer azonos infrastruktúrán – ez nem is vita tárgya 2026-ban.

Mennyibe kerül egy vektoradatbázis 10 millió vektorhoz havonta?

2026-os árakkal: Pinecone Serverless 250–450 USD, Qdrant Cloud 120–250 USD, Weaviate Cloud 180–320 USD, Zilliz Cloud (Milvus) 200–400 USD. Self-hosted Qdrant ugyanez 40–80 USD-ből megoldható, de ne felejtsd hozzá számolni a DevOps-időt.

Open source vagy managed vektoradatbázis?

50 millió vektor alatt és csapat-bevezetésnél a managed SaaS általában olcsóbb a teljes költségen (DevOps idő + oncall + backup + upgrade), mint a self-hosted megoldás. 100 millió vektor fölött vagy stabil DevOps-csapat mellett a self-hosted (Qdrant, Milvus) 5–10× olcsóbb lehet.

Pgvector elég RAG-hez vagy kell dedikált vektoradatbázis?

10 millió vektor alatt és Postgres-stack mellett a pgvector teljesen elég – ACID, egy adatbázisban van a relációs és a vektoradat, kevesebb mozgó alkatrész. 50 millió fölött vagy > 200 QPS forgalomnál érdemes átállni dedikált megoldásra (Qdrant, Pinecone, Milvus).

Mennyit változtat a vektoradatbázis-választás a RAG retrieval-minőségén?

Minimálisan, jellemzően 1–2% recall-eltérés azonos embedding-modell és azonos top-k mellett. Ezzel szemben az embedding-modell cseréje (pl. OpenAI text-embedding-3-small → Voyage-3-Large) 10–25% recall-javulást is hozhat. A modell-választás fontosabb döntés.

Összegzés

2026-ban a vektoradatbázis-piac kiforrott: nincs hibás választás, csak nem optimális választás a saját workloadhoz képest. A döntés algoritmusa egyszerű:

1. Méretezd fel a skálát – mennyi vektor lesz 12 hónap múlva?
2. Mérd fel az üzemeltetési kapacitást – van-e valaki, aki Kubernetest üzemeltet?
3. Listázd a lekérdezési mintákat – kell-e hibrid keresés, mély metaadat-szűrés, multi-tenant?
4. Modelled a 12 hónapos költséget a várható QPS-sel.

A négy válasz alapján a fenti döntési mátrix általában egyértelmű ajánlást ad. És ne felejtsd: az embedding-modell és a chunking-stratégia minőségében nyersz vagy bukik a RAG-rendszered – a vektoradatbázis csak az infrastruktúra alatta.