8341TokenFactory
LLM APIAPI GatewayAggregation

Oproepvolume steeg met 40%, maar de factuur bijna verdrievoudigd? SiCore TokenWorks helpt je deze rekening te ontrafelen

SiCore TokenWorks Team·2026-11-08

Toen de financiële afdeling vorige maand met de factuur aankwam, dacht ik dat ze zich had vergist. Het oproepvolume was met 40% gestegen ten opzichte van de vorige maand, maar de factuur sprong van net boven de zes cijfers naar bijna het driedubbele. Lineair gerekend zou het hooguit veertig procent meer moeten zijn — waar kwam die extra rekening vandaan?

Ik haalde de oproeplogs van de afgelopen dertig dagen op en sneed ze door op model, op interface en op aantal hertrypogingen. Het probleem zat niet in het "volume", maar in de "structuur". Vier verborgen bloedingspunten, elk onopvallender dan het vorige.

Eerst het meest in het oog springende: het vlaggenschipmodel deed het ruwe werk. We hebben een intentieherkenningsmodule die eigenlijk met een lichtgewicht model prima zou werken, maar in de beginfase hadden we hem voor het gemak direct aan het duurste vlaggenschipmodel gehangen, en niemand had er ooit naar omgekeken. Dit type verkeer vormt meer dan zestig procent van het totale aantal verzoeken, maar levert zeer weinig bedrijfswaarde op. Door opnieuw te draaien met modellagen en taken zoals classificatie, extractie en formaatvalidatie naar kleinere modellen te verplaatsen, en alleen de verzoeken die echt redeneerwerk vereisen aan het vlaggenschipmodel over te laten, kan dit deel van de kosten worden teruggebracht tot een derde tot de helft van het origineel. Onderschat deze actie niet: je hoeft de bedrijfslogica niet te wijzigen, alleen de routering.

Hoe maak je die gelaagdheid concreet? Ik heb op basis van taaktype drie niveaus onderscheiden: het eerste niveau is classificatie en intentieherkenning — korte input, korte output, eenvoudige logica — een klein model kan dit prima aan; het tweede niveau is informatie-extractie en formaatvalidatie — enig semantisch begrip nodig, maar geen meerstapsredenering — gebruik een middelgroot model; het derde niveau is pas de complexe meerstapsredenering, het genereren van lange teksten en code-aanvulling — dat laat je aan het vlaggenschipmodel over. Na de omschakeling vergeleek ik het: bij taken van het eerste niveau daalde de nauwkeurigheid op het kleine model met minder dan twee procentpunt, maar de kosten per oproep daalden met bijna negentig procent. Het tweede niveau is subtieler: het verschil in F1 tussen het middelgrote model en het vlaggenschipmodel bij extractietaken was minder dan 0,03, terwijl de kosten vijf keer zo hoog waren. Als je dat doorrekent, is het meteen duidelijk: het geld dat we eerder te veel uitgaven, was puur gemakzucht.

De tweede valkuil is nog geniepiger. Een hertry-storm. De time-outdrempel van een bepaalde upstream-interface was te strak ingesteld, waardoor de client bij elke netwerkhik meteen opnieuw probeerde, wat weer time-out liep, en dan weer opnieuw. In de logs was te zien dat hetzelfde verzoek vier of vijf keer werd afgevuurd, elke keer Tokens verbrandend, terwijl de gebruiker slechts één keer een fout zag. Dit soort nutteloze verbruik is onzichtbaar in de factuur, maar kan rond de twintig procent uitmaken. De oplossing is eenvoudig: hertrypogingen omzetten naar idempotente hertry met backoff, de time-outdrempel verruimen en op de server deduplicatie van verzoeken toepassen. Daarna kun je het nutteloze Token-verbruik grotendeels wegstrepen.

Laat ik hier een paar cruciale parameters toelichten. We hebben de time-outdrempel verruimd van de oorspronkelijke 3 seconden naar 15 seconden, het aantal hertrypogingen van onbeperkt naar maximaal twee, en de backoff-strategie ingesteld op exponentiële backoff met jitter — de eerste hertry wacht 1 seconde, de tweede 2 seconden, met willekeurige jitter om thundering herd te voorkomen. Aan de serverkant hebben we een verzoekvingerafdruk toegevoegd: dezelfde vingerafdruk wordt binnen 60 seconden slechts één keer verwerkt, en volgende verzoeken krijgen direct het gecachte resultaat terug. Na de wijziging heb ik een week lang specifiek meegekeken: het hertrypercentage daalde van de oorspronkelijke 18% naar minder dan 4%, en het nutteloze Token-verbruik werd met meer dan zeventig procent teruggebracht. Een onverwacht voordeel: de time-outklachten aan gebruikerszijde namen juist af, omdat na het verruimen van de drempel die verzoeken die eigenlijk hadden kunnen slagen maar te vroeg werden afgekapt, nu normaal kunnen terugkeren.

