Vector Databases: De Ruggengraat van AI-Applicaties

Wat zijn Vector Databases en Waarom zijn ze in 2026 Onmisbaar?

De opkomst van Large Language Models (LLMs), generatieve AI en semantische zoektoepassingen heeft een fundamenteel nieuw type dataopslag noodzakelijk gemaakt: de vector database. Waar traditionele relationele databases uitblinken in het opslaan van gestructureerde data en het uitvoeren van exacte zoekopdrachten, schieten ze tekort wanneer je wilt zoeken op betekenis in plaats van exacte trefwoorden.

In 2026 is de vector database niet langer een nicheoplossing voor academici of AI-onderzoekslaboratoria. Het is de ruggengraat van vrijwel elke serieuze AI-applicatie: van chatbots met bedrijfskennis (RAG-systemen) tot aanbevelingsengines, fraudedetectie en multimodale zoekmachines die tekst, afbeeldingen en audio combineren.

Stel je voor: een gebruiker zoekt naar "goedkope vakantiebestemmingen in Zuid-Europa" in jouw reisdatabase. Een traditionele zoekengine vindt alleen documenten met exact die woorden. Een vector database vindt ook artikelen over "budgetvriendelijke reizen naar Portugal", "zonvakantie Griekenland betaalbaar" en "goedkoop zomers Italië" — simpelweg omdat ze semantisch dicht bij elkaar liggen in de vectorruimte.

Hoe Werken Vector Databases? De Techniek Uitgelegd

Om vector databases echt te begrijpen, moet je drie kernconcepten beheersen: embeddings genereren, vectoren indexeren, en Approximate Nearest Neighbor (ANN) zoekopdrachten uitvoeren.

Hoe Similarity Berekend Wordt

Praktische Codevoorbeelden

Genoeg theorie — laten we kijken hoe je een vector database daadwerkelijk gebruikt in een productieomgeving. We behandelen drie populaire opties: Pinecone (managed cloud), Weaviate (open-source) en pgvector (PostgreSQL extensie).

1. RAG-pipeline met Pinecone en OpenAI

Dit is een realistisch voorbeeld van een Retrieval-Augmented Generation (RAG) systeem dat bedrijfsdocumenten doorzoekbaar maakt voor een chatbot:

import os
from openai import OpenAI
from pinecone import Pinecone, ServerlessSpec
import hashlib

# Initialiseer clients
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))

INDEX_NAME = "bedrijfsdocumenten"
EMBED_MODEL = "text-embedding-3-small"
EMBED_DIMS = 1536

# Maak index aan als die nog niet bestaat
if INDEX_NAME not in pc.list_indexes().names():
    pc.create_index(
        name=INDEX_NAME,
        dimension=EMBED_DIMS,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="eu-west-1")
    )

index = pc.Index(INDEX_NAME)

def genereer_embedding(tekst: str) -> list[float]:
    """Genereer een embedding via OpenAI API."""
    response = client.embeddings.create(
        input=tekst,
        model=EMBED_MODEL
    )
    return response.data[0].embedding

def indexeer_document(doc_id: str, tekst: str, metadata: dict):
    """Sla een document op als vector in Pinecone."""
    embedding = genereer_embedding(tekst)
    index.upsert(vectors=[{
        "id": doc_id,
        "values": embedding,
        "metadata": {
            **metadata,
            "tekst": tekst[:1000]  # Sla eerste 1000 tekens op als metadata
        }
    }])
    print(f"Document '{doc_id}' geïndexeerd.")

def zoek_relevante_documenten(vraag: str, top_k: int = 5, filter: dict = None):
    """Zoek de meest relevante documenten voor een vraag."""
    vraag_embedding = genereer_embedding(vraag)
    resultaten = index.query(
        vector=vraag_embedding,
        top_k=top_k,
        include_metadata=True,
        filter=filter  # Bijv. {"afdeling": {"$eq": "finance"}}
    )
    return resultaten.matches

