Vector Databases: AI-Ready Data Opslag in 2026

Wat zijn Vector Databases en Waarom Zijn Ze in 2026 Onmisbaar?

De wereld van data engineering maakt een fundamentele verschuiving door. Traditionele relationele databases zijn uitstekend voor gestructureerde data met exacte queries — zoek je een gebruiker op ID of filter je orders op datum, dan werkt SQL feilloos. Maar moderne AI-toepassingen stellen heel andere eisen: ze moeten begrijpen wat data betekent, niet alleen wat het letterlijk zegt. Hier komen vector databases om de hoek kijken.

In 2026 zijn vector databases geen luxe meer maar een basiscomponent van elke serieuze AI-stack. De adoptie van Large Language Models (LLMs) zoals GPT-4o, Claude 3.5 en Llama 3 heeft een enorme vraag gecreëerd naar systemen die semantisch zoeken ondersteunen. Volgens recente marktcijfers is de vector database markt in 2025 meer dan verdubbeld ten opzichte van 2023, met een verwachte waarde van ruim $4 miljard in 2026.

De belangrijkste use cases die de adoptie aandrijven:

Hoe Werken Vector Databases? Van Tekst tot Embedding

Om vector databases te begrijpen, moet je eerst begrijpen wat een embedding is. Een embedding is een numerieke representatie van data (tekst, afbeelding, audio) als een vector in een hoog-dimensionele ruimte. Semantisch vergelijkbare items liggen dicht bij elkaar in die ruimte.

Visueel kun je dit zien als een multidimensionele ruimte:

Praktische Codevoorbeelden

Laten we direct aan de slag gaan met concrete implementaties van de drie meest gebruikte oplossingen in 2026.

1. pgvector: Vector Search in PostgreSQL

pgvector is de meest pragmatische keuze voor teams die al PostgreSQL gebruiken. Je voegt vector mogelijkheden toe zonder een nieuwe infrastructuurcomponent. Perfecte keuze voor kleinere tot middelgrote datasets (tot ~10 miljoen vectoren).

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

-- Maak een tabel met embedding kolom (1536 dimensies voor OpenAI ada-002)
CREATE TABLE documenten (
    id          SERIAL PRIMARY KEY,
    titel       TEXT NOT NULL,
    inhoud      TEXT NOT NULL,
    categorie   TEXT,
    embedding   VECTOR(1536),
    aangemaakt  TIMESTAMP DEFAULT NOW()
);

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

-- Voeg een document toe met embedding (via Python gegenereerd)
INSERT INTO documenten (titel, inhoud, categorie, embedding)
VALUES (
    'Introductie tot Machine Learning',
    'Machine learning is een tak van AI waarbij systemen leren van data...',
    'techniek',
    '[0.023, -0.187, 0.341, ...]'  -- 1536 dimensies
);

-- Semantisch zoeken: vind de 5 meest gerelateerde documenten
SELECT 
    id,
    titel,
    categorie,
    1 - (embedding <=> '[query_vector...]') AS similarity_score
FROM documenten
WHERE categorie = 'techniek'  -- Metadata filter
ORDER BY embedding <=> '[query_vector...]'
LIMIT 5;

Python-integratie met OpenAI embeddings:

import psycopg2
import openai
from typing import List

client = openai.OpenAI(api_key="jouw-api-key")

def genereer_embedding(tekst: str) -> List[float]:
    """Genereer een embedding via OpenAI API."""
    response = client.embeddings.create(
        input=tekst,
        model="text-embedding-3-small"  # 1536 dimensies
    )
    return response.data[0].embedding

def sla_document_op(conn, titel: str, inhoud: str, categorie: str):
    """Sla een document op met zijn embedding in pgvector."""
    embedding = genereer_embedding(inhoud)
    
    with conn.cursor() as cur:
        cur.execute("""
            INSERT INTO documenten (titel, inhoud, categorie, embedding)
            VALUES (%s, %s, %s, %s)
        """, (titel, inhoud, categorie, embedding))
    conn.commit()

