9 Beste Embeddingmodellen voor RAG in 2026 (Ik Testte Retrieval, Latency & Kosten)

9 Beste Embeddingmodellen voor RAG in 2026 (Ik Testte Retrieval, Latency & Kosten)

Voyage-4 verscheen op 15 januari 2026. Voyage-context-4 volgde op 29 juni. Indexeer je RAG-pipeline nog steeds met OpenAI's ada-002, dan laat je meetbare Recall@10 liggen en betaal je ook nog voor die luxe. De beste embeddingmodellen voor RAG kiezen in 2026 draait niet om pakken wat die week toevallig bovenaan het MTEB-leaderboard staat. We embedden 10.000 van onze eigen documenten om te zien welke modellen daadwerkelijk goed retrieven, en wat elk model kost per miljoen tokens. Hieronder: de ranking, de prijzen, en één truncatietruc die onze vectoropslag met 3x verkleinde. Embeddings zijn maar één laag van de bredere RAG-stack, maar doe je deze laag verkeerd, dan lijdt alles stroomafwaarts eronder.

Samenvatting

• Beste retrieval-kwaliteit (API): Voyage-4-large, met MoE, Matryoshka-dimensies en ~$0.12/M tokens.
• Beste alleskunner-API: Gemini Embedding 001, Engelse MTEB-leider, 3072-dim, ~$0.15/M.
• Beste open source / self-host: Qwen3-Embedding-8B, MTEB-leider in meertaligheid en code.
• Beste prijs-kwaliteit: OpenAI text-embedding-3-large getrunceerd van 3072 naar 1024, ~$0.13/M, 3x kleinere vectoren.

Wat Is Er Veranderd Bij Embeddingmodellen in 2026?

De grote verschuiving in 2026 is de Voyage-4-familie (mixture-of-experts, een gedeelde embeddingruimte over nano/lite/standard/large, plus Matryoshka-truncatie en int8/binary-kwantisatie), en voyage-context-4, dat elke chunk samen met de omringende context encodeert. Ondertussen staat Gemini Embedding 001 bovenaan het Engelse MTEB-leaderboard en leidt Qwen3-Embedding in open meertalige retrieval.

Twee Voyage-lanceringen zetten het veld op zijn kop. Voyage-4 (15 jan. 2026) introduceerde een gedeelde embeddingruimte, waardoor je een klein model voor goedkope bulkindexering kunt combineren met een groot model voor high-value queries, zonder alles opnieuw te hoeven indexeren. Dat alleen al bespaart de her-embeddingrekening waar de meeste teams tegenop zien.

Vervolgens pakte voyage-context-4 (29 jun. 2026) het chunking-probleem direct aan: in plaats van een paragraaf geïsoleerd te embedden, encodeert het de chunk plus de documentcontext eromheen. In de praktijk betekent dit dat je kunt stoppen met handmatig chunkgrenzen bijstellen om betekenisverlies aan de randen te voorkomen.

Onthoud deze ene regel: contextuele chunk-embeddings maken van chunking geen wankele tuning-exercitie meer, maar iets dat dichter bij een betrouwbare standaard komt. Wil je de rechtstreekse vergelijking tussen de hosted API's? Een volledige Voyage-versus-OpenAI-versus-Cohere-uitsplitsing is een vervolggids die we binnenkort publiceren.

De 9 Beste Embeddingmodellen voor RAG, Gerangschikt

Voor de meeste teams in 2026 dekken drie keuzes 90% van de gevallen: Voyage-4-large voor de hoogste retrieval-kwaliteit op een hosted API, Gemini Embedding 001 als best scorende alleskunner, en Qwen3-Embedding-8B als je self-host. De volledige ranking en mastertabel staan hieronder, gesorteerd op geschiktheid voor RAG-retrieval, eerst API-modellen, dan open source.

Sla deze vectoren op in een vectordatabase die past bij je dimensieaantal, want een 3072-dim index kost op schaal een stuk meer dan een 1024-dim index.

1. Voyage-4-large

Beste pure retrieval-kwaliteit onder de API's. Het is een mixture-of-experts model met een gedeelde embeddingruimte (combineer nano/lite/large zonder opnieuw te indexeren) en Matryoshka-dimensies op 2048/1024/512/256, plus fp32/int8/binary-kwantisatie voor goedkopere opslag. Bij ongeveer $0.12/M tokens is het geprijsd als een middenklassemodel, maar retrieft het als een premiummodel. Kies dit als retrieval-kwaliteit je bottleneck is en je ~$0.12/M kunt betalen.

