# Embeddings routeren en budgetteren via de LLM-gateway

[Naar de inhoud](#lm-inhoud)Netwerk/NL[EN](/en/)[Hubhub.llmnet.nlModellen vergelijken op taak, taal, kosten en licentie.](https://hub.llmnet.nl/)[Communitycommunity.llmnet.nlPrompttechnieken, patronen en systeemprompts.](https://community.llmnet.nl/)[APIapi.llmnet.nlLLM's robuust in software: rate limits, routing, structured output.](https://api.llmnet.nl/)[Consultancyconsultancy.llmnet.nlAI invoeren in een organisatie, van pilot tot productie.](https://consultancy.llmnet.nl/)[Nieuwsnieuws.llmnet.nlOntwikkelingen in AI, geduid voor Nederland.](https://nieuws.llmnet.nl/)[Benchmarkbenchmark.llmnet.nlZelf meten wat AI-kwaliteit is, voor jouw taken.](https://benchmark.llmnet.nl/)[Vacaturesvacatures.llmnet.nlAI-rollen, salarissen en carrièrepaden in Nederland.](https://vacatures.llmnet.nl/)[Lerenleren.llmnet.nlAI-concepten in gewoon Nederlands, van beginner tot bouwer.](https://leren.llmnet.nl/)[Gidsgids.llmnet.nlAI privé draaien op eigen Mac, pc, NAS of thuisserver.](https://gids.llmnet.nl/)[Directorydirectory.llmnet.nlHet AI-ecosysteem in kaart: tools, modellen, bedrijven.](https://directory.llmnet.nl/)[Radarradar.llmnet.nlSignalen uit X, onderzoek en communities voor indie developers.](https://radar.llmnet.nl/)[llmnet.nl — hoofdsite](https://llmnet.nl/)[](https://x.com/intent/post?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren&text=Embeddings%20routeren%20en%20budgetteren%20via%20de%20LLM-gateway)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren)[](https://www.reddit.com/submit?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren&title=Embeddings%20routeren%20en%20budgetteren%20via%20de%20LLM-gateway)[](#)[](https://x.com/intent/post?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren&text=Embeddings%20routeren%20en%20budgetteren%20via%20de%20LLM-gateway)[](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren)[](https://www.reddit.com/submit?url=https%3A%2F%2Fapi.llmnet.nl%2Fretrieval-verkeer-door-de-gateway-embeddings-routeren-en-budgetteren&title=Embeddings%20routeren%20en%20budgetteren%20via%20de%20LLM-gateway)[](#)

 
# Retrieval-verkeer door de gateway: embeddings routeren en budgetteren

 Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini)

 Veel productie-architecturen routeren uitsluitend chat- en generatietaken via een centrale gateway. Retrieval-verkeer — zoals het aanmaken van vectoren via een embeddings-API voor documentindexering en zoekvragen — wordt daarbij vaak rechtstreeks vanuit applicatielagen aangeroepen. Dit zorgt voor een blinde vlek: vector-API's kennen eigen rate limits, provider-storingen en onvoorspelbare kostenpieken. Wie betrouwbare RAG-systemen wil bouwen, moet retrieval-verkeer als volwaardig API-verkeer behandelen.

 In deze gids onderzoeken we hoe je embeddings-aanroepen integreert in je centrale gateway-architectuur. We kijken naar het faalgedrag bij bulk- versus realtimeverkeer, slimme routeringsstrategieën over provider-pools heen, budgetbewaking per gebruiker en de bescherming van vector-integriteit. Als startpunt helpt het om te begrijpen hoe je [semantisch zoeken bouwt met een embeddings-API](https://api.llmnet.nl/semantisch-zoeken), zodat je de datastroom van tekst naar vector precies kunt plaatsen.

 
## Het anatomieverschil: generatie- versus embeddings-verkeer

 Het verkeersprofiel van embeddings-endpoints wijkt fundamenteel af van generatieve chat-endpoints. Waar chatverzoeken gekenmerkt worden door langdurige streams, asymmetrische I/O (weinig input-tokens, veel output-tokens) en hoge latency per token, vertonen embeddings-verzoeken het tegenovergestelde gedrag. Ze kennen geen streaming, leveren een strikt deterministische float-array af en vereisen snelle responsen bij individuele zoekvragen, maar veroorzaken extreme piekbelastingen bij batch-indexering.

 Wanneer een batch van 10.000 documentfragmenten wordt geïndexeerd, vuurt de applicatie miljoenen tokens in enkele seconden af. Als dit verkeer ongecontroleerd over dezelfde API-sleutels loopt als een realtime zoekbalk, leidt dit onvermijdelijk tot HTTP 429 Too Many Requests-fouten voor eindgebruikers. De gateway moet dit onderscheid kunnen maken op basis van headers, paden of payload-grootte.

 
 
 
 
 Eigenschap | 
 Generatieve calls (Chat/Completion) | 
 Retrieval calls (Embeddings) | 
 

 
 
 
 Verkeerspatroon | 
 Continu, interactief, relatief stabiel | 
 Bimodaal: snelle enkelvoudige queries vs. enorme bulkaanroepen | 
 

 
 I/O Verhouding | 
 Input variabel, output honderden tot duizenden tokens | 
 Input groot (tekstblokken), output vaste vectorlengte (bijv. 1536 floats) | 
 

 
 Latency-gevoeligheid | 
 Time-to-first-token kritiek, totale duur mag seconden duren | 
 Query-embedding moet onder 50ms blijven; bulk mag asynchroon | 
 

 
 Fallback-mogelijkheid | 
 Vrij uitwisselbaar tussen providers (bijv. Claude naar GPT) | 
 Niet uitwisselbaar zonder compatibele vectorruimte of herindexering | 
 

 
 
 

 
## Routering van embeddings: de valkuil van heterogene vectoren

 Bij generatieve LLM's is failover relatief eenvoudig: valt Provider A uit, dan stuurt de gateway de prompt door naar een equivalent model bij Provider B. Bij embeddings is dit levensgevaarlijk. Een vector gegenereerd door model X kan niet rechtstreeks vergeleken worden (via cosine similarity of dot product) met een vector van model Y, zelfs niet als beide modellen toevallig dezelfde dimensiegrootte (zoals 1536 of 3072) hebben. De semantische ruimtes zijn incompatibel.

 Routering van retrieval-verkeer in de gateway vereist daarom strikte routeringsregels. Fallback mag alleen plaatsvinden tussen exact dezelfde onderliggende modelgewichten. Een handige methode is het inzetten van [de kracht van een LLM API-aggregator](https://api.llmnet.nl/aggregator-uitleg) om abstractielagen in te richten, mits je garandeert dat de aggregatielaag exact dezelfde modelversie levert via alternatieve endpoints (bijvoorbeeld OpenAI direct versus Azure OpenAI Service).

 De gateway implementeert hiervoor een Model Family Group. In plaats van een willekeurige fallback definieert de gateway specifieke replica-endpoints:

 // Voorbeeld gateway route-mapping voor embeddings
{
 "virtual_model": "text-embedding-3-small",
 "strategy": "priority_with_failover",
 "targets": [
 {
 "provider": "openai_direct",
 "endpoint": "https://api.openai.com/v1/embeddings",
 "model": "text-embedding-3-small",
 "priority": 1,
 "timeout_ms": 350
 },
 {
 "provider": "azure_eastus",
 "endpoint": "https://company-eastus.openai.azure.com/openai/deployments/text-embedding-3-small/embeddings?api-version=2024-02-01",
 "model": "text-embedding-3-small",
 "priority": 2,
 "timeout_ms": 500
 }
 ]
}

 Als je zelf de infrastructuur beheert, raadpleeg dan de principes over hoe je een [zelfgehoste LLM-gateway opzet](https://api.llmnet.nl/llm-gateway-zelf-hosten) met failover-regels en health checks om latency-pieken tijdig te detecteren.

 
## Doorvoerbewaking: Token Buckets voor bulk versus realtime

 Om te voorkomen dat zware indexeertaken de interactieve zoekervaring van gebruikers verstoppen, moet de gateway onderscheid maken tussen interactieve queries (laag volume, hoge prioriteit) en batch-ingestie (hoog volume, lage prioriteit). Dit lossen we op met gescheiden Token Bucket-wachtrijen op de gateway.

 Wanneer een verzoek binnenkomt, inspecteert de gateway de header X-Traffic-Type: interactive of X-Traffic-Type: background_ingest. Beide stromen putten uit een eigen rate-limit quotum:

 
 
- Interactive Queue (Zoekopdrachten): Krijgt 70% van de gegarandeerde provider-capaciteit (bijvoorbeeld 700.000 TPM). Verzoeken passeren direct en falen snel als het platform overbelast is, met directe notificatie aan de client.
 
- Bulk Queue (Document Parsing & Indexering): Krijgt maximaal 30% van de capaciteit in rustige periodes, maar kan dynamisch opschalen naar ongebruikte tokens zolang de interactieve latency onder een drempelwaarde (bijv. 40 ms) blijft. Wordt de interactieve bucket aangesproken, dan vertraagt de gateway de bulk queue via dynamische throttling (HTTP 429 met Retry-After headers).
 

 Hierdoor voorkom je dat een ontwikkelaar die lokaal een dataset opnieuw indexeert, de productiewebsite platlegt met rate limit-fouten.

 
## Budgettering en kostenallocatie per tenant voor vectorverkeer

 Hoewel embeddings per token goedkoper zijn dan generatieve tokens, kunnen ongecontroleerde loops en herindexeringen tienduizenden euro's verspillen. Een documentcollectie van 500.000 PDF's die wekelijks opnieuw gevectoriseerd wordt zonder chunk-caching, tikt hard aan.

 De gateway fungeert als boekhouder en poortwachter. Elk inkomend embedding-verzoek moet voorzien zijn van metadata (zoals tenant_id, project_id of environment). De gateway telt de input-tokens vooraf (met behulp van een lokale tokenizer zoals tiktoken) en controleert direct of het maandelijkse budget van de betreffende tenant niet is overschreden.

 Voor een gedetailleerd financieel model over hoe je dergelijk verbruik doorberekent naar klanten, bekijk je het artikel over hoe je [API-kosten per eindgebruiker toerekent in een SaaS-product](https://api.llmnet.nl/kosten-per-gebruiker-toerekenen). Door drempelwaarden in te stellen op 80%, 95% en 100% van het budget, kan de gateway niet-kritieke indexeertaken automatisch pauzeren terwijl interactieve zoekopdrachten voor bestaande data operationeel blijven.

 
## Beveiliging, sleutelisolatie en data-integriteit

 Het indexeren van bedrijfsdocumenten brengt grote privacy- en beveiligingsrisico's met zich mee. Gevoelige data (PII, financiële rapportages, interne communicatie) stroomt in platte tekst door de gateway naar de embedding-provider. Daarom moet de gateway strikt sleutelbeheer en zero data retention afdwingen.

 Ontwikkelaars en microservices mogen nooit rechtstreeks beschikken over provider-sleutels (zoals OpenAI- of Cohere-API-keys). Ze communiceren uitsluitend met de gateway via kortlevende interne API-tokens met strikte scopes (bijvoorbeeld embeddings:write of embeddings:read-only). Raadpleeg de richtlijnen over hoe je [API-sleutels voor LLM's veilig beheert](https://api.llmnet.nl/api-sleutels-veilig-beheren) om lekken via omgevingsvariabelen of build-pipelines te voorkomen.

 Daarnaast moet de gateway payload-hashing toepassen. Door een SHA-256 hash van het invoerfragment op te slaan gekoppeld aan de gegenereerde vector, kan de gateway een deterministische Exact Embedding Cache bijhouden. Als dezelfde alinea opnieuw ter indexering wordt aangeboden, retourneert de gateway direct de gecachete vector zonder een externe API-aanroep te doen. Dit bespaart tot wel 40% op bulkindexeringskosten.

 
## Vector-drift, indexonderhoud en kwaliteitsborging

 Een vaak over het hoofd geziene faalmodus is vector-drift: een leverancier past een embedding-model aan (of update stilletjes tokenizer-artefacten), waardoor nieuw gegenereerde vectoren langzaam afwijken van vectoren die zes maanden eerder in de database zijn opgeslagen. Het gevolg is dat semantische zoekopdrachten plotseling minder relevante documenten opleveren, zonder dat er een foutmelding verschijnt.

 De gateway kan dit detecteren door periodiek een Canary Benchmark Suite af te vuren. Dit is een vaste set van 50 controlezinnen waarvan de resulterende vectoren worden vergeleken met een gouden referentievector via cosine distance. Wijkt de score af met meer dan een minieme tolerantiedrempel (bijvoorbeeld 1e-5), dan slaat de gateway alarm en blokkeert hij automatische indexeringsverzoeken.

 Voor structureel beheer van je vectorstore lees je de gids over hoe je [een vector-index onderhoudt en embeddings bijwerkt](https://api.llmnet.nl/vector-index-onderhoud). Kwaliteit in RAG-pijplijnen draait immers niet alleen om retrieval-snelheid, maar vooral om inhoudelijke betrouwbaarheid; zie ook het belang van [AI-antwoorden factchecken en verifiëren](https://gids.llmnet.nl/ai-antwoorden-factchecken) wanneer retrieval-fouten leiden tot hallucinaties in de uiteindelijke generatiestap.

 
## Architectuurpatroon: de gateway-implementatie in code

 Hieronder staat een robuust pseudocodepatroon voor een gateway-middleware die embeddings-verkeer afhandelt. Het script valideert het budget, controleert de lokale hash-cache, kiest het primaire of secundaire replica-endpoint en handelt timeouts netjes af zonder dat de client crasht.

 // TypeScript / Node.js Gateway Middleware Voorbeeld
import { Request, Response, NextFunction } from 'express';
import { createHash } from 'crypto';

interface EmbeddingTarget {
 name: string;
 url: string;
 apiKey: string;
 timeoutMs: number;
}

export async function handleEmbeddingRoute(req: Request, res: Response) {
 const { input, tenant_id, traffic_type } = req.body;

 if (!input || !tenant_id) {
 return res.status(400).json({ error: 'Missing input text or tenant_id' });
 }

 // 1. Controleer tenant budget
 const hasBudget = await checkTenantBudget(tenant_id, input);
 if (!hasBudget) {
 return res.status(429).json({ 
 error: 'Budget exceeded for tenant',
 tenant_id,
 retry_after_billing_cycle: true 
 });
 }

 // 2. Hash-gebaseerde cache check (SHA-256)
 const inputHash = createHash('sha256').update(input).digest('hex');
 const cachedVector = await redisClient.get(`emb:${inputHash}`);
 if (cachedVector) {
 return res.json({ 
 data: [{ embedding: JSON.parse(cachedVector) }], 
 source: 'gateway_cache' 
 });
 }

 // 3. Fallback endpoints definiëren (identieke semantische ruimte)
 const targets: EmbeddingTarget[] = [
 {
 name: 'openai-primary',
 url: 'https://api.openai.com/v1/embeddings',
 apiKey: process.env.OPENAI_API_KEY!,
 timeoutMs: 800
 },
 {
 name: 'azure-secondary',
 url: 'https://gateway-eu.openai.azure.com/openai/deployments/text-embedding-3-small/embeddings?api-version=2024-02-01',
 apiKey: process.env.AZURE_API_KEY!,
 timeoutMs: 1200
 }
 ];

 // 4. Uitvoeren met failover en strikte timeout
 for (const target of targets) {
 try {
 const controller = new AbortController();
 const timeout = setTimeout(() => controller.abort(), target.timeoutMs);

 const response = await fetch(target.url, {
 method: 'POST',
 headers: {
 'Content-Type': 'application/json',
 'Authorization': `Bearer ${target.apiKey}`
 },
 body: JSON.stringify({
 model: 'text-embedding-3-small',
 input: input
 }),
 signal: controller.signal
 });

 clearTimeout(timeout);

 if (response.ok) {
 const payload = await response.json();
 const vector = payload.data[0].embedding;

 // Asynchroon cachen voor toekomstige queries
 await redisClient.setex(`emb:${inputHash}`, 86400 * 7, JSON.stringify(vector));
 await trackTenantUsage(tenant_id, payload.usage.total_tokens);

 return res.json({
 data: payload.data,
 source: target.name,
 usage: payload.usage
 });
 }
 } catch (err) {
 console.warn(`Target ${target.name} gefaald of timed-out, probeer volgende target...`);
 }
 }

 return res.status(502).json({ 
 error: 'All embedding upstream replicas failed or timed out.' 
 });
}

 
## Wat kost een robuuste embeddings-gateway?

 Het toevoegen van een gateway-laag tussen je applicatie en de vector-endpoints brengt afwegingen met zich mee. We zetten de trade-offs op een rij:

 
 
- Netwerklatency: Een interne gateway voegt gemiddeld 2 tot 8 milliseconden toe aan elke round-trip (tokenizatie, header-inspectie, caching-lookup). Voor realtime zoekbalken is dit verwaarloosbaar vergeleken met de externe netwerklatency van 80-250 ms naar de API-provider.
 
- Operationele complexiteit: Je moet een Redis- of memcached-instantie onderhouden voor de hash-cache en een persistent databeheer voor rate limits en tenant-budgetten (bijv. Postgres of Redis Token Buckets).
 
- Scherpe kostenbesparing: Door exacte caching van alinea's en het dedupliceren van batch-verzoeken bespaar je in praktijkopstellingen aanzienlijk op API-facturen, terwijl de continuïteit van de interactieve zoekfunctie gegarandeerd blijft tijdens grootschalige herindexeringen.
 

 
## Conclusie

 Door retrieval- en embeddings-verkeer expliciet onder te brengen in de centrale LLM-gateway, voorkom je dat zware indexeringsprocessen je interactieve zoekfuncties verstoren. Met gescheiden token buckets, strikte fallback-regels tussen identieke modelversies, tenant-gebaseerde budgetkappen en automatische integriteitscontroles transformeer je een kwetsbaar RAG-prototype tot een betrouwbaar en kostenbeheersbaar productiesysteem.