def rag_antwoord(vraag: str, afdeling: str = None) -> str:
    """Genereer een antwoord op basis van relevante documenten (RAG)."""
    filter = {"afdeling": {"$eq": afdeling}} if afdeling else None
    docs = zoek_relevante_documenten(vraag, top_k=3, filter=filter)

    if not docs:
        return "Geen relevante documenten gevonden."

    # Bouw context op uit gevonden documenten
    context = "\n\n".join([
        f"[{doc.metadata.get('titel', 'Onbekend')}]\n{doc.metadata.get('tekst', '')}"
        for doc in docs
    ])

    # Genereer antwoord met GPT-4
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": (
                "Je bent een behulpzame assistent. Beantwoord vragen uitsluitend "
                "op basis van de gegeven context. Als het antwoord niet in de "
                "context staat, zeg dat dan eerlijk."
            )},
            {"role": "user", "content": f"Context:\n{context}\n\nVraag: {vraag}"}
        ],
        temperature=0.1
    )
    return response.choices[0].message.content

# Voorbeeld gebruik
if __name__ == "__main__":
    # Indexeer voorbeelddocumenten
    documenten = [
        {
            "id": "hr-001",
            "tekst": "Medewerkers hebben recht op 25 vakantiedagen per jaar. "
                     "Vakantiedagen kunnen worden opgebouwd en overgedragen naar het volgende jaar.",
            "metadata": {"titel": "Vakantiebeleid", "afdeling": "hr"}
        },
        {
            "id": "finance-001",
            "tekst": "Declaraties tot €150 kunnen direct worden ingediend zonder goedkeuring. "
                     "Bedragen boven €150 vereisen manager-goedkeuring binnen 5 werkdagen.",
            "metadata": {"titel": "Declaratiebeleid", "afdeling": "finance"}
        }
    ]

    for doc in documenten:
        indexeer_document(doc["id"], doc["tekst"], doc["metadata"])

    # Stel een vraag
    antwoord = rag_antwoord("Hoeveel vakantiedagen heb ik?", afdeling="hr")
    print(f"Antwoord: {antwoord}")

2. pgvector: Vector Search in PostgreSQL

Als je al PostgreSQL gebruikt, is pgvector de meest pragmatische keuze — geen nieuwe infrastructuur nodig:

-- Installeer de pgvector extensie
CREATE EXTENSION IF NOT EXISTS vector;

-- Maak een tabel aan voor productembeddings
CREATE TABLE producten (
    id          SERIAL PRIMARY KEY,
    naam        TEXT NOT NULL,
    beschrijving TEXT,
    categorie   TEXT,
    prijs       DECIMAL(10,2),
    embedding   vector(1536)  -- OpenAI text-embedding-3-small dimensie
);

-- Maak een HNSW index aan voor snelle similarity search
CREATE INDEX ON producten USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- Voeg een product in (embedding als array van floats)
INSERT INTO producten (naam, beschrijving, categorie, prijs, embedding)
VALUES (
    'Ergonomische bureaustoel',
    'Verstelbare lendensteuн, ademend mesh materiaal, 8 uur comfort',
    'kantoormeubelen',
    249.99,
    '[0.023, -0.045, 0.112, ...]'::vector  -- Vervang door echte embedding
);

-- Semantic search: vind de 5 meest vergelijkbare producten
-- (query_embedding zou gegenereerd worden door je applicatie)
SELECT
    naam,
    beschrijving,
    categorie,
    prijs,
    1 - (embedding <=> '[0.021, -0.041, 0.108, ...]'::vector) AS similarity_score
FROM producten
WHERE categorie = 'kantoormeubelen'  -- Metadata filter
ORDER BY embedding <=> '[0.021, -0.041, 0.108, ...]'::vector
LIMIT 5;

# Python-implementatie met pgvector en asyncpg
import asyncpg
import numpy as np
from openai import OpenAI

client = OpenAI()