Het derde punt is dat lange contexten niet werden bijgesneden. Onze gespreksinterface stopte standaard de volledige geschiedenis erin, dus tegen de twintigste ronde was de input-Token meer dan tien keer die van de eerste ronde. Maar in werkelijkheid is het grootste deel van de geschiedenis nutteloos voor het huidige antwoord. Met een schuifvenster plus samenvattingscompressie, waarbij alleen de originele tekst van de laatste paar rondes plus een rollende samenvatting wordt bewaard, kan de inputzijde met veertig tot zestig procent dalen. Er zit hier een detail: de samenvatting zelf kost ook Tokens, dus het venster mag niet te agressief worden ingekrompen — je moet dat omslagpunt vinden.

We hebben een paar parametercombinaties geprobeerd en zijn uiteindelijk uitgekomen op de combinatie "originele tekst van de laatste vijf rondes + rollende samenvatting". De rollende samenvatting wordt niet elke ronde opnieuw gegenereerd, maar elke drie rondes bijgewerkt, waarbij eerder gevoerde gesprekken worden gecomprimeerd tot een samenvatting van minder dan tweehonderd woorden. Zo daalde de Token-hoeveelheid aan de inputzijde van meer dan achtduizend in de twintigste ronde naar iets meer dan drieduizend, een daling van meer dan zestig procent. Maar ik heb ook geprobeerd om alleen de laatste twee rondes te bewaren, en toen bleek de antwoordkwaliteit duidelijk achteruit te gaan: wanneer de gebruiker doorvroeg over de context, gaf het model vaak antwoorden die er niet op aansloten. Dat omslagpunt bestaat dus echt, en je moet het testen op basis van je eigen bedrijfsscenario. Onze ervaring is: de venstergrootte mag niet kleiner zijn dan de laatste drie rondes, en de updatefrequentie van de samenvatting mag niet hoger zijn dan eens per twee rondes, anders is het geld dat je aan Tokens bespaart niet genoeg om de gebruikerservaring te compenseren.

Het vierde punt: een lage cache-hitrate. Identieke of sterk vergelijkbare verzoeken kwamen steeds weer binnen, maar wij deden elke keer opnieuw inferentie. Systeemprompts, vaste templates en veelgestelde vragen — inhoud die volledig cachebaar is — hadden toen een hitrate van minder dan tien procent. Na het toevoegen van een semantische cache-laag worden herhaalde verzoeken direct teruggegeven; het percentage dat je hiermee kunt besparen hangt af van de herhalingsgraad van je bedrijf, bij ons ongeveer twintig tot dertig procent.

Over semantische caching valt het een en ander te zeggen. Een exacte cache kan alleen volledig identieke verzoeken raken, maar in de praktijk zijn heel veel verzoeken "ongeveer hetzelfde bedoeld, maar anders geformuleerd". Als een gebruiker bijvoorbeeld vraagt "hoe vraag ik een terugbetaling aan" en "wat is het terugbetalingsproces", dan raakt een exacte match niets, maar een semantische cache wel. De oplossing die wij gebruiken: de input vectoriseren, in de cache-database een benaderende nearest-neighbor-zoekopdracht doen, en bij een similarity boven de drempel direct het gecachte resultaat teruggeven. De drempel instellen is cruciaal: te hoog en de hitrate komt niet omhoog, te laag en je geeft makkelijk irrelevante antwoorden terug. Wij hebben hem uiteindelijk op 0,92 gezet, waardoor de hitrate van minder dan 10% naar 34% steeg, zonder dat we enige klacht van gebruikers ontvingen dat het antwoord er niet op aansloot. Het gedeelte met systeemprompts en vaste templates is eenvoudiger: gewoon prefix-caching toepassen, met een hitrate van bijna 100%.

Met de vier acties opgeteld hebben we daarna de facturering op basis van verbruik plus modelgelaagdheid nog eens doorgerekend: de factuur viel terug naar ongeveer 1,2 keer het niveau van vóór de groei, terwijl het oproepvolume nog steeds diezelfde stijging van 40% had. Terloops: tussendoor hebben we token8341 geprobeerd voor uniforme toegang tot meerdere modellen — één Key om tussen meerdere modellen te schakelen — en nadat de routering en factureringsmaatstaven uniform waren gemaakt, scheelde dat een hoop werk bij het opsporen van dit soort structurele problemen.

Nog een punt dat makkelijk over het hoofd wordt gezien: monitoring en attributie. De reden dat deze vier problemen zo lang onopgemerkt bleven, is in wezen dat onze factuur alleen per model- en interface-dimensie werd uitgesplitst, niet per "taaktype" en "verzoekvingerafdruk". Later heb ik een laag oproeplabels toegevoegd, waarbij elk verzoek labels kreeg voor taaktype, of het een hertry was, of de cache werd geraakt, en het aantal contextrondes. Toen de factuur er daarna weer kwam, was in één oogopslag te zien welke schakel geld verbrandde. Dat labelsysteem bespaart op zichzelf geen geld, maar zonder het weet je gewoon niet waar het geld naartoe gaat.

Tips om valkuilen te vermijden: begin niet meteen met het vervangen door goedkopere modellen. Splits eerst de oproepstructuur uit en kijk ernaar; vaak wordt het geld niet aan de stukprijs uitgegeven, maar aan de duplicatie en redundantie waarvan je je niet bewust bent. Prijsoptimalisatie is de laatste stap, niet de eerste.

Auteur: Zhao Qiming

Publicatiedatum: 9 november 2026