Wat is LLM-inferentie? Tokens, latentie en kosten
Als je vraagt wat LLM-inferentie is, dan is het korte antwoord dit: het is de stap waarbij een getraind taalmodel je prompt leest en een antwoord schrijft, token voor token. Deze pagina legt uit hoe dat werkt en wat het kost.
Bijgewerkt:

Belangrijkste punten
- Inferentie is het draaien van een afgerond model om output te produceren; training is de eerdere, veel duurdere stap die het model heeft gecreëerd.
- Een verzoek heeft twee fasen: het lezen van de prompt (prefill) en het schrijven van het antwoord token voor token (decoding).
- Kosten en snelheid volgen beide het aantal tokens, dus de invoerlengte, de uitvoerlengte en het contextvenster zijn belangrijker dan alles anders.
- Met een gehoste API betaal je per token en sla je de GPU's over; met je eigen hardware betaal je voor de machine, of deze nu belast is of inactief.
Inferentie in één alinea
Een large language model is een bestand vol getallen, gewichten genoemd. Training is het proces waarbij die getallen worden ingesteld door het model enorme hoeveelheden tekst te tonen. Inferentie is alles wat daarna gebeurt, wanneer je de afgewerkte gewichten gebruikt om een antwoord te krijgen. Elk chatbericht dat je naar een model stuurt, elke autocomplete-suggestie en elke API-aanroep die tekst retourneert, is een inferentie-verzoek.
Het onderscheid is belangrijk omdat de twee taken verschillende economische aspecten hebben. Training gebeurt één keer (of een paar keer) en vereist een groot cluster. Inferentie gebeurt elke keer dat iemand een prompt verstuurt, dus het is het deel dat schaalt met je gebruikers. Als mensen het hebben over de kosten van het draaien van een AI-product, bedoelen ze bijna altijd de kosten van inferentie.
Het model "opzoekt" geen antwoord. Het berekent een waarschijnlijkheid voor elke mogelijke volgende token, kiest er één, voegt het toe aan de tekst en herhaalt dit. Die lus is het hele mechanisme, en de rest van deze pagina is een nadere blik daarop.
Wat er gebeurt tijdens één verzoek
Neem een enkel chatverzoek en volg het van je code tot het laatste teken.
- Tokenisatie. Je tekst wordt opgesplitst in tokens, die brokken tekens zijn. Een token is vaak een kort woord of een stukje van een langer woord. Een veelgebruikte vuistregel voor Engels is ongeveer vier tekens per token, maar dit varieert per taal en inhoud zoals code.
- Prefill. Het model verwerkt alle prompt-tokens in één doorloop. Dit is parallel werk en het bouwt de interne staat op die het model nodig heeft om de tekst voort te zetten.
- Decoderen. Het model produceert het eerste uitvoertoken, dan het tweede, en zo verder. Elk nieuw token hangt af van alle voorgaande tokens, dus deze fase is sequentieel. Het is het langzame deel van de meeste verzoeken.
- Sampling. In elke stap heeft het model een score voor elke token in zijn vocabulaire. Instellingen zoals
temperatureentop_pbepalen hoe de volgende token uit die scores wordt gekozen. Een lage temperatuur kiest bijna altijd de meest waarschijnlijke token; een hogere temperatuur staat meer variatie toe. - Stoppen. De generatie eindigt wanneer het model een einde-tekst-token uitzendt, wanneer het een door jou gedefinieerde
stop-sequentie raakt, of wanneer het de tokenlimiet bereikt.
Prefill en decoderen belasten hardware op verschillende manieren. Prefill wordt voornamelijk beperkt door rekenkracht. Decoderen wordt voornamelijk beperkt door hoe snel de GPU de modelgewichten uit het geheugen kan lezen, omdat elk token ze moet benaderen. Daarom duurt een lang antwoord zichtbaar langer dan een lange vraag van dezelfde grootte.
Tokens, contextvenster en het KV-cachegeheugen
Alles in inferentie wordt gemeten in tokens. Je prompt, het systeembericht, eerdere beurtjes van het gesprek en het antwoord tellen allemaal mee. Het contextvenster is het maximale aantal tokens dat het model tegelijk kan vasthouden, prompt en voltooiing samen. Bij deze service is het contextvenster 100.000 tokens, en de voltooiing kan gebruiken wat de prompt overlaat.
Om het hele gesprek niet voor elk nieuw token opnieuw te hoeven berekenen, bewaren inferentie-motoren een KV cache: de tussenliggende sleutels en waarden voor al verwerkte tokens. De cache groeit mee met de lengte van de context en neemt GPU-geheugen in beslag. Dit is de belangrijkste reden waarom lange contexten duur zijn om te serveren, en de reden waarom een server maar een beperkt aantal lange verzoeken tegelijk kan afhandelen.
Een praktisch gevolg voor jou als ontwikkelaar: een chat die de volledige geschiedenis bij elke beurt opnieuw verstuurt, betaalt voor die geschiedenis elke keer opnieuw. Als een gesprek groeit tot 20.000 tokens, draagt elk nieuw bericht die 20.000 inputtokens met zich mee. Het inkorten of samenvatten van oude beurtjes is de goedkoopste snelheids- en kostenoptimalisatie die je hebt, en vereist geen wijzigingen aan de serverkant.
Latentie: waarom er twee getallen zijn
Mensen vragen vaak hoe snel een model is, maar er zijn twee aparte metingen.
- Tijd tot eerste token. Hoe lang je wacht voordat er tekst verschijnt. Het omvat netwerktijd, wachttijd bij de server en prefill. Lange prompts verhogen deze tijd.
- Generatiesnelheid. Hoe snel tokens aankomen na de eerste. Dit hangt af van de modelgrootte, de hardware en hoeveel andere verzoeken dezelfde GPU op dat moment bedient.
Streaming bestaat vanwege deze splitsing. Met stream: true stuurt de server tokens zodra ze worden geproduceerd, zodat de gebruiker begint met lezen na de eerste token in plaats van te wachten op het volledige antwoord. De totale tijd is hetzelfde, maar de interface voelt veel sneller aan. Voor chat, roleplay en schrijftools is streaming bijna altijd de juiste standaardkeuze.
Een detail om te onthouden als je parallelle verzoeken plant: een gestreamd verzoek houdt zijn slot vast tot de stream eindigt, niet tot de eerste token aankomt. Als je sleutel 8 gelijktijdige verzoeken toestaat, betekent acht lange streams in uitvoering dat de negente moet wachten of een 429-response krijgt.
Wat inferentie kost, met echte cijfers
Gehoste inferentie wordt gefactureerd per token, met aparte prijzen voor input en output omdat outputtokens meer werk kosten. Deze service rekent $0,15 per 1M inputtokens en $0,50 per 1M outputtokens, van prepaid tegoed zonder abonnement. Hier is hoe dat uitkomt voor een paar typische verzoeken.
| Verzoek | Input-tokens | Output-tokens | Kosten |
|---|---|---|---|
| Kort chatbericht | 500 | 300 | $0.000075 + $0.00015 = $0.000225 |
| Chat met geschiedenis | 2,000 | 500 | $0.0003 + $0.00025 = $0.00055 |
| Samenvatting lang document | 30,000 | 1,000 | $0.0045 + $0.0005 = $0.005 |
| Volledige prompt van 100.000 tokens, kort antwoord | 100,000 | 500 | $0.015 + $0.00025 = $0.01525 |
De wiskunde is eenvoudig: deel het aantal tokens door één miljoen en vermenigvuldig met de prijs. Voor de rij chat met geschiedenis: 2.000 / 1.000.000 x $0,15 = $0,0003 en 500 / 1.000.000 x $0,50 = $0,00025, wat samen $0,00055 oplevert. Duizend verzoeken als dit kosten $0,55.
Twee factureringsdetails helpen bij het budgetteren. Mislukte of geweigerde verzoeken worden niet in rekening gebracht en tegoed vervalt niet, dus een opwaardering is geen klok die aftelt. Elk antwoord bevat een X-Balance-USD header, waardoor je code het resterende saldo kunt bewaken zonder een apart verzoek.
Gehoste inferentie of je eigen GPU
Je hebt twee manieren om inferentie uit te voeren. Je kunt GPUs huren of kopen, een serverengine installeren en een model zelf draaien. Of je kunt een API aanroepen en iemand anders de hardware laten beheren.
Het zelf draaien geeft je volledige controle over de modelbestanden, de instellingen en het datapad. De prijs is operationeel werk: hardware kiezen die past bij de gewichten plus de KV-cache, drivers en engines up-to-date houden, pieken in verkeer afhandelen en betalen voor de machine tijdens rustige uren. Een gehoste API zet dit om in een factuur per token. Het is meestal de snelste route wanneer je verkeer ongelijkmatig is of je nog een idee test.
De hier beschreven service is een gehoste, OpenAI-compatibele, tekst-only API. Hij draait één open-weight model, beheerd door een onafhankelijke provider en afgestemd op het geven van antwoorden zonder inhoudelijke weigeringen voor legaal gebruik door volwassenen. Het is niet de officiële API van een modelleverancier en het genereert geen afbeeldingen, audio of video, maakt geen embeddings of fine-tunes modellen. Als je een van die dingen nodig hebt, heb je een ander tool nodig. Als je gewone tekstgeneratie nodig hebt met weinig weigeringen, toont de quickstart de setup, en de prijspagina somt de top-up opties op.
Probeer zelf een inferentie-aanroep
De snelste manier om het concept concreet te maken is één verzoek te versturen en de getallen die het retourneert te lezen. Na het aanmaken van een sleutel verstuurt dit curl-commando een chatcompletie naar de endpoint:
curl https://api.llminferenceapi.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Explain the KV cache in two sentences."}],
"max_tokens": 120
}'
De JSON-respons bevat een usage-object met prompt_tokens, completion_tokens en total_tokens. Vermenigvuldig die met de prijzen hierboven en je hebt de exacte kosten van het verzoek. Dezelfde code in Python met de OpenAI SDK:
from openai import OpenAI
client = OpenAI(
base_url="https://api.llminferenceapi.com/v1",
api_key="YOUR_API_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Explain the KV cache in two sentences."}],
max_tokens=120,
)
u = resp.usage
cost = u.prompt_tokens / 1e6 * 0.15 + u.completion_tokens / 1e6 * 0.50
print(resp.choices[0].message.content)
print(u.prompt_tokens, u.completion_tokens, round(cost, 6))
Nieuwe gebruikers kunnen $0,50 aan proeftegoed claimen met één klik op de sleutelpagina na het inloggen. Er is geen kaart nodig, het duurt 7 dagen en dekt bij de prijzen hierboven ongeveer twee duizend korte chatberichten. Als er een foutmelding verschijnt die je niet herkent, somt het foutopsporingsartikel de gebruikelijke oorzaken op.
Meer handleidingen
Vragen en antwoorden
Is inferentie hetzelfde als het draaien van een model?
Ja. Het draaien van een getraind model op nieuwe input om output te produceren is inferentie. Training, waarbij de gewichten worden aangepast, is een andere en eerdere stap.
Waarom is output duurder dan input?
Invoertokens worden samen verwerkt in één parallelle doorloop, terwijl uitvoertokens één voor één worden gegenereerd. Aanbieders rekenen meer voor het langzamere, sequentiële deel en deze service rekent $0,50 versus $0,15 per 1M tokens.
Maakt een langer contextvenster verzoeken langzamer?
Meestal wel. Een langere prompt betekent meer prefill-werk en een groter KV-cache, dus de tijd tot het eerste token stijgt. Je betaalt alleen voor de tokens die je daadwerkelijk verstuurt en ontvangt, niet voor het ongebruikte deel van het contextvenster van 100.000 tokens.
Heb ik een GPU nodig om een inferentie-API te gebruiken?
Nee. De aanbieder draait de hardware. Je verstuurt HTTPS-verzoeken vanaf elke machine, inclusief een laptop of een kleine server.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.
API-sleutel aanvragen