async def zoek_producten(zoekvraag: str, categorie: str = None, top_k: int = 5):
    """Zoek producten op basis van semantische gelijkenis."""
    # Genereer embedding voor de zoekvraag
    embedding = client.embeddings.create(
        input=zoekvraag,
        model="text-embedding-3-small"
    ).data[0].embedding

    embedding_str = "[" + ",".join(map(str, embedding)) + "]"

    conn = await asyncpg.connect(dsn=os.getenv("DATABASE_URL"))

    query = """
        SELECT naam, beschrijving, prijs,
               1 - (embedding <=> $1::vector) AS score
        FROM producten
        WHERE ($2::text IS NULL OR categorie = $2)
        ORDER BY embedding <=> $1::vector
        LIMIT $3
    """

    resultaten = await conn.fetch(query, embedding_str, categorie, top_k)
    await conn.close()
    return resultaten

3. Weaviate: Hybrid Search met BM25 + Vectoren

import weaviate
import weaviate.classes as wvc

# Verbind met lokale Weaviate instantie
client = weaviate.connect_to_local()

# Definieer een collectie met automatische vectorisatie
artikelen = client.collections.create(
    name="Kennisbank",
    vectorizer_config=wvc.config.Configure.Vectorizer.text2vec_openai(
        model="text-embedding-3-small"
    ),
    generative_config=wvc.config.Configure.Generative.openai(
        model="gpt-4o"
    ),
    properties=[
        wvc.config.Property(name="titel", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="inhoud", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="afdeling", data_type=wvc.config.DataType.TEXT),
    ]
)

# Hybrid search: combineer keyword (BM25) en vector search
resultaten = client.collections.get("Kennisbank").query.hybrid(
    query="thuiswerken beleid",
    alpha=0.5,        # 0 = puur BM25, 1 = puur vector, 0.5 = mix
    limit=5,
    filters=wvc.query.Filter.by_property("afdeling").equal("hr")
)

for item in resultaten.objects:
    print(f"Titel: {item.properties['titel']}")
    print(f"Score: {item.metadata.score}")

client.close()

Vergelijking: Welke Vector Database Kies Je?

De keuze voor de juiste vector database hangt af van je use case, bestaande infrastructuur en team-expertise. Hier is een eerlijke vergelijking van de meest populaire opties in 2026:

Best Practices voor Productie

Vector databases in productie brengen is een ander verhaal dan een proof-of-concept draaien. Hier zijn de kritische best practices die je behoedt voor dure fouten:

Chunking Strategie in Code

from langchain.text_splitter import RecursiveCharacterTextSplitter
from typing import List, Dict

def chunk_document(tekst: str, doc_metadata: dict) -> List[Dict]:
    """
    Splits een document in overlappende chunks met metadata.
    Volgt best practice: 512 tokens, 10% overlap.
    """
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=512,
        chunk_overlap=51,           # ~10% overlap
        length_function=len,
        separators=["\n\n", "\n", ". ", " ", ""]  # Volgorde van voorkeur
    )

    chunks = splitter.split_text(tekst)

    resultaat = []
    for i, chunk in enumerate(chunks):
        resultaat.append({
            "id": f"{doc_metadata['doc_id']}_chunk_{i}",
            "tekst": chunk,
            "metadata": {
                **doc_metadata,
                "chunk_index": i,
                "totaal_chunks": len(chunks),
                "char_start": tekst.find(chunk)  # Positie in origineel document
            }
        })

    return resultaat

def batch_indexeer(chunks: List[Dict], index, batch_size: int = 200):
    """Indexeer chunks in batches voor maximale throughput."""
    for i in range(0, len(chunks), batch_size):
        batch = chunks[i:i + batch_size]

        # Genereer embeddings voor de hele batch in één API-call
        teksten = [c["tekst"] for c in batch]
        embeddings = client.embeddings.create(
            input=teksten,
            model="text-embedding-3-small"
        ).data

        vectors = [
            {
                "id": chunk["id"],
                "values": emb.embedding,
                "metadata": chunk["metadata"]
            }
            for chunk, emb in zip(batch, embeddings)
        ]

        index.upsert(vectors=vectors)
        print(f"Batch {i//batch_size + 1} geïndexeerd ({len(vectors)} chunks)")

Conclusie: Wanneer Wel en Wanneer Niet?

Vector databases zijn krachtig, maar ze zijn geen silver bullet. Hier is een eerlijk overzicht van wanneer je ze wel of juist niet moet inzetten:

In 2026 is de vraag niet meer "of