AccueilGuide
Mis à jour le
Fenêtre de contexte de l'agent IA : comment les 100k tokens sont utilisés
La fenêtre de contexte d'un agent IA est l'espace total de tokens partagé par le prompt, les résultats d'outils et la réponse du modèle. Sur cette API, cet espace est de 100 000 tokens, et les agents à longue durée de vie ont tendance à le remplir plus vite que prévu.

Points clés
- La fenêtre de 100 000 tokens couvre le prompt et la complétion, donc chaque résultat d'outil que vous gardez réduit la place pour la réponse suivante.
- Dans une boucle d'agent, tout l'historique est réenvoyé à chaque étape, donc l'entrée totale croît au carré du nombre d'étapes, et non linéairement.
- Supprimez d'abord les anciens résultats d'outils, gardez le prompt système et les derniers échanges, et mesurez avec le champ usage.
- Une boucle de 20 étapes avec 1 500 nouveaux tokens par étape coûte environ 0,055 $ au total.
Pas de carte nécessaire. Après l'inscription, réclamez 0,50 $ de crédit d'essai gratuit en un clic (une fois par personne).
Obtenir une clé APILa réponse courte : un budget partagé de 100 000 tokens
Quand les gens cherchent la fenêtre de contexte d'agent IA, ils veulent généralement savoir combien un agent peut mémoriser avant de saturer. Ici, le nombre est de 100 000 tokens, et il compte tout : le prompt système, les définitions d'outils, chaque message précédent, chaque résultat d'outil, et la complétion que le modèle est sur le point d'écrire. La complétion peut utiliser ce qui reste, et max_tokens est optionnel.
Cela fait de la fenêtre un budget, et non un espace de stockage. Un chatbot atteint rarement la limite. Un agent qui appelle des outils en boucle peut l'atteindre en un après-midi, car chaque étape ajoute un message du modèle et un résultat d'outil à l'historique, et tout l'historique est renvoyé lors de l'appel suivant. Le modèle n'a pas de mémoire entre les requêtes. Ce qui ressemble à de la mémoire, c'est vous qui renvoyez l'historique de conversation.
Ce qui remplit réellement la fenêtre dans un agent
La plupart de l'espace n'est pas le texte de l'utilisateur. Suivez ces cinq sources et vous pourrez prédire où une exécution manquera de place.
- Prompt système. Règles, persona et format de sortie. Souvent 500 à 2 000 tokens et envoyé à chaque appel.
- Définitions d'outils. Chaque nom de fonction, description et schéma JSON compte. Dix outils avec de longues descriptions peuvent coûter plusieurs milliers de tokens avant le premier message utilisateur.
- Résultats d'outils. La cause habituelle. Un résultat de recherche, une extraction de fichier ou un jeu de lignes de base de données peut représenter des milliers de tokens, et il reste dans l'historique sauf si vous le supprimez.
- Messages assistant. Raisonnement écrit en texte et les arguments
tool_callsproduits par le modèle. - La réponse en cours de génération. Elle a aussi besoin de place. Si le prompt fait 99 000 tokens, il reste environ 1 000 tokens.
L'API rapporte des nombres exacts dans le bloc usage de chaque réponse, donc vous n'avez pas à deviner. Journalisez prompt_tokens après chaque étape et vous verrez la courbe.
Un exemple détaillé : 20 étapes d'une boucle d'outils
Prenons un agent avec un départ de 3 000 tokens (prompt système plus définitions d'outils). Chaque étape ajoute environ 1 500 tokens à l'historique : l'appel d'outil du modèle et le résultat de l'outil. Il écrit également environ 300 tokens de sortie par étape. L'agent effectue 20 étapes.
L'entrée à l'étape k est 3 000 + 1 500 × (k − 1). Sommé sur 20 étapes :
- 3 000 × 20 = 60 000 tokens pour le début fixe, réenvoyé à chaque fois.
- 1 500 × (0 + 1 + ... + 19) = 1 500 × 190 = 285 000 tokens d'historique accumulé.
- Entrée totale : 345 000 tokens. Sortie totale : 20 × 300 = 6 000 tokens.
| Élément | Tokens | Prix par 1M | Coût |
|---|---|---|---|
| Entrée | 345,000 | $0.15 | $0.05175 |
| Sortie | 6,000 | $0.50 | $0.003 |
| Total | environ 0,055 $ |
Deux points sautent aux yeux. Premièrement, le contexte à l'étape 20 est de 3 000 + 1 500 × 19 = 31 500 tokens, bien dans la fenêtre, mais vous avez payé pour 345 000 tokens d'entrée, car l'historique a été renvoyé à chaque fois. Deuxièmement, un appel unique avec une fenêtre complètement pleine (100 000 tokens d'entrée) coûte 100 000 × 0,15 $ / 1M = 0,015 $ pour la partie entrée. Les contextes longs sont abordables par appel ; le coût vient de leur répétition sur de nombreuses étapes. Consultez la page tarifaire pour les tarifs et les bonus de rechargement.
Combien d'étapes tiennent avant que la fenêtre ne soit pleine
Vous pouvez estimer cela avant d'écrire du code. Gardez une réserve pour la réponse, disons 20 000 tokens, ce qui laisse un budget de 80 000 tokens pour le prompt. Avec un départ de 3 000 tokens et 1 500 tokens ajoutés par étape, l'historique atteint ce budget après (80 000 − 3 000) / 1 500, soit environ 51 étapes.
Évaluez maintenant le coût d'une exécution de cette longueur. Sur 51 étapes, l'entrée est de 3 000 × 51 + 1 500 × (0 + 1 + ... + 50) = 153 000 + 1 500 × 1 275 = 153 000 + 1 912 500 = 2 065 500 tokens. La sortie à 300 tokens par étape fait 15 300 tokens. Coût : 2 065 500 × 0,15 $ / 1M = 0,30983 $, plus 15 300 × 0,50 $ / 1M = 0,00765 $, soit environ 0,32 $.
Comparez cela avec l'exécution de 20 étapes à environ 0,055 $. L'exécution est 2,55 fois plus longue mais coûte environ 5,8 fois plus cher, car chaque étape transporte un historique plus long. C'est la raison pratique de réduire : cela plafonne le coût par étape tout en protégeant la fenêtre.
Maintenir un agent à l'intérieur de la fenêtre
Supprimez d'abord les anciennes sorties d'outils
Les résultats bruts des outils sont la partie la plus volumineuse et la moins utile d'un ancien historique. Une fois que le modèle a agi sur une liste de fichiers, il n'a rarement besoin de la liste à nouveau. Remplacez les anciens résultats par un stub d'une ligne tel que "résultat supprimé, 4 200 tokens", ou supprimez la paire entièrement.
Résumez le milieu, gardez les deux extrémités
Gardez le prompt système et les derniers échanges tels quels. Pour tout ce qui se trouve entre les deux, demandez au modèle un résumé court des décisions prises et des faits trouvés, puis stockez ce résumé comme un message unique. Exécutez l'appel de résumé avant d'atteindre la limite, et non après.
Déplacez les faits hors de la transcription
Si l'agent apprend quelque chose qu'il doit conserver pendant des heures, écrivez-le dans un fichier ou une petite base de données via un outil, et relisez-le quand nécessaire. C'est moins cher que de le transporter dans chaque requête et cela survit aux redémarrages.
Gardez les schémas d'outils courts
Réduisez les descriptions à ce dont le modèle a besoin pour choisir l'outil. Ne passez que les outils pertinents pour la phase actuelle de la tâche.
Code : une boucle d'outils avec un budget de tokens
Cette boucle supprime les messages les plus anciens lorsque la taille approximative dépasse un budget de 80 000 tokens, laissant de la place pour la réponse. L'estimation divise les caractères par quatre, une approximation courante pour le texte anglais ; le compte réel revient dans usage. L'élagage supprime les messages tool orphelins pour qu'un résultat n'apparaisse jamais sans son appel.
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})
L'appel de fonctions suit le format OpenAI : tools, tool_choice, et les résultats retournés en tant que role: "tool". La documentation liste les paramètres transmis.
Limites importantes en plus de la fenêtre
La fenêtre est une contrainte. Les agents atteignent également des limites de requête. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute ; une clé d'essai permet 2 et 60. Une boucle serrée avec des sous-agents en parallèle peut dépasser rapidement le cap de concurrence. L'API répond avec HTTP 429 et le code d'erreur concurrency ou rate_limited, et en cas de surcharge temporaire avec un en-tête Retry-After: 5. Attendez ce délai et réessayez.
Si vous utilisez le streaming, rappelez-vous qu'une requête en streaming occupe son slot de concurrence jusqu'à la fin du flux. Un client bloqué qui ne ferme jamais le flux garde un slot occupé.
Le corps de la requête maximum est de 8 Mo, ce qui est bien plus que 100 000 tokens de texte, donc la fenêtre est la limite que vous atteindrez en premier. Pour un exemple de pipeline textuel construit sur cette API, voir le guide de script vidéo. Lorsque vous êtes prêt à l'exécuter, créez une clé API ; les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai en un clic, valable 7 jours et sans paiement nécessaire.
Plus de guides
Questions et réponses
Quelle est la taille de la fenêtre de contexte ?
100 000 tokens, en comptant le prompt et la complétion ensemble. La complétion peut utiliser tout ce que le prompt laisse libre.
Le modèle se souvient-il des requêtes précédentes ?
Non. Chaque requête est indépendante, donc votre code doit renvoyer les messages qu’il veut que le modèle voie.
Que se passe-t-il lorsque vous dépassez la limite ?
La requête ne tient pas dans la fenêtre, donc réduisez ou résumez l’historique avant d’envoyer. Les requêtes échouées ne sont pas facturées.
Comment compter les tokens ?
Lisez prompt_tokens et completion_tokens dans le bloc usage de chaque réponse, ou utilisez une estimation approximative de quatre caractères par token pour l’anglais avant d’envoyer.
Votre clé est à un formulaire près
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.