Wat model_context_window_exceeded betekent
De string model_context_window_exceeded is hoe sommige clients, SDK's en API's een specifieke fout labelen: de tekst die je hebt verzonden, plus de ruimte die nodig is voor een antwoord, is groter dan het model in één verzoek kan vasthouden. De formulering van de boodschap verschilt tussen tools, dus lees de volledige foutmelding die je client toont in plaats van te vertrouwen op een naam. De oorzaak is altijd hetzelfde.
Op deze API is het contextvenster 100.000 tokens, en dat aantal dekt de prompt en de voltooiing samen. Als je prompt 95.000 tokens gebruikt, zijn er maximaal ongeveer 5.000 over voor het antwoord. Als je ook max_tokens op 8.000 zet, vraagt het verzoek meer aan dan het venster toestaat. Het veld max_tokens is optioneel, en als je het weglaat, gebruikt het antwoord gewoon de resterende ruimte.
Een verzoek dat op deze manier faalt, retourneert een fout in plaats van een voltooiing. Mislukte verzoeken worden niet in rekening gebracht, dus het raken van de limiet kost je niets, behalve de heen-en-weer-rit. De oplossing ligt aan jouw kant: stuur minder, of vraag om minder.
Hoe groot is 100.000 tokens?
Een token is een tekstblok, vaak een kort woord of een deel van een langer woord. Voor gewone Engelse tekst is een ruwe vuistregel één token per vier tekens, of ongeveer drie kwart van een woord. Volgens die regel zijn 100.000 tokens ongeveer 75.000 woorden, wat een dikke roman is. Code, JSON, tabellen en niet-Engelse tekst splitsen zich in meer tokens per karakter, dus dezelfde tekentelling kan veel groter zijn. Beschouw elke vuistregel als een getal voor planning, geen garantie.
Het exacte aantal komt van de eigen tokenizer van het model. De API rapporteert het werkelijke verbruik in het antwoord: het usage-object geeft prompt- en completion-tokens weer, en bij een gestreamd antwoord wordt het verbruik aan het einde verzonden. Dat is de meest betrouwbare data die je hebt, dus log het.
| Inhoud | Geschatte grootte |
|---|---|
| Een chatbericht van twee zinnen | 40 tot 60 tokens |
| Een pagina Engelse tekst, 500 woorden | ongeveer 670 tokens |
| Een document van 10.000 woorden | ongeveer 13.000 tokens |
| Een JSON-dump van 3 MB | vaak meer dan 100.000 tokens, te groot om rauw te versturen |
Het verzoeklichaam heeft ook een groottelimiet van 8 MB, wat een aparte limiet is van tokens. Grote inputs kunnen falen op een van beide, en de tokenlimiet is bijna altijd de eerste die je raakt.
Waarom chat-applicaties de limiet raken
De API houdt geen geheugen vast tussen aanroepen. Om een gesprek voort te zetten, verstuurt je code elke keer de volledige lijst met berichten. Elke beurt voegt de gebruikersboodschap en het antwoord toe, dus de prompt groeit met elke uitwisseling. Een bot die een uur goed werkt en daarna begint te falen, is het klassieke teken.
Hetzelfde gebeurt bij agents. Elk toolresultaat wordt aan de geschiedenis toegevoegd, en één functie die een groot record retourneert, kan duizenden tokens in één stap toevoegen. Retrieval-configuraties voegen een derde bron toe: als je twintig documentfragmenten in elke prompt plakt, is de basisprijs per verzoek al groot voordat er geschiedenis is.
Voordat je iets oplost, kom erachter welke van de drie groeit. Print het prompt-tokenaantal uit het usage-object na elke aanroep. Als het met ongeveer dezelfde hoeveelheid stijgt per beurt, is het geschiedenis. Als het springt na specifieke stappen, is het tooluitvoer of opgehaalde tekst.
Kort de geschiedenis in voordat je het verstuurt
De eenvoudigste betrouwbare oplossing is een functie die de oudste gespreksbeurten verwijdert totdat de schatting past binnen een budget. Houd het systeembericht altijd vast, en houd het laatste bericht van de gebruiker altijd vast. Het budget moet ruimte laten voor het antwoord, dus gebruik iets als 80.000 tokens voor de prompt en laat de rest over voor de completion-ruimte.
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
)
def estimate_tokens(text: str) -> int:
return len(text) // 4 + 4 # rough: 4 characters per token plus overhead
def trim(messages, budget=80_000):
system = [m for m in messages if m["role"] == "system"]
rest = [m for m in messages if m["role"] not in ("system",)]
total = sum(estimate_tokens(m["content"]) for m in system + rest)
while total > budget and len(rest) > 1:
dropped = rest.pop(0) # oldest turn goes first
total -= estimate_tokens(dropped["content"])
return system + rest
history = [{"role": "system", "content": "You are a helpful assistant."}]
def ask(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(
model="uncensored",
messages=trim(history),
max_tokens=2000,
)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
return reply
Houd gebruikers- en assistentbeurten waar mogelijk in paren bij elkaar; het verwijderen van de helft van een paar kan het model in de war maken. Toolberichten zijn vergelijkbaar: een role: "tool"-bericht moet bij de assistentbeurt blijven die het heeft aangevraagd, dus verwijder ze samen. Omdat de schatting ruw is, is een marge van 20 procent tussen je budget en het echte venster een comfortabele veiligheidsmarge.
Betere opties dan oude beurten verwijderen
Samenvatten, dan doorgaan
Wanneer de geschiedenis een drempel passeert, verstuur je de oudste helft naar het model met de instructie deze samen te vatten in een paar honderd woorden, en vervang die beurten vervolgens door de samenvatting als een systeem- of gebruikersbericht. Je verliest details, maar behoudt de draad. Voer deze stap buiten de live-antwoordroute uit, zodat de gebruiker niet hoeft te wachten.
Speld de feiten vast die moeten overleven
Houd een klein blok duurzame notities vast, zoals namen, beslissingen en instellingen, en voeg het opnieuw toe aan de bovenkant van elk verzoek. Dit werkt beter dan hopen dat een oud bericht nog zichtbaar is.
Krimp wat je invoert
Beperk toolresultaten tot de velden die er toe doen. Haal minder fragmenten op, en knip elk fragment naar de relevante alinea's. Splits een zeer lang document in delen, verwerk elk deel, en combineer de resultaten in een korte eindaanroep.
Stel max_tokens bewust in
Als antwoorden normaal gesproken kort zijn, stel max_tokens dan in op een waarde die past bij je product. Een limiet beschermt het budget, maar een limiet die te laag is, knipt antwoorden midden in een zin af, dus kijk eerst naar je echte antwoordlengtes in de logs.
Inkorten bespaart ook geld
Invoertokens kosten $0,15 per 1M, uitvoertokens $0,50 per 1M, gefactureerd van prepaid tegoed. Omdat chat de geschiedenis opnieuw verstuurt, groeien de kosten per gesprek sneller dan de lengte. Neem een chat waarbij elke uitwisseling 500 tokens aan de geschiedenis toevoegt en het gesprek 100 beurten duurt.
- Zonder trimmen stuurt beurt n 500 x n tokens. De som over 100 beurten is 500 x 5.050 = 2.525.000 input tokens, wat 2,525 x $0,15 = $0,379 kost.
- Met een limiet van 20.000 tokens zijn de eerste 40 beurten hetzelfde (500 x 820 = 410.000 tokens). De resterende 60 beurten versturen 20.000 elk, wat 1.200.000 is. Het totaal is 1.610.000 tokens, of 1,61 x $0,15 = $0,242.
De cap bespaart hier ongeveer een derde, en het verschil wordt groter naarmate chats langer worden. In het uiterste geval kost een volledige prompt van 100.000 tokens 0,1 x $0,15 = $0,015 per verzoek. Dat is op zich goedkoop, maar het loopt op in een bot die veel gebruikers bedient. Prijsdetails en opwaardeerbonussen staan op de prijzenpagina, en tegoed verloopt nooit.
De fout afhandelen in code
Zelfs met trimmen, reken op een fout. Vang de API-fout af, controleer of het bericht wijst naar de contextlengte, verklein het verzoek en probeer het één keer opnieuw. Probeer niet hetzelfde verzoek opnieuw, omdat het op dezelfde manier zal falen.
from openai import BadRequestError
def safe_ask(messages, budget=80_000):
try:
return client.chat.completions.create(
model="uncensored", messages=trim(messages, budget)
)
except BadRequestError as err:
if "context" in str(err).lower() and budget > 10_000:
return safe_ask(messages, budget // 2)
raise
Controleer de daadwerkelijke statuscode en het bericht die je client ontvangt bij een te groot verzoek en pas de test aan; de string match hierboven is een startpunt. Rate limits zijn apart: HTTP 429 met rate_limited of concurrency betekent te veel verzoeken, niet te veel tokens, en 429 met Retry-After: 5 betekent een tijdelijke overbelasting. De docs geven de verzoekvelden weer, de uitleg over ongecensureerde modellen behandelt wat het model is, en je kunt een sleutel krijgen om dit allemaal te testen met echte verbruikscijfers.
