NL ▾

Uncensored Model Hubmodel_context_window_exceeded: Oorzaken en oplossingen

model_context_window_exceeded: Oorzaken en oplossingen

Een foutmelding contextvenster betekent dat je prompt plus het gevraagde antwoord niet meer past in het geheugen van het model. Dit artikel legt de limiet van deze API uit (100.000 tokens), hoe je je prompts meet en code die de geschiedenis inkort voordat deze faalt.

Bijgewerkt

Glazen vat gevuld met gloeiende blokken, de overloop ingekort, als representatie van een vol contextvenster

Belangrijkste punten

  1. Het venster is 100.000 tokens en telt de prompt en de voltooiing samen.
  2. Chat-applicaties lopen hier tegenaan omdat ze de volledige geschiedenis bij elke beurt opnieuw versturen.
  3. Tel of schat tokens voordat je verstuurt en houd ruimte vrij voor het antwoord.
  4. Het inkorten van oude beurten verlaagt ook de kosten, omdat invoer wordt gefactureerd tegen $0,15 per 1M tokens.

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.

InhoudGeschatte grootte
Een chatbericht van twee zinnen40 tot 60 tokens
Een pagina Engelse tekst, 500 woordenongeveer 670 tokens
Een document van 10.000 woordenongeveer 13.000 tokens
Een JSON-dump van 3 MBvaak 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.

Vragen en antwoorden

Hoeveel tokens kan ik in één verzoek sturen?

Het venster is 100.000 tokens, gedeeld tussen je prompt en de completion. Wat de prompt gebruikt, is niet langer beschikbaar voor het antwoord.

Word ik aangerekend als een verzoek het venster overschrijdt?

Nee. Mislukte verzoeken worden niet in rekening gebracht. Je betaalt per token alleen voor verzoeken die compleet zijn.

Moet ik max_tokens instellen?

Nee, het is optioneel. Zonder deze instelling kan de voltooiing de resterende ruimte in het venster gebruiken. Stel het in als je een harde limiet wilt voor de lengte en de kosten van het antwoord.

Hoe tel ik tokens precies?

Lees het usage-object in elk antwoord, dat echt prompt- en completion-tokenaantal rapporteert. Voor schattingen voordat je verstuurt, werkt een regel van vier tekens per token voor Engels.

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