NL ▾
API-sleutel aanvragen

HomeGids

Bijgewerkt

Contextvenster van AI-agent: hoe 100k tokens worden gebruikt

Het contextvenster van een AI-agent is de totale tokenruimte die gedeeld wordt door de prompt, de toolresultaten en het antwoord van het model. Op deze API is die ruimte 100.000 tokens, en langlopende agents vullen deze sneller dan verwacht.

Een glazen vat dat gevuld wordt met gloeiende blokken terwijl een pijl eromheen cirkelt, ter illustratie van het contextvenster van een agent

Belangrijkste punten

  1. Het 100.000-token venster omvat prompt plus completion, dus elk toolresultaat dat je bewaart vermindert de ruimte voor het volgende antwoord.
  2. In een agent-loop wordt de volledige geschiedenis elke stap opnieuw verstuurd, dus de totale input groeit met het kwadraat van het aantal stappen, niet lineair.
  3. Knip eerst oude tooloutput, bewaar de system prompt en de laatste beurten, en meet met het usage veld.
  4. Een loop van 20 stappen met 1.500 nieuwe tokens per stap kost ongeveer $0,055 in totaal.

Geen kaart nodig. Na het aanmaken van je account claim je met één klik $0,50 aan gratis proeftegoed (één keer per persoon).

API-sleutel aanvragen

Het korte antwoord: één gedeeld budget van 100.000 tokens

Wanneer mensen zoeken naar het contextvenster van de AI-agent, willen ze meestal weten hoeveel een agent kan onthouden voordat het vastloopt. Hier is dat getal 100.000 tokens, en het telt alles: de system prompt, de tool-definities, elk eerder bericht, elk tool-resultaat en de completion die het model gaat schrijven. De completion kan alles gebruiken wat overblijft, en max_tokens is optioneel.

Dat maakt het venster tot een budget, geen opslagruimte. Een chatbot komt zelden in de buurt van de limiet. Een agent die tools in een loop aanroept, kan het in een middag bereiken, omdat elke stap een modelbericht en een toolresultaat toevoegt aan de geschiedenis, en de volledige geschiedenis opnieuw wordt verstuurd bij de volgende call. Het model heeft geen geheugen tussen verzoeken door. Wat eruitziet als geheugen is dat jij het transcript opnieuw verstuurt.

Wat het venster in een agent eigenlijk vult

De meeste ruimte is niet de tekst van de gebruiker. Volg deze vijf bronnen en je kunt voorspellen waar een run opraakt.

  • System prompt. Regels, persona en uitvoerformaat. Vaak 500 tot 2.000 tokens en verstuurd bij elke call.
  • Tool-definities. Elke functienaam, beschrijving en JSON-schema telt. Tien tools met lange beschrijvingen kunnen al enkele duizenden tokens kosten voordat het eerste gebruikersbericht wordt verstuurd.
  • Toolresultaten. De gebruikelijke boosdoener. Een zoekresultaat, een bestandsdump of een set databaserijen kan duizenden tokens zijn, en het blijft in de geschiedenis tenzij je het verwijdert.
  • Assistant-berichten. Redenering uitgeschreven in tekst en de tool_calls argumenten die het model produceerde.
  • Het gegenereerde antwoord. Het heeft ook ruimte nodig. Als de prompt 99.000 tokens is, heeft het antwoord nog ongeveer 1.000 over.

De API rapporteert exacte aantallen in de usage-sectie van elk antwoord, zodat je niet hoeft te raden. Log prompt_tokens na elke stap en je ziet de curve.

Een uitgewerkt voorbeeld: 20 stappen van een tool-loop

Neem een agent met een start van 3.000 tokens (systeem prompt plus tool-definities). Elke stap voegt ongeveer 1.500 tokens toe aan de geschiedenis: de tool-oproep van het model en het resultaat van de tool. Het schrijft ook ongeveer 300 tokens output per stap. De agent voert 20 stappen uit.

De input bij stap k is 3.000 + 1.500 × (k − 1). Opgeteld over 20 stappen:

  • 3.000 × 20 = 60.000 tokens voor de vaste start, opnieuw verzonden elke keer.
  • 1.500 × (0 + 1 + ... + 19) = 1.500 × 190 = 285.000 tokens aan opgehoopte geschiedenis.
  • Totale input: 345.000 tokens. Totale output: 20 × 300 = 6.000 tokens.
ArtikelTokensPrijs per 1MKosten
Invoer345,000$0.15$0.05175
Uitvoer6,000$0.50$0.003
Totaalongeveer $0,055

Twee dingen vallen op. Ten eerste is de context bij stap 20 3.000 + 1.500 × 19 = 31.500 tokens, ver binnen het venster, toch heb je betaald voor 345.000 input tokens, omdat de geschiedenis elke keer opnieuw werd verzonden. Ten tweede kost een enkele call met een volledig vol venster (100.000 input tokens) 100.000 × $0,15 / 1M = $0,015 voor de inputkant. Lange contexten zijn betaalbaar per call; de kosten komen door het herhalen ervan over veel stappen. Zie de prijzenpagina voor de tarieven en opwaardeerbonussen.

Hoeveel stappen passen voordat het venster vol is

Je kunt dit schatten voordat je code gaat schrijven. Houd een reserve aan voor het antwoord, zeg 20.000 tokens, wat een budget van 80.000 tokens voor de prompt overlaat. Met een start van 3.000 tokens en 1.500 tokens toegevoegd per stap, bereikt de geschiedenis dat budget na (80.000 − 3.000) / 1.500, of ongeveer 51 stappen.

