Wat is een Embedding? Vectoren voor Betekenis, Uitgelegd (2026)

Voorkennis & Setup

U heeft basiskennis Python nodig (functies, virtuele omgevingen, pip), het vermogen om een HTTP-aanroep te doen, en een API-sleutel voor OpenAI of Azure OpenAI. NumPy voor de wiskunde.

python -m venv .venv
source .venv/bin/activate     # Windows: .venv\Scripts\activate
pip install openai sentence-transformers numpy

Zet OPENAI_API_KEY als omgevingsvariabele. Haal er één op platform.openai.com/api-keys, of gebruik Azure OpenAI in EU-regio voor productie.

Waarom embeddings bestaan (het verhaal)

Vóór 2013 begrepen computers geen betekenis. Ze begrepen exacte strings. "De kat zat op de mat" en "Een poes rustte op het kleed" zagen er volledig ongerelateerd uit, ook al betekenen ze hetzelfde. Zoekmachines werkten op trefwoordenmatching: typ "retour" en u vond alleen documenten met letterlijk het woord "retour."

• 2013 — word2vec (Mikolov et al., Google): toonde aan dat woorden konden worden afgebeeld op vectoren waarbij vergelijkbare woorden clusteren. De beroemde demo: koning − man + vrouw ≈ koningin.
• 2018 — BERT (Devlin et al., Google): contextuele embeddings. De betekenis van "bank" hing nu af van of u sprak over een rivier of een financiële instelling.
• 2019 — Sentence-BERT (Reimers & Gurevych): maakte het efficiënt om volledige zinnen te embedden, niet alleen woorden.
• 2024–2026: OpenAI text-embedding-3, Voyage AI, Cohere Embed v3, BGE-M3 — instructie-getrainde, meertalige, multimodale embeddings werden de standaard.

Tegen 2026 zijn embeddings de basis van elke serieuze LLM-toepassing. Elk RAG-systeem berekent ze. Elke aanbevelingsmotor gebruikt ze. Elke semantische zoekopdracht bouwt erop.

Het mentale model

Vijf termen die u moet internaliseren:

Anatomie: volg één zin

Laten we één zin door een embedding-model volgen. Invoer: "Wat is ons retourbeleid?"

Niveau 1 — Speelgoedvoorbeeld

Het kleinste nuttige embedding-voorbeeld. Twaalf regels. In-memory. Embed drie zinnen, bereken cosinus-gelijkenis, zie welke twee het meest op elkaar lijken.

import os, numpy as np
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def embed(text):
    return np.array(client.embeddings.create(input=text, model="text-embedding-3-small").data[0].embedding)

a = embed("Ons retourbeleid staat retouren toe binnen 30 dagen.")
b = embed("Klanten mogen artikelen retourneren in de eerste maand.")
c = embed("Verzending is gratis voor bestellingen boven 50 euro.")

# Cosinus-gelijkenis (vectoren zijn al genormaliseerd door OpenAI, dus dot product = cosinus)
print(f"a vs b: {a @ b:.3f}")
print(f"a vs c: {a @ c:.3f}")

Niveau 2 — Realistisch

Niveau 1 heeft drie problemen voor echt gebruik: (a) elke herstart betaalt opnieuw de embedding-rekening, (b) één-voor-één aanroepen zijn traag, (c) geen foutafhandeling. Niveau 2 lost alle drie op met batching, caching en model-versionering.

import os, json, hashlib, numpy as np
from pathlib import Path
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
CACHE = Path("./embeddings_cache.jsonl")
MODEL = "text-embedding-3-small"

def _key(text: str) -> str:
    return hashlib.sha256(f"{MODEL}::{text}".encode()).hexdigest()

cache: dict[str, list[float]] = {}
if CACHE.exists():
    for line in CACHE.read_text().splitlines():
        row = json.loads(line)
        cache[row["key"]] = row["vec"]

def embed_many(texts: list[str]) -> np.ndarray:
    """Embed een batch. Cachet via tekst+model hash."""
    missing = [t for t in texts if _key(t) not in cache]
    if missing:
        for i in range(0, len(missing), 2048):
            batch = missing[i:i+2048]
            resp = client.embeddings.create(input=batch, model=MODEL)
            with CACHE.open("a") as f:
                for text, item in zip(batch, resp.data):
                    cache[_key(text)] = item.embedding
                    f.write(json.dumps({"key": _key(text), "vec": item.embedding}) + "\n")
    return np.array([cache[_key(t)] for t in texts])

Niveau 3 — Productiepatroon

In productie gaan embeddings door een speciale service met retries, observability, en een echte cache-backend (Redis of pgvector, geen JSON-bestanden). Schets:

# embeddings/service.py
from dataclasses import dataclass
from typing import Sequence
import hashlib, logging, time
from tenacity import retry, stop_after_attempt, wait_exponential

class EmbeddingService:
    def __init__(self, client, cache, model: str = "text-embedding-3-small", batch_size: int = 1024):
        self.client = client
        self.cache = cache
        self.model = model
        self.batch_size = batch_size
        self.log = logging.getLogger("embeddings")

    def _key(self, text: str) -> str:
        return hashlib.sha256(f"{self.model}::{text}".encode()).hexdigest()

    @retry(stop=stop_after_attempt(3), wait=wait_exponential(min=1, max=8))
    def _call_api(self, batch: list[str]) -> list[list[float]]:
        resp = self.client.embeddings.create(input=batch, model=self.model)
        return [d.embedding for d in resp.data]

    def embed(self, texts: Sequence[str], *, trace_id: str = "") -> list[dict]:
        # Cache check, batch missing, log hit-rate + latency
        ...

Acht valkuilen (productielessen)

Embedding-modellen vergelijken

Kosten & Prestaties

Embeddings zijn het goedkoopste onderdeel van elk RAG-systeem — totdat ze het niet zijn. De kosten worden gedomineerd door hoeveel tokens u embed, niet door welk model.

Latency: een enkele OpenAI embedding-aanroep duurt 50–100ms; een batch van 1.000 duurt ~500ms (10× sneller per item). Self-hosted BGE-M3 op een moderne GPU doet ~20.000 zinnen/seconde.

Verder gaan

Geselecteerde bronnen

• Mikolov et al. (2013) — word2vec paper
• Reimers & Gurevych (2019) — Sentence-BERT
• OpenAI embeddings documentatie
• MTEB leaderboard
• sentence-transformers documentatie
• Cohere — What are embeddings?

Zelfcheck: heeft u het geleerd?

def search(query, docs):
    q_vec = embed(query)
    scores = [np.dot(q_vec, embed(d)) for d in docs]
    return sorted(zip(docs, scores), key=lambda x: -x[1])[:5]

Veelgestelde vragen