Cosa significa model_context_window_exceeded
La stringa model_context_window_exceeded è il modo in cui alcuni client, SDK e API etichettano un errore specifico: il testo che hai inviato, più lo spazio necessario per una risposta, è più grande di quanto il modello possa gestire in una singola richiesta. La formulazione del messaggio varia tra gli strumenti, quindi leggi il corpo completo dell'errore mostrato dal tuo client invece di affidarti a un nome. La causa è sempre la stessa.
Su questa API la finestra di contesto è di 100.000 token, e quel numero copre insieme il prompt e il completamento. Se il tuo prompt utilizza 95.000 token, restano al massimo circa 5.000 per la risposta. Se imposti anche max_tokens a 8.000, la richiesta richiede più di quanto consenta la finestra. Il campo max_tokens è facoltativo e, se lo lasci vuoto, la risposta usa semplicemente lo spazio rimanente.
Una richiesta che fallisce in questo modo restituisce un errore invece di un completamento. Le richieste fallite non vengono addebitate, quindi raggiungere il limite non ti costa nulla tranne il round trip. La soluzione è lato tuo: invia meno o chiedi meno.
Quanto sono grandi 100.000 token?
Un token è un blocco di testo, spesso una parola breve o parte di una più lunga. Per la prosa inglese ordinaria una regola approssimativa è un token ogni quattro caratteri, o circa tre quarti di parola. Secondo questa regola 100.000 token corrispondono a circa 75.000 parole, che è un romanzo fitto. Codice, JSON, tabelle e testo non inglese si dividono in più token per carattere, quindi lo stesso conteggio di caratteri può essere molto più grande. Tratta qualsiasi regola pratica come un numero di pianificazione, non una garanzia.
Il conteggio esatto proviene dal tokenizer del modello. L'API segnala l'utilizzo reale nella risposta: l'oggetto usage elenca i token di prompt e completamento, e una risposta in streaming invia l'utilizzo alla fine. Questi sono i dati più affidabili che hai, quindi registrali.
| Contenuti | Dimensione approssimativa |
|---|---|
| Un messaggio di chat di due frasi | 40-60 token |
| Una pagina di testo inglese, 500 parole | circa 670 token |
| Un documento di 10.000 parole | circa 13.000 token |
| Un dump JSON da 3 MB | spesso oltre 100.000 token, troppo grande per essere inviato grezzo |
Il corpo della richiesta ha anche un limite di dimensione di 8 MB, che è un limite separato dai token. Input grandi possono fallire per uno o per l'altro, e il limite di token è quasi sempre il primo che raggiungi.
Perché le app di chat vanno incontro al limite
L'API non conserva la memoria tra le chiamate. Per continuare una conversazione, il tuo codice invia l'elenco completo dei messaggi ogni volta. Ogni turno aggiunge il messaggio dell'utente e la risposta, quindi il prompt cresce con ogni scambio. Un bot che funziona bene per un'ora e poi inizia a fallire è il segno classico.
La stessa cosa accade negli agenti. Ogni risultato degli strumenti viene aggiunto alla cronologia e una funzione che restituisce un record grande può aggiungere migliaia di token in un singolo passaggio. Le configurazioni di retrieval aggiungono una terza fonte: se incolli venti chunk di documento in ogni prompt, il costo base per richiesta è già elevato prima che esista qualsiasi cronologia.
Prima di correggere qualsiasi cosa, scopri quale delle tre sta crescendo. Stampa il conteggio dei token del prompt da usage dopo ogni chiamata. Se sale di circa la stessa quantità ogni turno, è la cronologia. Se salta dopo passaggi specifici, è output degli strumenti o testo recuperato.
Riduci la cronologia prima di inviarla
La correzione più semplice e affidabile è una funzione che rimuove i turni più vecchi finché la stima rientra in un budget. Mantieni sempre il messaggio di sistema e mantieni sempre l'ultimo messaggio dell'utente. Il budget dovrebbe lasciare spazio per la risposta, quindi usa qualcosa come 80.000 token per il prompt e lascia che il resto sia spazio per il completamento.
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
Mantieni i turni utente e assistente in coppie quando possibile; rimuovere metà di una coppia può confondere il modello. I messaggi degli strumenti sono simili: un messaggio role: "tool" deve rimanere con il turno dell'assistente che lo ha richiesto, quindi rimuovili insieme. Poiché la stima è approssimativa, un margine di sicurezza del 20 percento tra il tuo budget e la finestra reale è un margine confortevole.
Opzioni migliori rispetto alla rimozione dei turni vecchi
Riassumi, poi continua
Quando la cronologia supera una soglia, invia la metà più vecchia al modello con un'istruzione per riassumerla in poche centinaia di parole, quindi sostituisci quei turni con il riassunto come messaggio di sistema o utente. Perdi dettagli ma mantieni il filo. Esegui questo passaggio al di fuori del percorso di risposta live in modo che l'utente non debba aspettare.
Fissa i fatti che devono sopravvivere
Mantieni un piccolo blocco di note durevoli, come nomi, decisioni e impostazioni, e reinseriscilo all'inizio di ogni richiesta. Questo funziona meglio che sperare che un turno vecchio sia ancora visibile.
Riduci ciò che invii
Tronca i risultati degli strumenti ai campi che contano. Recupera meno chunk e taglia ciascuno ai paragrafi rilevanti. Per un documento molto lungo, dividilo in parti, elabora ogni parte e combina i risultati in una chiamata finale breve.
Imposta max_tokens deliberatamente
Se le risposte sono normalmente brevi, limita max_tokens a un valore che si adatta al tuo prodotto. Un limite protegge il budget, ma un limite troppo basso taglia le risposte a metà frase, quindi controlla prima le lunghezze delle tue risposte reali nei log.
La riduzione risparmia anche denaro
I token di input costano $0,15 per 1M, i token di output $0,50 per 1M, fatturati dal credito prepagato. Poiché la chat reinvia la cronologia, il costo per conversazione cresce più velocemente della sua lunghezza. Prendi una chat in cui ogni scambio aggiunge 500 token alla cronologia e la conversazione dura 100 turni.
- Senza riduzione, il turno n invia 500 x n token. La somma su 100 turni è 500 x 5.050 = 2.525.000 token di input, che costano 2,525 x $0,15 = $0,379.
- Con un limite di 20.000 token, i primi 40 turni sono gli stessi (500 x 820 = 410.000 token). I restanti 60 turni inviano 20.000 ciascuno, che è 1.200.000. Il totale è 1.610.000 token, o 1,61 x $0,15 = $0,242.
Il limite fa risparmiare circa un terzo, e il divario si allarga con chat più lunghe. In caso estremo, un prompt da 100.000 token costa 0,1 x $0,15 = $0,015 per richiesta. È economico di per sé, ma il costo si accumula in un bot che serve molti utenti. I dettagli sui prezzi e i bonus di ricarica sono nella pagina dei prezzi, e il credito non scade mai.
Gestione dell'errore nel codice
Anche con la riduzione, prevedi un fallimento. Cattura l'errore API, controlla se il messaggio punta alla lunghezza del contesto, riduci la richiesta e riprova una volta. Non riprovare la richiesta identica, poiché fallirà nello stesso modo.
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
Controlla il codice di stato effettivo e il messaggio che il tuo client riceve per una richiesta di grandi dimensioni e regola il test; la corrispondenza della stringa sopra è un punto di partenza. I limiti di frequenza sono separati: HTTP 429 con rate_limited o concurrency significa troppe richieste, non troppi token, e 429 con Retry-After: 5 significa un sovraccarico temporaneo. La documentazione elenca i campi della richiesta, la spiegazione sui modelli senza censura copre cos'è il modello, e puoi ottenere una chiave per testare tutto questo con numeri di utilizzo reali.