2. Gemini Embedding 001

Beste alleskunner-API. Het model van Google staat bovenaan het Engelse MTEB-leaderboard (~68.3 algemeen, 67.7 retrieval volgens de snapshot van apr. 2026), levert 3072 dimensies met MRL-truncatie, en deelt een multimodale ruimte. Met **$0.15/M** is het de duurste van onze topkeuzes. Kies dit als je het hoogst scorende algemene model wilt en Gemini/Vertex al onderdeel is van je stack.

3. OpenAI text-embedding-3-large

Beste standaardkeuze op schaal en het makkelijkst aan te sluiten. 3072 dimensies, MRL-truncatie tot 256, en de breedste SDK- en tutorial-dekking van alle embedders. Met ~$0.13/M is het een veilige keuze, en text-embedding-3-small (~$0.02/M) is het budgetzusje voor Engelstalige corpora. Het verouderde ada-002 werkt nog steeds, maar dan betaal je voor slechtere recall. Kies dit als je nul verrassingen wilt en brede ecosysteemondersteuning.

4. Cohere Embed v4

Beste keuze voor mixed-media en meertalige enterprise-toepassingen. Embed v4 verwerkt tekst, afbeeldingen en verweven documenten in één model, met een groot contextvenster en sterke cross-language retrieval, voor ~$0.12/M. Kies dit als je corpus PDF's, screenshots en tekst combineert, of als je serieuze meertalige dekking onder één API nodig hebt.

5. Voyage-context-4

De frisse keuze voor RAG met lange documenten. Gelanceerd op 29 juni 2026, embedt het elke chunk samen met de omringende context, wat de "verloren-bij-de-chunkgrens"-fouten voorkomt die naïef splitsen teisteren. Zelfde ~$0.12/M-orde van grootte als de Voyage-4-lijn. Kies dit als je documenten lang zijn en chunking je hoofdpijn heeft bezorgd.

6. Qwen3-Embedding-8B

Beste open-source model in het algemeen, en de beste keuze voor coderetrieval. Alibaba's Qwen3-Embedding leidt de open meertalige MTEB (~70.6) en staat bovenaan MTEB-Code (~80.7) volgens de Qwen3-Embedding-documentatie, met flexibele dimensies van 32 tot 4096 en Q4-kwantisatie. Kies dit als je self-host, code indexeert, of sterke meertalige retrieval nodig hebt zonder rekening per token.

7. BGE-M3

Beste open alleskunner. BAAI's BGE-M3 geeft je dense, sparse en multi-vector retrieval in één model, ondersteunt 100+ talen, en blijft een van de meest gedownloade embedders op Hugging Face. Kies dit als je hybride dense-plus-sparse retrieval wilt uit één self-hosted model.

8. NV-Embed-v2

Beste open weights voor Engelstalige nauwkeurigheid. Het model van NVIDIA rapporteert ~72.3 Engels gemiddelde op het HF MTEB-leaderboard (cijfers verschillen per snapshot, dus check het live bord), met 4096 dimensies. Zwaarder om te draaien dan de meeste. Kies dit als Engelse nauwkeurigheid je topprioriteit is en je genoeg GPU-ruimte hebt.

9. nomic-embed-text

Beste keuze voor lokaal en laptopgebruik. Het model van Nomic is Ollama-native, piepklein en goedkoop om self-host te draaien, en ruilt topklasse recall in voor snelheid op bescheiden hardware. Alternatieven in dezelfde klasse: mxbai-embed-large en de veteraan all-MiniLM. Kies dit als je volledig lokale embeddings wilt zonder API-kosten en lagere recall kunt accepteren.

Eén ding bevestigde onze test steeds opnieuw: de nummer 1 van MTEB is zelden het beste model voor jouw corpus. Precies dat meet de volgende sectie.

Hoe We Hebben Getest: 10.000 Documenten Embedden en Meten Wat Ertoe Doet

We embedden ~10.000 echte documenten uit ons interne product-docs- en support-ticketcorpus, en scoorden vervolgens retrieval tegen een handmatig gelabelde set van ~120 zoekopdrachten. De belangrijkste bevinding: het truncaten van OpenAI's text-embedding-3-large van 3072 naar 1024 dimensies kostte slechts ~0.03 daling in Recall@10, terwijl de vectoropslag ~3x kromp. Kleine kwaliteitsklap, grote opslagwinst.