def semantisch_zoeken(conn, query: str, top_k: int = 5, categorie: str = None):
    """Voer een semantische zoekopdracht uit."""
    query_embedding = genereer_embedding(query)
    
    sql = """
        SELECT 
            id, 
            titel, 
            categorie,
            1 - (embedding <=> %s::vector) AS score
        FROM documenten
        {filter}
        ORDER BY embedding <=> %s::vector
        LIMIT %s
    """
    
    filter_clause = "WHERE categorie = %s" if categorie else ""
    params = (
        query_embedding, 
        *([categorie] if categorie else []),
        query_embedding, 
        top_k
    )
    
    with conn.cursor() as cur:
        cur.execute(sql.format(filter=filter_clause), params)
        return cur.fetchall()

# Gebruik
conn = psycopg2.connect("postgresql://user:pass@localhost/vectordb")
sla_document_op(conn, "Deep Learning Basis", "Neurale netwerken zijn...", "AI")
resultaten = semantisch_zoeken(conn, "hoe werken neurale netwerken?", top_k=3)

for doc_id, titel, cat, score in resultaten:
    print(f"[{score:.3f}] {titel} ({cat})")

2. Weaviate: RAG Architectuur in Productie

Weaviate is een volledig beheerde of self-hosted vector database met ingebouwde vectorizer-modules en uitstekende RAG-ondersteuning. Ideaal voor enterprise use cases.

import weaviate
from weaviate.classes.init import Auth
from weaviate.classes.config import Configure, Property, DataType
from weaviate.classes.query import MetadataQuery

# Verbinding met Weaviate Cloud (of lokale instantie)
client = weaviate.connect_to_weaviate_cloud(
    cluster_url="jouw-cluster.weaviate.network",
    auth_credentials=Auth.api_key("jouw-weaviate-key"),
    headers={"X-OpenAI-Api-Key": "jouw-openai-key"}
)

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

# Data importeren met batch processing
kennisbank = client.collections.get("KennisBank")

with kennisbank.batch.dynamic() as batch:
    documenten = [
        {"titel": "Onboarding Gids", "inhoud": "Welkom bij het bedrijf...", 
         "afdeling": "HR", "versie": 2.1},
        {"titel": "Security Policy", "inhoud": "Alle medewerkers dienen...", 
         "afdeling": "IT", "versie": 1.5},
        {"titel": "API Documentatie", "inhoud": "Onze REST API accepteert...", 
         "afdeling": "Engineering", "versie": 3.0},
    ]
    for doc in documenten:
        batch.add_object(properties=doc)

# RAG Query: zoek EN genereer een antwoord
response = kennisbank.generate.near_text(
    query="wat zijn de beveiligingsregels voor wachtwoorden?",
    limit=3,
    filters=weaviate.classes.query.Filter.by_property("afdeling").equal("IT"),
    grouped_task="Vat de gevonden beveiligingsregels samen in bullet points",
    return_metadata=MetadataQuery(score=True)
)

print("=== RAG Antwoord ===")
print(response.generated)
print("\n=== Bronnen ===")
for obj in response.objects:
    print(f"- {obj.properties['titel']} (score: {obj.metadata.score:.3f})")

client.close()

3. Pinecone: Managed Vector Database op Schaal

Pinecone is de go-to keuze als je snel wilt schalen zonder infrastructuurbeheer. Volledig serverless, ondersteunt miljarden vectoren met sub-milliseconde latency.

from pinecone import Pinecone, ServerlessSpec
import openai

pc = Pinecone(api_key="jouw-pinecone-key")
openai_client = openai.OpenAI(api_key="jouw-openai-key")

# Maak een serverless index
if "productcatalogus" not in pc.list_indexes().names():
    pc.create_index(
        name="productcatalogus",
        dimension=1536,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="eu-west-1")
    )

index = pc.Index("productcatalogus")

def upsert_producten(producten: list[dict]):
    """Voeg producten toe aan Pinecone met embeddings."""
    vectors = []
    
    for product in producten:
        tekst = f"{product['naam']} {product['beschrijving']}"
        embedding = openai_client.embeddings.create(
            input=tekst,
            model="text-embedding-3-small"
        ).data[0].embedding
        
        vectors.append({
            "id": product["id"],
            "values": embedding,
            "metadata": {
                "naam": product["naam"],
                "categorie": product["categorie"],
                "prijs": product["prijs"],
                "voorraad": product["voorraad"]
            }
        })
    
    # Batch upsert (max 100 per keer)
    index.upsert(vectors=vectors, namespace="nl-producten")

