Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Datubāzes vektoriem (Pinecone, Qdrant, Weaviate)

Nodarbība 8 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Kāpēc vektoru datubāze?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma un pgvector
  7. Salīdzinājums
  8. Galvenās atziņas

Mērķi

  • Saprast, kāpēc ir nepieciešamas vektoru datubāzes
  • Salīdzināt Pinecone, Qdrant, Weaviate, Chroma un pgvector
  • Implementēt meklēšanu ar katru no tām

Kāpēc vektoru datubāze?

Iepriekšējās nodarbības NumPy indekss lieliski strādā ar dažiem tūkstošiem dokumentu, jo desmit tūkstošu vektoru pilnīga skenēšana paliek nemanāma. Pie viena miljona tāds pats aprēķins rada vienas sekundes aizkavi uz katru vaicājumu, un matrica vairs neietilpst operatīvajā atmiņā bez problēmām.

Vienlaikus rodas četras vajadzības. ANN meklēšana (Approximate Nearest Neighbors) atsakās no garantijas par precīzu rezultātu par labu milisekunžu atbildei uz miljoniem vektoru – kompromiss, kas gandrīz vienmēr ir pieņemams, jo lietotāja pieredzei nav nozīmes, vai tiek atgriezts piektais labākais dokuments ceturtā vietā. Metadatu filtrēšana, apvienojot ar vektoru meklēšanu, ļauj ierobežot vaicājumu līdz konkrētai kategorijai, valodai vai datumu diapazonam bez papildu apstrādes. Noturība un atjaunināšana reāllaikā novērš nepieciešamību pārbūvēt visu failu tikai tāpēc, lai pievienotu vienu dokumentu. Visbeidzot, horizontālā mērogojamība ir tas, kas atšķir prototipu no ražošanas servisa.

Pinecone

Pinecone ir pārvaldīts serviss: tu neizvieto serverus, tu izveido indeksu, norādot tā dimensiju un metrisko, un pārējo tas paveic tavā vietā. Ņem vērā filtru categorie, kas tiek nodots tieši funkcijai query – vektoru meklēšana un filtrēšana tiek izpildītas kopā, nevis secīgi.

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

Izveides brīdī deklarētā dimensija ir galīga: pāreja no text-embedding-3-large uz text-embedding-3-small prasa indeksa pārizveidi. Tāpēc izvēlies modeli iepriekš, nevis pēc tam.

Qdrant

Qdrant ir atvērtā koda risinājums, ko izvieto pats, un tas piedāvā izcilu veiktspēju. Vārdnīca atšķiras – mēs runājam par kolekcijām, punktiem un kravas datiem (payload), turpretī Pinecone lieto terminus indeksi, vektori un metadati –, taču shēma paliek identiska. Ņem vērā, ka piemērā iekļaušanas API tiek izsaukts dokumentu pa dokumentam cikla ietvaros: tas ir pieņemami trim dokumentiem, taču, korpusam augot, noteikti pārej uz batch apstrādi.

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 izceļas ar savu natīvo hibrīdmeklēšanu, pie kuras atgriezīsimies 9. nodarbībā. Tās datu modelis ir strukturētāks nekā konkurentiem: tu eksplicīti deklarē īpašības un to tipus pirms jebkādas ievietošanas, kas pieredzi tuvina klasiskai datubāzei.

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

Chroma ir paredzēts prototipēšanai: noturīgs klients, kas norāda uz lokālu mapi, kolekcija, kas tiek izveidota uzreiz, bez infrastruktūras. Šī ir opcija, kas ļauj pāriet no NumPy indeksa uz īstu datubāzi, nemainot darba vidi.

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 risina pavisam citu situāciju: tavi dokumenti jau atrodas PostgreSQL kopā ar to savienojumiem, piekļuves tiesībām un dublējumiem. Tā vietā, lai ieviestu otro sistēmu sinhronizācijai, paplašinājums pievieno vector tipu un attāluma operatorus esošajai datubāzei. Operators <=> aprēķina kosinusa attālumu, un HNSW indekss ir tas, kas padara vaicājumu lietojamu arī ārpus dažiem tūkstošiem rindu.

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

Salīdzinājums

KritērijsPineconeQdrantWeaviateChromapgvector
TipsPārvaldītsAtvērtā kodaAtvērtā kodaAtvērtā kodaPaplašinājums
IzvietošanaMākonisPašizvietots/MākonisPašizvietots/MākonisLokāls/IegultsPostgreSQL
Hibrīdmeklēšana✅✅✅ Natīvā❌Caur SQL
Ražošana✅✅✅⚠️ Prototipēšana✅
Lietošanas ērtums✅✅✅✅✅✅✅

Izvēle ir atkarīga mazāk no izejveiktspējas, kas praksē ir ļoti līdzīga, un vairāk no tava konteksta: komandai, kas jau izmanto PostgreSQL, ir visas priekšrocības palikt pie tā; komanda bez ops resursiem izvēlēsies pārvaldītu risinājumu, bet komandai, kurai regulējumu dēļ jāizvieto serveri Eiropā, būs jāvērsas pie pašizvietotiem risinājumiem.

Galvenās atziņas

  • Chroma ātrai prototipēšanai
  • pgvector, ja jau izmanto PostgreSQL
  • Pinecone pārvaldītam risinājumam bez infrastruktūras
  • Qdrant augstas veiktspējas pašizvietotam risinājumam
  • Weaviate natīvai hibrīdmeklēšanai