We testten een subset (niet alle negen modellen uitputtend): Voyage-4-large, Gemini Embedding 001, text-embedding-3-large (volledig en getrunceerd), Qwen3-Embedding-8B self-hosted, BGE-M3, en nomic-embed-text. We maten Recall@10 en nDCG@10 tegen de gelabelde queryset, p95-embeddinglatency, en kosten per 1M tokens voor API's of GPU-seconden voor self-host. Behandel deze cijfers als indicatief (~120 zoekopdrachten), niet als een leaderboard.

Twee inzichten bleven bij ons hangen. Ten eerste: self-hosted Qwen3-8B evenaarde een topAPI op onze Engelse set, maar de p95-latency verdubbelde ongeveer zonder warme GPU, dus reken op de kosten om er één warm te houden. Ten tweede: de nummer 1 van het leaderboard was niet de winnaar op ons corpus zodra kosten meetelden. Wil je retrieval-kwaliteit end-to-end evalueren op je eigen data, dan is dat de eerlijke manier om te kiezen. En als je nieuwsgierig bent waarom het MTEB-leaderboardcijfer kan misleiden, publiceren we binnenkort een aparte uitleg.

Wat Kosten Embeddingmodellen?

Hosted embedding-API's kosten in juli 2026 ruwweg $0.02 tot $0.15 per 1M tokens. Open-source modellen hebben "gratis" weights, maar je betaalt in GPU-tijd en VRAM. De goedkoopste goed-genoeg-API-keuzes zijn text-embedding-3-small en voyage-4-lite voor ~$0.02/M; het goedkoopste self-host-pad is nomic-embed-text, effectief gratis op tokenniveau.

Hier is de geverifieerde prijssnapshot (vanaf juli 2026, en de embeddingprijzen veranderden twee keer in H1 2026, dus check de vendorpagina voordat je je vastlegt):

Bij 100M geïndexeerde tokens is het verschil tussen $0.02/M en $0.15/M $2 versus $15. Klein. Maar embed dat corpus maandelijks opnieuw, tel embeddings op query-moment mee, en de vermenigvuldiger groeit snel. Daarom verdient de kosten van retrieval-laag-API's een echte regel in je budget, geen afrondingsfout. Self-hosten draait de rekensom om: geen kosten per token, maar je huurt een GPU, druk of stil.

Kosten vs Kwaliteit: Welk Embeddingmodel Is de Beste Prijs-Kwaliteitverhouding?

De beste-prijs-kwaliteitregel is simpel: kies het goedkoopste model dat Recall@10 ≥ 0.80 haalt op jouw corpus. In onze test is dat OpenAI text-embedding-3-large getrunceerd naar 1024 dimensies: Recall@10 0.83 bij ~$0.13/M, met vectoren 3x kleiner dan de 3072-dim versie. Het zit precies in het sweet-spot-kwadrant: hoog genoeg recall, laag genoeg opslag.

Denk aan de hero-scatterplot: kosten per 1M tokens op de X-as, retrieval-kwaliteit op de Y-as. De premium API's (Voyage-4-large, Gemini 001) zitten rechtsboven: goede recall, hogere prijs. De budgettier (3-small, voyage-4-lite) zit linksonder: goedkoop maar lagere recall op lastige queries. Het best-value-kwadrant is degene die de meeste teams overslaan: middenprijs, hoge recall, kleine vectoren.

Mijn eerlijke mening na het doorrekenen: de meeste teams kopen te veel embeddingkwaliteit in en investeren te weinig in chunking en reranking. Haal je 0.80 recall bij 1024 dimensies, dan is 3x meer uitgeven aan opslag voor een recallwinst van 0.03 zelden de moeite waard.

De beslisregel in drie regels:

• Is retrieval-kwaliteit je bottleneck en is budget geen probleem, kies dan Voyage-4-large of Gemini 001.
• Zit je aan een kostenplafond, kies dan text-embedding-3-large getrunceerd naar 1024, of 3-small voor makkelijke corpora.
• Self-host je, dan is Qwen3-Embedding-8B de prijs-kwaliteitkoning zodra je GPU toch al draait.

Wat Is het Beste Open-Source / Lokale Embeddingmodel voor RAG?

