Ce que signifie model_context_window_exceeded
La chaîne model_context_window_exceeded est la façon dont certains clients, SDK et API signalent une erreur spécifique : le texte envoyé, plus l’espace nécessaire pour une réponse, dépasse la capacité du modèle en une seule requête. Le libellé du message varie selon les outils, lisez donc le corps complet de l’erreur affiché par votre client plutôt que de vous fier à un nom. La cause est toujours la même.
Sur cette API, la fenêtre de contexte fait 100 000 tokens, et ce nombre couvre le prompt et la complétion ensemble. Si votre prompt utilise 95 000 tokens, il reste au maximum environ 5 000 tokens pour la réponse. Si vous définissez aussi max_tokens à 8 000, la requête demande plus que ce que la fenêtre permet. Le champ max_tokens est optionnel ; si vous l’omettez, la réponse utilise simplement l’espace restant.
Une requête qui échoue ainsi renvoie une erreur au lieu d’une complétion. Les requêtes échouées ne sont pas facturées, donc atteindre la limite ne vous coûte rien, sauf le temps aller-retour. La solution est de votre côté : envoyez moins ou demandez moins.
Combien font 100 000 tokens ?
Un token est un fragment de texte, souvent un mot court ou une partie d’un mot plus long. Pour un texte anglais ordinaire, une règle approximative est un token pour quatre caractères, soit environ trois quarts de mot. Selon cette règle, 100 000 tokens représentent environ 75 000 mots, soit un roman épais. Le code, le JSON, les tableaux et les textes non anglais se divisent en plus de tokens par caractère, donc le même nombre de caractères peut représenter beaucoup plus. Considérez toute règle empirique comme un chiffre de planification, pas comme une garantie.
Le décompte exact provient du tokenizer du modèle. L'API indique l'utilisation réelle dans la réponse : l'objet usage liste les tokens du prompt et de la complétion, et une réponse en streaming envoie les informations d'utilisation à la fin. Ce sont les données les plus fiables que vous ayez, alors journalisez-les.
| Contenu | Taille approximative |
|---|---|
| Un message de chat de deux phrases | 40 à 60 tokens |
| Une page de texte anglais, 500 mots | environ 670 tokens |
| Un document de 10 000 mots | environ 13 000 tokens |
| Un dump JSON de 3 Mo | souvent plus de 100 000 tokens, trop volumineux pour être envoyé brut |
Le corps de la requête a aussi une limite de taille de 8 Mo, qui est une limite distincte de celle des tokens. Les grandes entrées peuvent échouer pour l’une ou l’autre raison, et la limite de tokens est presque toujours la première atteinte.
Pourquoi les applications de chat atteignent la limite
L'API ne conserve aucune mémoire entre les appels. Pour poursuivre une conversation, votre code doit envoyer la liste complète des messages à chaque fois. Chaque tour ajoute le message de l'utilisateur et la réponse, donc le prompt s'allonge à chaque échange. Un bot qui fonctionne bien pendant une heure puis commence à échouer est le signe classique.
Le même phénomène se produit dans les agents. Chaque résultat d’outil est ajouté à l’historique, et une fonction qui renvoie un grand enregistrement peut ajouter des milliers de tokens en une seule étape. Les configurations de récupération ajoutent une troisième source : si vous collez vingt extraits de document dans chaque prompt, le coût de base par requête est déjà élevé avant même qu’il y ait un historique.
Avant de corriger quoi que ce soit, déterminez laquelle des trois sources grossit. Affichez le nombre de tokens de prompt depuis usage après chaque appel. S’il augmente d’à peu près la même quantité à chaque tour, c’est l’historique. S’il saute après des étapes spécifiques, c’est la sortie d’outil ou le texte récupéré.
Réduisez l’historique avant de l’envoyer
La correction la plus simple et fiable est une fonction qui supprime les tours les plus anciens jusqu’à ce que l’estimation tienne dans un budget. Conservez toujours le message système et gardez toujours le dernier message utilisateur. Le budget doit laisser de la place pour la réponse, donc utilisez quelque chose comme 80 000 tokens pour le prompt et laissez le reste pour l’espace de complétion.
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
Conservez les tours utilisateur et assistant par paires si possible ; en supprimer une moitié peut laisser le modèle confus. Les messages d'outil sont similaires : un message role: "tool" doit rester associé au tour de l'assistant qui l'a demandé, donc supprimez-les ensemble. Comme l'estimation est approximative, un écart de 20 % entre votre budget et la fenêtre réelle constitue une marge de sécurité confortable.
De meilleures options que de supprimer les anciens tours
Résumez, puis continuez
Lorsque l'historique dépasse un seuil, envoyez la moitié la plus ancienne au modèle avec une instruction pour la résumer en quelques centaines de mots, puis remplacez ces tours par le résumé sous forme de message système ou utilisateur. Vous perdez du détail mais conservez le fil. Exécutez cette étape en dehors du chemin de réponse en direct pour que l'utilisateur n'ait pas à attendre.
Épinglez les faits qui doivent survivre
Conservez un petit bloc de notes durables, comme des noms, des décisions et des paramètres, et réinsérez-le au début de chaque requête. Cela fonctionne mieux que d’espérer qu’un ancien tour soit encore visible.
Réduisez ce que vous envoyez
Tronquez les résultats d’outil aux champs pertinents. Récupérez moins d’extraits et coupez chacun aux paragraphes pertinents. Pour un document très long, divisez-le en parties, traitez chaque partie et combinez les résultats dans un appel final court.
Définissez max_tokens délibérément
Si les réponses sont normalement courtes, plafonnez max_tokens à une valeur adaptée à votre produit. Une limite protège le budget, mais une limite trop basse coupe les réponses en plein milieu d'une phrase, alors examinez d'abord les longueurs réelles de vos réponses dans les journaux.
La réduction économise aussi de l’argent
Les tokens d'entrée coûtent 0,15 $ par 1 M, les tokens de sortie 0,50 $ par 1 M, facturés sur le crédit prépayé. Comme le chat renvoie l'historique, le coût par conversation augmente plus vite que sa longueur. Prenons un chat où chaque échange ajoute 500 tokens à l'historique et où la conversation dure 100 tours.
- Sans réduction, le tour n envoie 500 x n tokens. La somme sur 100 tours est de 500 x 5 050 = 2 525 000 tokens d'entrée, ce qui coûte 2,525 x 0,15 $ = 0,379 $.
- Avec un plafond de 20 000 tokens, les 40 premiers tours sont identiques (500 x 820 = 410 000 tokens). Les 60 tours restants envoient 20 000 chacun, soit 1 200 000. Le total est de 1 610 000 tokens, soit 1,61 x 0,15 $ = 0,242 $.
La limite économise environ un tiers ici, et l'écart s'élargit à mesure que les conversations s'allongent. À l'extrême, un prompt complet de 100 000 tokens coûte 0,1 x 0,15 $ = 0,015 $ par requête. C'est peu coûteux en soi, mais cela s'accumule dans un bot qui sert de nombreux utilisateurs. Les détails de tarification et les bonus de rechargement sont sur la page de tarification, et le crédit n'expire jamais.
Gérer l’erreur dans le code
Même avec une réduction, prévoyez un échec. Interceptez l’erreur API, vérifiez si le message pointe vers la longueur du contexte, réduisez la requête et réessayez une fois. Ne réessayez pas la requête identique, car elle échouera de la même manière.
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
Vérifiez le code d’état et le message réels que votre client reçoit pour une requête surdimensionnée et ajustez le test ; la correspondance de chaîne ci-dessus n’est qu’un point de départ. Les limites de débit sont distinctes : HTTP 429 avec rate_limited ou concurrency signifie trop de requêtes, pas trop de tokens, et 429 avec Retry-After: 5 signifie une surcharge temporaire. La documentation liste les champs de requête, l’explication sur les modèles sans censure couvre ce qu’est le modèle, et vous pouvez obtenir une clé pour tester tout cela avec de vrais chiffres d’utilisation.
