Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Vector databases (Pinecone, Qdrant, Weaviate)

Les 8 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Waarom een vectordatabase?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma en pgvector
  7. Vergelijking
  8. Belangrijkste punten

Doelstellingen

  • Begrijpen waarom vectordatabases noodzakelijk zijn
  • Pinecone, Qdrant, Weaviate, Chroma en pgvector vergelijken
  • Zoekopdrachten implementeren met elk van deze systemen

Waarom een vectordatabase?

De NumPy-index uit de vorige les werkt perfect voor een paar duizend documenten, omdat een exhaustieve scan van tienduizend vectoren onmerkbaar blijft. Bij één miljoen wordt diezelfde berekening echter een seconde latentie per query, en past de matrix niet meer comfortabel in het geheugen.

Er doen zich vier behoeften tegelijk voor. ANN-zoekopdrachten (Approximate Nearest Neighbors) laten de garantie op een exact resultaat varen ten gunste van een respons in milliseconden op miljoenen vectoren; een compromis dat bijna altijd aanvaardbaar is, aangezien het teruggeven van het op vier na beste document in plaats van het op drie na beste niets verandert aan de gebruikerservaring. Metadatfiltering in combinatie met vectorzoekopdrachten stelt u in staat een query te beperken tot een categorie, taal of datumbereik zonder nabewerking. Persistentie en realtime-updates voorkomen dat u een heel bestand opnieuw moet opbouwen om slechts één document toe te voegen. Tot slot is horizontale schaling wat een prototype onderscheidt van een productiedienst.

Pinecone

Pinecone is een beheerde dienst: u hoeft geen servers in te richten, u maakt een index aan door de dimensie en metriek op te geven, en de rest wordt voor u afgehandeld. Merk op dat het filter categorie direct wordt doorgegeven aan query; vectorzoekopdrachten en filtering worden samen uitgevoerd, niet na elkaar.

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

De bij het aanmaken gedeclareerde dimensie is definitief: overstappen van text-embedding-3-large naar text-embedding-3-small vereist het opnieuw aanmaken van de index. Beslis dus vooraf over het model, niet achteraf.

Qdrant

Qdrant is open source, self-hosted en biedt uitstekende prestaties. De terminologie verschilt: we spreken over collecties, punten en payloads waar Pinecone het heeft over indexen, vectoren en metadata, maar het schema blijft identiek. Merk op dat het voorbeeld de embedding-API document voor document aanroept binnen de lus: dit is aanvaardbaar voor drie documenten, maar denk eraan om terug te schakelen naar batches zodra het corpus groeit.

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 onderscheidt zich door zijn native hybride zoekfunctie, waarop we in les 9 terugkomen. Het datamodel is gestructureerder dan dat van zijn concurrenten: u declareert expliciet eigenschappen en hun typen voordat u iets invoegt, wat de ervaring dichter bij die van een klassieke database brengt.

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

Chroma richt zich op prototyping: een persistente client die naar een lokale map wijst, een collectie die on-the-fly wordt aangemaakt, geen infrastructuur. Dit is de optie die u van een NumPy-index naar een echte database brengt zonder uw werkomgeving te wijzigen.

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 adresseert een heel andere situatie: uw documenten staan al in PostgreSQL, met hun joins, toegangsrechten en back-ups. In plaats van een tweede systeem te introduceren dat gesynchroniseerd moet worden, voegt de extensie een vector-type en afstandoperators toe aan de bestaande database. De operator <=> berekent de cosinusafstand, en de HNSW-index is wat de query bruikbaar maakt voor meer dan een paar duizend rijen.

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

Vergelijking

CriteriumPineconeQdrantWeaviateChromapgvector
TypeBeheerdOpen sourceOpen sourceOpen sourceExtensie
HostingCloudSelf-hosted/CloudSelf-hosted/CloudLokaal/EmbedPostgreSQL
Hybride zoeken✅✅✅ Native❌Via SQL
Productie✅✅✅⚠️ Prototyping✅
Gebruiksgemak✅✅✅✅✅✅✅

De keuze hangt minder af van de ruwe prestaties, die in de praktijk zeer dicht bij elkaar liggen, dan van uw context: een team dat al PostgreSQL draait, heeft er alle belang bij daarbij te blijven, een team zonder ops-kennis kiest voor een beheerde oplossing, en een team dat om regelgevende redenen in Europa moet hosten, zal kiezen voor self-hosting.

Belangrijkste punten

  • Chroma voor snel prototyping
  • pgvector als u al PostgreSQL heeft
  • Pinecone voor een beheerde oplossing zonder infrastructuur
  • Qdrant voor high-performance self-hosting
  • Weaviate voor native hybride zoekopdrachten