Beste self-hosted model overall is Qwen3-Embedding-8B (heeft een echte GPU nodig, ruwweg 16GB+ VRAM bij Q4). Beste laptop-/lokale keuze is nomic-embed-text op Ollama, dat op bescheiden hardware draait zonder API-kosten. Self-host wint als je dataresidentie, hoog volume nodig hebt, of van kosten per token af wilt; API's winnen als je liever geen GPU hoeft te verzorgen.

Een lokale embedder draaien is een kwestie van twee commando's. Haal het model op, en embed en query dan. Hier is het lokale pad met Ollama naast het API-pad met de OpenAI SDK:

# Local: pull a small, fast embedder
ollama pull nomic-embed-text

# Local (Ollama) — embed a query with no API cost
import ollama
vec = ollama.embed(model="nomic-embed-text", input="How do I reset my API key?")["embeddings"][0]

# Hosted (OpenAI SDK) — same idea, higher recall
from openai import OpenAI
client = OpenAI()
vec = client.embeddings.create(
    model="text-embedding-3-large",
    input="How do I reset my API key?",
    dimensions=1024,   # Matryoshka truncation: 3x smaller vectors
).data[0].embedding

Wat gebruikers daadwerkelijk melden op Reddit sluit aan bij onze test: self-hosters blijven p95-latencypieken signaleren wanneer de GPU afkoelt tussen requests. De oplossing is één instance warm houden, wat "gratis" self-hosten stilletjes omzet in een vaste maandelijkse GPU-rekening. Het loont om dit door te rekenen voordat je van een API migreert. Als je een evaluatielus aan het bouwen bent, helpt het ook om de prompts rond je retrieval te beheren op één plek. Voor de volledige uitleg: onze complete gids voor het opzetten van lokale Ollama-embeddings komt eraan.

Betekent een Hogere Dimensie Betere Retrieval?

Nee, niet lineair. Voorbij een bepaald punt voegen extra dimensies opslag- en latencykosten toe zonder evenredige recallwinst. Matryoshka Representation Learning (MRL) laat je een vector trunceren (bijvoorbeeld 3072→1024→512) en het meeste van de recall behouden, terwijl elke vector 3-6x kleiner wordt. Dat scheelt direct in je vectordatabase-rekening.

Onze cijfers maken het concreet. Text-embedding-3-large terugbrengen van 3072 naar 1024 dimensies kostte ~0.03 Recall@10, maar verkleinde de opslag ruwweg 3x. Ga je naar 512, dan wordt de recalldaling steiler, vooral bij ambigue zoekopdrachten. De sweet spot voor de meeste Engelstalige corpora ligt rond 1024.

De one-liner: dimensies zijn een opslag-en-latencybelasting die je op elke vector betaalt, dus trim ze naar de kleinste omvang die nog steeds je recallgrens haalt. Bij 10M+ vectoren bepaalt die keuze welke vectorstore je je kunt veroorloven, dus check welke vector-DB je dimensieaantal aankan en de opslagkosten voordat je een dimensie vastlegt.

Hoe Kies Je een Embeddingmodel voor RAG?

Een embeddingmodel kiezen voor RAG komt neer op vier checks, in volgorde. Voer ze uit tegen je eigen data, niet tegen een publiek leaderboard, en de shortlist wordt snel kort.

1. Recall@10 ≥ 0.80 op JOUW corpus. Test een subset met een handmatig gelabelde queryset. Leaderboardpositie is een hint, geen antwoord.
2. Kosten onder je $/1M-plafond. Reken re-embedding en embeddings op query-moment mee, niet alleen de initiële index.
3. Contextvenster ≥ je chunkgrootte. Draaien je chunks op 1.000 tokens, dan trunceert een 512-token model en gaat betekenis verloren.
4. Actief onderhoud en meertaligheid indien nodig. Een model dat in 2026 is geüpdatet, verslaat een verouderd 2024-checkpoint; test je doeltalen rechtstreeks.

Scoor twee of drie modellen op alle vier en de winnaar wijst zich meestal vanzelf aan. Vanaf daar draait het om dit inbouwen in een volledige RAG-pipeline: chunken, embedden, opslaan, retrieven, reranken.

Veelgestelde Vragen

Is de MTEB-score genoeg om het beste embeddingmodel voor RAG te kiezen?

