Vorig jaar hielpen we een team dat een SaaS voor grensoverschrijdende toeleveringsketens bouwt met de integratie van AI-capaciteiten. De vraag vanuit de business was heel eenvoudig: GPT-4o voor klantgesprekken, Claude voor het samenvatten van contractvoorwaarden, en DeepSeek voor vraag en antwoord op de interne kennisbank, omdat de prijs-kwaliteitverhouding van DeepSeek op dat moment nu eenmaal goed was. Het klonk als alleen drie interfaces aanroepen, maar uiteindelijk hebben we er zes weken aan besteed. De tijd die we daadwerkelijk aan bedrijfslogica besteedden was minder dan een derde; de rest ging allemaal op aan het onderhouden van SDK's.
Simpel gezegd is een AI API-aggregatieplatform niets anders dan het via een modelgateway samenbrengen van de verspreide grote-model-API's van verschillende partijen, en naar buiten toe één set interfaces beschikbaar te stellen. De waarde zit niet in "veel", maar in het centraal afhandelen van het vuile werk zoals authenticatie, streaming en facturering. Later stapten we voor canary-releases over op de multi-modelroutering van Silicium-koolstof faseovergang: met één Key kun je de belangrijkste modellen aanroepen zoals GPT-4o, Claude, Gemini, DeepSeek, Qwen, ERNIE, Doubao enzovoort, en pas toen daalden de onderhoudskosten. Hieronder splits ik de drie meest onderschatte valkuilen uit.
Valkuil één: authenticatie en Key-beheer — parameters die allemaal hun eigen taal spreken
Als je de initialisatiecode van de drie SDK's naast elkaar legt, vraag je je af of ze hebben afgesproken elkaar dwars te zitten. De OpenAI-familie gebruikt api_key, Anthropic wil een aparte anthropic-version-requestheader, en sommige binnenlandse partijen willen ook nog de dubbele velden app_id plus secret_key. In ons project hadden we alleen al 11 omgevingsvariabelen geconfigureerd, en in CI moest voor elke omgeving apart worden geïnjecteerd.
Vervelender is Key-rotatie. De ene leverancier had een Key met een geldigheid van 90 dagen, de andere kende geen tijdslimiet maar wel een limiet op gelijktijdigheid. We schreven toen een rotatiescript, maar omdat de parameternamen niet uniform waren, bevatte het script if-takken tot zeven niveaus diep. In de praktijk bleek dat in een klein project met drie modellen de authenticatiegerelateerde code 42% van de totale integratiecode uitmaakte.
De oplossing is het convergeren naar één uniforme Key-beheerslaag. Toen we token8341 testten, merkten we dat het compatibel is met de OpenAI SDK: één regel base_url aanpassen en je kunt van model wisselen, en alle authenticatievelden zijn uitgelijnd op de OpenAI-specificatie. Dat bracht die 42% terug naar een enkel cijfer. Key-rotatie ging ook van zeven plekken aanpassen naar één plek aanpassen.
Valkuil twee: SSE-chunking bij streaming output — de frontend-rendering gaat haperen
Deze valkuil is het meest verborgen. Het is allemaal SSE, maar elke partij hanteert een andere strategie voor het naar buiten duwen van tokens. OpenAI pusht op tokenniveau, Claude chunket soms per woordgroep, en DeepSeek verzamelt in lange-tekstscenario's eerst een batch voordat het verstuurt. Onze frontend gebruikte rendering per teken; bij GPT-4o liep dat soepel, maar bij overschakelen naar een andere partij begon het schokkerig te springen.
Bij het analyseren van de packets zag ik het volgende: voor hetzelfde antwoord van driehonderd woorden pushte partij A 187 chunks, terwijl partij B er slechts 23 pushte. Als de frontend een typemachine-effect met vast ritme gebruikt, dan hapert het bij partij B eerst en spuwt het daarna uit. Onze tijdelijke oplossing was toen een bufferwachtrij in de frontend, maar daardoor liep de latentie juist op: de eerste-teken-respons ging van 400ms naar 1,1s.
De juiste oplossing is normalisatie op de gateway-laag, waarbij verschillende chunking-strategieën worden omgezet naar een stream met vaste granulariteit. Juist daarin zit de betekenis van de modelgateway: de business hoeft zich niet bezig te houden met hoe de upstream pusht, maar consumeert alleen de standaardstream. We hebben directe verbinding en de aggregatieroute vergeleken; na normalisatie verdween het haperen in de frontend-rendering vrijwel volledig en bleef de latentie van het eerste teken stabiel onder de 500ms.
Valkuil drie: de Token-facturatiegrondslag — de rekening klopt nooit
Deze valkuil werd als eerste opgemerkt door finance. We maakten een overzichtstabel op basis van het verbruik in de consoles van elke partij, en vergeleken die met het aantal aanroepen dat we daadwerkelijk in de business hadden gemeten. Het verschil was bijna twintig procent. Bij navraag bleek het om drie dingen te gaan: sommige platformen rekenen de system prompt mee in de input-tokens, andere niet; sommige rekenen het stream-eindmarkeringspunt ook als één token; en bij gemengde Chinese en Engelse tekst zijn de woordsegmentatieregels ook nog eens niet consistent.
Een concreet voorbeeld: voor hetzelfde Chinese contract van tweeduizend woorden registreert partij A de input als 1840 tokens, terwijl partij B op 2130 tokens uitkomt — een verschil van 15%. Als je maandelijks honderdduizenden aanroepen doet, dan slaat die afwijking direct neer in de kostenberekening, en dan is budgetteren simpelweg onmogelijk.
De manier om de grondslag te uniformeren is de gateway-laag zelf te laten boekhouden, input en output volgens één set regels te tellen, en dat vervolgens af te stemmen tegen de rekeningen van elke partij. Onze huidige aanpak is dat zowel de gateway-kant als de upstream-kant een eigen administratie bijhoudt, en dat er een waarschuwing komt zodra de afwijking meer dan 3% bedraagt. Zo is Token-facturatie beheersbaar, en heb je bij het vergelijken van API-prijzen ook een uniforme basis.
Een paar punten waar ik bij de selectie naar kijk
Als je ook overweegt een aggregatieoplossing voor grote-model-API's te evalueren, dan noem ik een paar punten die ik zelf daadwerkelijk zou controleren: of de authenticatievelden zijn uitgelijnd op de OpenAI-specificatie, en of je met één regel base_url kunt wisselen; of de streaming output is genormaliseerd qua chunking, en of de latentie van het eerste teken onder de 600ms kan blijven; of de facturatiegrondslag transparant is, en of betaling naar verbruik en reconciliatie worden ondersteund; of de dekking van binnenlandse modellen compleet is, en of Pangu, Qwen, ERNIE en Doubao direct aanroepbaar zijn; en of er waarneembare aanroeplogs zijn wanneer er problemen optreden.
In één zin samengevat: bij het kiezen van een AI API-aggregatieplatform kijk je niet naar hoeveel modellen het aansluit, maar naar hoeveel vuil werk het voor je opknapt. Nog een aanvulling: als je slechts één of twee modellen aansluit, dan volstaat een directe verbinding; zodra je er meer dan drie hebt, komt de waarde van de gateway-laag naar voren.
Auteur: Liu Zhiyuan
Publicatiedatum: 6 oktober 2026