def zoek_producten(query: str, categorie: str = None, max_prijs: float = None, top_k: int = 10):
    """Semantisch zoeken in productcatalogus met filters."""
    query_embedding = openai_client.embeddings.create(
        input=query,
        model="text-embedding-3-small"
    ).data[0].embedding
    
    # Bouw metadata filter op
    filter_dict = {}
    if categorie:
        filter_dict["categorie"] = {"$eq": categorie}
    if max_prijs:
        filter_dict["prijs"] = {"$lte": max_prijs}
    
    resultaten = index.query(
        namespace="nl-producten",
        vector=query_embedding,
        top_k=top_k,
        filter=filter_dict if filter_dict else None,
        include_metadata=True
    )
    
    return resultaten.matches

# Gebruik
producten = [
    {"id": "p001", "naam": "Trek Domane SL6", "beschrijving": "Carbon racefiets voor lange afstanden", 
     "categorie": "fietsen", "prijs": 2499.0, "voorraad": 5},
    {"id": "p002", "naam": "Specialized Rockhopper", "beschrijving": "Aluminum mountainbike voor trails", 
     "categorie": "fietsen", "prijs": 899.0, "voorraad": 12},
]

upsert_producten(producten)

resultaten = zoek_producten("fiets voor lange toertochten op de weg", max_prijs=3000.0)
for match in resultaten:
    print(f"[{match.score:.3f}] {match.metadata['naam']} - €{match.metadata['prijs']}")

Vergelijking: Welke Vector Database Kies Je?

In 2026 is het aanbod groot. Hier is een eerlijk overzicht van de belangrijkste opties:

RAG Architectuur: De Praktijk

Retrieval-Augmented Generation (RAG) is verreweg de meest populaire use case voor vector databases. Het patroon stelt LLMs in staat te antwoorden op basis van je eigen, actuele bedrijfsdata zonder dure fine-tuning.

# Volledig RAG pipeline voorbeeld
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_weaviate import WeaviateVectorStore
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# 1. Document chunking strategie
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", ".", " "]
)

# 2. Embeddings en vector store setup
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = WeaviateVectorStore(
    client=weaviate_client,
    index_name="KennisBank",
    text_key="inhoud",
    embedding=embeddings
)

# 3. Retriever met hybride search
retriever = vectorstore.as_retriever(
    search_type="hybrid",      # Combineert BM25 + vector search
    search_kwargs={
        "k": 5,
        "alpha": 0.7           # 70% vector, 30% keyword
    }
)

# 4. RAG prompt template
rag_prompt = ChatPromptTemplate.from_template("""
Je bent een behulpzame assistent die vragen beantwoordt op basis van de 
beschikbare bedrijfsdocumentatie. Geef altijd een bronvermelding.

Context:
{context}

Vraag: {question}

Beantwoord de vraag uitsluitend op basis van de bovenstaande context.
Indien het antwoord niet in de context staat, zeg dit dan eerlijk.
Verwijs altijd naar de relevante documenten.
""")

# 5. Bouw de RAG chain
llm = ChatOpenAI(model="gpt-4o", temperature=0)

def format_docs(docs):
    return "\n\n".join([
        f"[Bron: {doc.metadata.get('titel', 'Onbekend')}]\n{doc.page_content}" 
        for doc in docs
    ])

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# Gebruik
antwoord = rag_chain.invoke("Hoeveel vakantiedagen heb ik als nieuwe medewerker?")
print(antwoord)

Best Practices voor Productie

Vector databases in productie brengen specifieke uitdagingen met zich mee. Hier zijn de lessen die we hebben geleerd van enterprise implementaties:

Index Configuratie Optimalisatie

-- pgvector: Optimale HNSW configuratie voor productie
-- m: aantal connecties per node (hogere = beter recall, meer geheugen)
-- ef_construction

    


    

      
         Alle blogs