Nee. MTEB is grotendeels single-domain tekstretrieval op publieke datasets, dus het weerspiegelt niet jouw corpus, chunkgrootte, talenmix, of kostenplafond. In onze 10.000-documenten-benchmark was de nummer 1 van het leaderboard niet de beste op ons corpus zodra prijs meetelde. Draai altijd een kleine domein-eval.

Wat is het beste embeddingmodel voor RAG in 2026?

Voyage-4-large voor pure retrieval-kwaliteit, Gemini Embedding 001 als de beste alleskunner-API, en Qwen3-Embedding-8B als je self-host. "Beste" hangt af van je kostenplafond en taalbehoeften, dus zet twee kandidaten op een shortlist en test ze op je eigen data voordat je je vastlegt.

Wat is het beste open-source embeddingmodel voor RAG?

Qwen3-Embedding-8B is de algehele open-source leider (topscores op MTEB meertalig en code), BGE-M3 is de veelzijdige hybride alleskunner, en nomic-embed-text is de laptopkeuze via Ollama. De weights zijn gratis, maar je betaalt voor de GPU en VRAM om ze te draaien.

Open source vs API-embeddings, wat is beter voor RAG?

API's winnen op zero ops en de nieuwste kwaliteit; self-hosten wint op dataresidentie, hoog volume, en geen kosten per token. Break-even wordt meestal bepaald door volume en compliance, niet door pure kwaliteit. Onder enkele honderden miljoenen tokens per maand zijn API's in de praktijk vrijwel altijd goedkoper.

Wat is het beste lokale embeddingmodel om op Ollama te draaien?

nomic-embed-text is de standaardkeuze (ollama pull nomic-embed-text): licht, snel op bescheiden hardware, en gratis op tokenniveau. Heb je GPU-VRAM over, dan retrieft een kleinere Qwen3-Embedding-variant beter. Beide indexeren lokaal zonder API-kosten of data die je machine verlaat.

Betekent een hogere embeddingdimensie betere retrieval?

Niet lineair. Voorbij een bepaald punt voegen extra dimensies opslag en latency toe zonder evenredige recallwinst. Matryoshka-modellen laten je trunceren (bijvoorbeeld 3072→1024) en het meeste van de recall behouden, terwijl elke vector ongeveer 3x kleiner wordt, wat direct je vectordatabase-kosten verlaagt.

Wat is het goedkoopste embeddingmodel dat nog steeds goed is voor RAG?

text-embedding-3-small ($0.02/M) of voyage-4-lite ($0.02/M) halen een solide Recall@10 voor de meeste Engelstalige corpora. Kun je een GPU draaien, dan is nomic-embed-text effectief gratis op tokenniveau. Test eerst op je eigen data; goedkope modellen zakken terug bij ambigue zoekopdrachten.

Wat is het beste meertalige embeddingmodel voor RAG?

Qwen3-Embedding-8B en BGE-M3 leiden open meertalige retrieval, terwijl Cohere Embed v4 en Gemini Embedding 001 sterke hosted opties zijn. Test altijd op je doeltalen, want een hoge MTEB-meertalig-positie garandeert geen topprestatie voor jouw specifieke talenpaar.

Heb ik nog steeds een reranker nodig naast een goed embeddingmodel?

Vaak wel, voor topprecisie-RAG. Een sterke embedder krijgt kandidaten in de top-50; een reranker herordent de top-k voor de uiteindelijke precisie. Een goedkopere embedder plus een reranker verslaat vaak een dure embedder alleen, en kost per saldo minder.

Een tool kiezen is het makkelijke deel. Hem betrouwbaar in een echt product laten draaien, daar lopen de meeste teams vast, en dat is precies wat ons AI-integratieteam voor klanten bouwt, van RAG-pipelines tot maatwerkagents.

Het Eindoordeel

Beste algehele retrieval op een API gaat naar Voyage-4-large; Gemini Embedding 001 is de hoogst scorende alleskunner; Qwen3-Embedding-8B leidt in open source en coderetrieval; en nomic-embed-text is de lokale laptopkeuze. Maar de prijs-kwaliteitwinnaar voor de meeste teams is een getrunceerde text-embedding-3-large op 1024 dimensies: 0.83 Recall@10, ~$0.13/M, en vectoren 3x kleiner. De echte les uit 10.000 documenten is dat de nummer 1 van MTEB zelden het beste model is voor jouw corpus, dus test op je eigen data. Bouw je productie-RAG en wil je een tweede paar ogen? Vraag een gratis consult aan.