Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Vektoritietokannat (Pinecone, Qdrant, Weaviate)

Oppitunti 8 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Miksi vektoritietokanta?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma ja pgvector
  7. Vertailu
  8. Keskeiset asiat

Tavoitteet

  • Ymmärtää, miksi vektoritietokantoja tarvitaan
  • Vertailla Pineconea, Qdrantia, Weaviatea, Chromaa ja pgvectoria
  • Toteuttaa haku kullakin niistä

Miksi vektoritietokanta?

Edellisen oppitunnin NumPy-indeksi toimii moitteettomasti muutaman tuhannen dokumentin kanssa, sillä kymmenen tuhannen vektorin tyhjentävä läpikäynti on edelleen huomaamatonta. Miljoonan vektorin kohdalla sama laskenta tuottaa kuitenkin sekunnin viiveen per kysely, eikä matriisi enää mahdu mukavasti muistiin.

Neljä tarvetta nousee esiin samanaikaisesti. ANN-haku (Approximate Nearest Neighbors) luopuu tarkan tuloksen takuusta millisekuntien vasteajan hyväksi miljoonien vektorien joukossa – kompromissi, joka on lähes aina hyväksyttävä, sillä viidenneksi parhaan dokumentin palauttaminen neljänneksi parhaan sijaan ei muuta käyttäjäkokemusta. Metatietosuodatus yhdistettynä vektorihakuun mahdollistaa kyselyn rajoittamisen tiettyyn kategoriaan, kieleen tai aikaväliin ilman jälkikäsittelyä. Pysyvyys ja reaaliaikaiset päivitykset välttävät koko tiedoston uudelleenrakentamisen pelkän dokumentin lisäämiseksi. Lopuksi horisontaalinen skaalautuvuus on se, mikä erottaa prototyypin tuotantopalvelusta.

Pinecone

Pinecone on hallittu palvelu: et provisionoi palvelimia, vaan luot indeksin määrittämällä sen ulottuvuuden ja metrian, ja loput hoidetaan puolestasi. Huomaa categorie-suodatin, joka välitetään suoraan query-funktiolle – vektorihaku ja suodatus suoritetaan yhdessä, ei peräkkäin.

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

Luonnin yhteydessä ilmoitettu ulottuvuus on lopullinen: siirtyminen mallista text-embedding-3-large malliin text-embedding-3-small vaatii indeksin uudelleenluonnin. Päätä siis malli ennen, älä jälkeen.

Qdrant

Qdrant on avoimen lähdekoodin ratkaisu, jonka voit isännöidä itse, ja se tarjoaa erinomaisen suorituskyvyn. Sanasto eroaa hieman – puhumme kokoelmista, pisteistä ja hyötykuormista (payloads), kun taas Pinecone puhuu indekseistä, vektoreista ja metatiedoista – mutta skeema pysyy samana. Huomaa, että esimerkissä embedding-API:a kutsutaan dokumentti kerrallaan silmukan sisällä: tämä on hyväksyttävää kolmelle dokumentille, mutta muista palata eräajoon (batching) heti, kun aineisto kasvaa.

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 erottuu natiivilla hybridihaullaan, johon palaamme oppitunnilla 9. Sen datamalli on jäsennellympi kuin kilpailijoilla: määrittelet ominaisuudet ja niiden tyypit eksplisiittisesti ennen minkään lisäämistä, mikä tuo kokemuksen lähemmäs perinteistä tietokantaa.

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

Chroma tähtää nopeaan prototypointiin: pysyvä asiakasohjelma, joka osoittaa paikalliseen kansioon, lennossa luotu kokoelma, ei infrastruktuuria. Tämä on vaihtoehto, joka vie sinut NumPy-indeksistä oikeaan tietokantaan muuttamatta työympäristöäsi.

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 ratkaisee hyvin erilaisen tilanteen: dokumenttisi ovat jo PostgreSQLissa omilla liitoksillaan, käyttöoikeuksillaan ja varmuuskopioillaan. Toisen järjestelmän tuominen synkronoitavaksi on turhaa; laajennus lisää olemassa olevaan tietokantaan vector-tyypin ja etäisyysoperaattorit. Operaattori <=> laskee kosinusetäisyyden, ja HNSW-indeksi on se, mikä tekee kyselystä käyttökelpoisen muutaman tuhannen rivin yläpuolella.

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

Vertailu

KriteriPineconeQdrantWeaviateChromapgvector
TyyppiHallittuAvoin lähdekoodiAvoin lähdekoodiAvoin lähdekoodiLaajennus
IsännöintiPilviOma/PilviOma/PilviPaikallinen/UpotettuPostgreSQL
Hybridi-haku✅✅✅ Natiivi❌SQL:n kautta
Tuotanto✅✅✅⚠️ Prototypointi✅
Käytettävyys✅✅✅✅✅✅✅

Valinta riippuu vähemmän raakasuorituskyvystä, joka on käytännössä hyvin lähellä toisiaan, kuin kontekstistasi: tiimi, joka jo pyörittää PostgreSQLää, hyötyy sen käytön jatkamisesta; tiimi, jolla ei ole ops-resursseja, valitsee hallitun palvelun; ja tiimi, jonka on sääntelysyistä isännöitävä Euroopassa, kääntyy itse isännöityyn ratkaisuun.

Keskeiset asiat

  • Chroma nopeaan prototypointiin
  • pgvector, jos sinulla on jo PostgreSQL
  • Pinecone hallittuun käyttöön ilman infrastruktuuria
  • Qdrant suorituskykyiseen itse isännöityyn ratkaisuun
  • Weaviate natiiviin hybridi-hakuun