Bereken nu de kosten voor een run van die lengte. Over 51 stappen is de input 3.000 × 51 + 1.500 × (0 + 1 + ... + 50) = 153.000 + 1.500 × 1.275 = 153.000 + 1.912.500 = 2.065.500 tokens. De output bedraagt 300 tokens per stap, wat neerkomt op 15.300 tokens. Kosten: 2.065.500 × $0,15 / 1M = $0,30983, plus 15.300 × $0,50 / 1M = $0,00765, dus ongeveer $0,32.

Vergelijk dat met de run van 20 stappen voor ongeveer $0,055. De run is 2,55 keer langer, maar kost ongeveer 5,8 keer meer, omdat elke stap een langere geschiedenis bevat. Dit is de praktische reden om te trimmen: het beperkt de kosten per stap en beschermt het contextvenster.

Een agent binnen het venster houden

Verwijder eerst oude tooloutput

Ruwe tool-resultaten zijn het grootste en minst nuttige deel van een oude geschiedenis. Zodra het model heeft gehandeld op basis van een bestandsoverzicht, heeft het dat overzicht zelden nog nodig. Vervang oude resultaten door een eenregelige stub zoals "resultaat verwijderd, 4.200 tokens", of verwijder het paar volledig.

Vat het midden samen, bewaar beide uiteinden

Bewaar de system prompt en de laatste paar beurten letterlijk. Voor alles ertussen, vraag het model om een korte samenvatting van gemaakte beslissingen en gevonden feiten, en sla die samenvatting op als één bericht. Voer de samenvattingscall uit voordat je de limiet raakt, niet erna.

Verplaats feiten uit het transcript

Als de agent iets leert dat hij urenlang moet bewaren, schrijf het dan naar een bestand of een kleine database via een tool, en lees het terug wanneer nodig. Dit is goedkoper dan het in elk verzoek mee te dragen en overleeft herstarts.

Houd toolschemas kort

Knip beschrijvingen tot wat het model nodig heeft om de tool te kiezen. Geef alleen de tools door die relevant zijn voor de huidige fase van de taak.

Code: een toolloop met een tokenbudget

Deze lus trimt de oudste berichten wanneer de ruwe grootte een budget van 80.000 tokens overschrijdt, zodat er ruimte blijft voor het antwoord. De schatting deelt het aantal karakters door vier, een veelgebruikte benadering voor Engelstalige tekst; de werkelijke telling vind je terug in usage. Trimming verwijdert geïsoleerde tool-berichten, zodat een resultaat nooit zonder de bijbehorende call verschijnt.

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.aivideogenapi.com/v1", api_key=os.environ["API_KEY"])
BUDGET = 80_000

tools = [{"type": "function", "function": {
    "name": "get_scene_length",
    "description": "Return the length of a scene in seconds",
    "parameters": {"type": "object",
                   "properties": {"scene": {"type": "integer"}},
                   "required": ["scene"]}}}]

def rough_tokens(messages):
    return sum(len(json.dumps(m)) for m in messages) // 4

def trim(messages):
    system, rest = messages[0], messages[1:]
    while rough_tokens([system] + rest) > BUDGET and len(rest) > 4:
        rest.pop(0)
        while rest and rest[0]["role"] == "tool":
            rest.pop(0)
    return [system] + rest

def run_tool(name, args):
    return json.dumps({"seconds": 4 * args["scene"]})  # stub

messages = [
    {"role": "system", "content": "You plan video scenes. Use tools for lengths."},
    {"role": "user", "content": "Total the length of scenes 1 to 5."},
]

for step in range(20):
    resp = client.chat.completions.create(
        model="uncensored", messages=trim(messages), tools=tools)
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    print(step, resp.usage.prompt_tokens)
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        result = run_tool(call.function.name, json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

Tool calling volgt het OpenAI-formaat: tools, tool_choice, en resultaten geretourneerd als role: "tool". De documentatie vermeldt de parameters die worden doorgegeven.

Limieten die tellen naast het venster

Het contextvenster is één beperking. Agents stuiten ook op limieten voor verzoeken. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe; een proefsleutel staat 2 en 60 toe. Een strakke lus met parallelle sub-agents kan de limiet voor gelijktijdige verzoeken snel overschrijden. De API reageert met HTTP 429 en de foutcode concurrency of rate_limited, en bij tijdelijke overbelasting met een Retry-After: 5-header. Wacht die tijd af en probeer het opnieuw.

Als je streamt, onthoud dan dat een gestreamd verzoek zijn slot voor gelijktijdige verzoeken vasthoudt tot de stream eindigt. Een vastgelopen client die de stream niet sluit, houdt een slot bezet.

De maximale body is 8 MB, wat veel meer is dan 100.000 tokens tekst, dus het venster is de limiet die je als eerste zult tegenkomen. Voor een voorbeeld van een pipeline met alleen tekst gebouwd op deze API, zie de gids voor videoscripts. Wanneer je klaar bent om het uit te voeren, maak een API-sleutel aan; nieuwe gebruikers kunnen $0,50 aan proeftegoed claimen met één klik, geldig voor 7 dagen en zonder betalingsinformatie.

Vragen en antwoorden

Hoe groot is het contextvenster?

100.000 tokens, tellend de prompt en de completion samen. De completion kan alles gebruiken wat de prompt overlaat.

Onthoudt het model eerdere verzoeken?

Nee. Elk verzoek is onafhankelijk, dus je code moet de berichten opnieuw sturen die het model moet zien.

Wat gebeurt er als ik de limiet overschrijd?

Het verzoek past niet, dus knip of vat de geschiedenis samen voordat je het verstuurt. Mislukte verzoeken worden niet in rekening gebracht.

Hoe tel ik tokens?

Lees prompt_tokens en completion_tokens uit het usage-blok van elk antwoord, of gebruik een ruwe schatting van vier tekens per token voor Engels voordat je verstuurt.

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