Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Vektorinės duomenų bazės (Pinecone, Qdrant, Weaviate)

Paskaita 8 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Kodėl reikia vektorinės duomenų bazės?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma ir pgvector
  7. Palyginimas
  8. Svarbiausi punktai

Tikslai

  • Suprasti, kodėl reikia vektorinių duomenų bazių
  • Palyginti Pinecone, Qdrant, Weaviate, Chroma ir pgvector
  • Įgyvendinti paiešką naudojant kiekvieną iš jų

Kodėl reikia vektorinės duomenų bazės?

Ankstesnėje pamokoje naudotas NumPy indeksas puikiai tinka keliems tūkstančiams dokumentų, nes dešimties tūkstančių vektorių išsami nuskaitymo operacija lieka nepastebima. Esant vienam milijonui, tas pats skaičiavimas sukelia vieną sekundės delsą kiekvienai užklausai, o matrica nebetelpa patogiai operatyviojoje atmintyje.

Iškyla keturi poreikiai. ANN paieška (apytiksliai artimiausi kaimynai) atsisako garantijos gauti tikslų rezultatą mainais į milisekundžių trukmės atsakymą dirbant su milijonais vektorių – tai kompromisas, kuris beveik visada priimtinas, nes penktojo geriausio dokumento grąžinimas vietoj ketvirtojo vartotojo patirčiai nieko nekeičia. Metaduomenų filtravimas, derinamas su vektorine paieška, leidžia apriboti užklausą konkrečia kategorija, kalba ar datos intervalu be papildomo apdorojimo. Ilgaamžiškumas ir atnaujinimai realiuoju laiku leidžia išvengti viso failo perkūrimo tiesiog pridėjus naują dokumentą. Galiausiai, horizontalus mastelio keitimas yra tai, kas prototipą skiria nuo gamybinės sistemos.

Pinecone

Pinecone yra valdoma paslauga: jums nereikia diegti serverių, sukuriate indeksą nurodydami jo dimensiją ir metriką, o visa kita sutvarkoma už jus. Atkreipkite dėmesį į categorie filtrą, perduodamą tiesiai į query – vektorinė paieška ir filtravimas vykdomi kartu, o ne vienas po kito.

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

Kūrimo metu deklaruota dimensija yra galutinė: perėjimas nuo text-embedding-3-large prie text-embedding-3-small reikalauja indekso perkūrimo. Todėl modelį pasirinkite iš anksto, o ne po to.

Qdrant

Qdrant yra atviro kodo sprendimas, diegiamas savarankiškai, ir pasižymi puikiu našumu. Žodynas skiriasi – mes kalbame apie kolekcijas, taškus ir naudingąją apkrovą (payload), tuo tarpu Pinecone vartoja indeksų, vektorių ir metaduomenų sąvokas, tačiau schema lieka identiška. Atkreipkite dėmesį, kad pavyzdyje įterpimo API kviečiama dokumentas po dokumento ciklo viduje: tai priimtina trims dokumentams, tačiau augant korpusui, pagalvokite apie grįžimą prie paketinio apdorojimo.

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 išsiskiria savo natyvia hibridine paieška, prie kurios grįšime 9-oje pamokoje. Jo duomenų modelis yra labiau struktūrizuotas nei konkurentų: prieš įterpdami ką nors, aiškiai deklaruojate savybes ir jų tipus, todėl patirtis tampa artimesnė klasikinei duomenų bazei.

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

Chroma skirta prototipų kūrimui: tai nuolatinis klientas, nukreiptas į vietinį aplanką, kolekcija kuriama dinamiškai, jokia infrastruktūra nereikalinga. Tai yra pasirinkimas, leidžiantis pereiti nuo NumPy indekso prie tikros duomenų bazės nekeičiant darbo aplinkos.

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 sprendžia visiškai kitokią situaciją: jūsų dokumentai jau yra PostgreSQL sistemoje su savo jungtimis, prieigos teisėmis ir atsarginėmis kopijomis. Užuot diegę antrą sistemą sinchronizavimui, plėtinys į esamą duomenų bazę prideda vector tipą ir atstumo operatorius. Operatorius <=> apskaičiuoja kosinusinį atstumą, o HNSW indeksas yra tai, kas leidžia užklausai būti efektyviai vykdomai viršijus kelis tūkstančius eilučių.

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

Palyginimas

KriterijusPineconeQdrantWeaviateChromapgvector
TipasValdomaAtviro kodoAtviro kodoAtviro kodoPlėtinys
TalpinimasDebesisSavarankiškas/DebesisSavarankiškas/DebesisVietinis/ĮterptasPostgreSQL
Hibridinė paieška✅✅✅ Natyvi❌Per SQL
Gamyba✅✅✅⚠️ Prototipams✅
Naudojimo paprastumas✅✅✅✅✅✅✅

Pasirinkimas priklauso mažiau nuo žaliavinio našumo, kuris praktiškai yra labai panašus, o labiau nuo jūsų konteksto: komanda, kuri jau naudoja PostgreSQL, turėtų visais būdais pasilikti prie jos; komanda be operacijų specialistų pasirinks valdomą sprendimą, o komandai, kuri dėl reguliavimo priežasčių privalo talpinti duomenis Europoje, reikės savarankiško sprendimo.

Svarbiausi punktai

  • Chroma – greitai prototipų kūrimui
  • pgvector – jei jau naudojate PostgreSQL
  • Pinecone – valdomam sprendimui be infrastruktūros rūpesčių
  • Qdrant – našiam savarankiškam diegimui
  • Weaviate – natyviai hibridinei paieškai