Claude Architect · Leçon

Tokens, fenêtres de contexte et coût

Pourquoi l’historique complet est envoyé à chaque tour et ce qu’il coûte.

Leçon 4 sur 413 étapes

Tokens, fenêtres de contexte et coût est une leçon Claude Architect gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Claude Architect, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Claude Architect comprend 4 leçons au total.

Claude n'a pas de mémoire

Voici l'idée la plus importante de cette leçon : l'API Claude ne conserve NO état entre les échanges.

Le modèle ne se souvient pas de votre dernier message. Chaque appel d'API repart de zéro. Alors, comment les chatbots donnent-ils l'impression de se souvenir ?

Vous envoyez l'historique complet de la conversation dans chaque requête. Le champ messages contient l'intégralité des échanges, à chaque fois.

Ce que contient une requête

Une requête adressée à l'API Claude comporte quelques champs essentiels :

model — le modèle Claude à utiliser
max_tokens — la limite de longueur de la réponse
system — l'invite système
messages — l'historique FULL à chaque échange
tools / tool_choice — configuration facultative des outils

Remarquez que messages s'allonge au fil du temps. L'échange 1 envoie 1 message. L'échange 10 envoie les 19 messages précédents, ainsi que le nouveau.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a support agent.",
    messages=[
        {"role": "user", "content": "My order is late."},
        {"role": "assistant", "content": "I can help. What is your order ID?"},
        {"role": "user", "content": "It's #4821."},
    ],
)

Qu'est-ce qu'un jeton ?

Les modèles ne lisent ni les caractères ni les mots entiers. Ils lisent des jetons — de petits fragments de texte.

À titre indicatif, un jeton correspond à environ 4 caractères anglais, soit environ les trois quarts d'un mot. « unhappiness » peut être découpé en « un » et « happiness ». La ponctuation et les espaces comptent également.

Les jetons sont importants parce que vous payez pour chaque jeton et que la fenêtre de contexte est mesurée en jetons, et non en mots.

Jetons d'entrée et de sortie

Chaque requête comporte deux nombres de jetons, facturés différemment :

Jetons d'entrée — tout ce que vous envoyez : system + tools + l'historique complet de messages.
Jetons de sortie — ce que le modèle génère dans sa réponse.

Les jetons de sortie coûtent généralement plus cher à l'unité que les jetons d'entrée. Mais comme l'historique complet est renvoyé à chaque échange, ce sont les jetons d'entrée qui gonflent discrètement dans les longues conversations.

La fenêtre de contexte

La fenêtre de contexte est le nombre maximal de jetons qu'un modèle peut traiter dans une requête — entrées et sorties combinées.

Si votre historique complet additionné à la valeur demandée de max_tokens dépasse cette fenêtre, la requête échoue. La fenêtre est un plafond strict, pas une suggestion.

C'est pourquoi les conversations longues et les sorties volumineuses des outils finissent par atteindre une limite : l'historique renvoyé ne cesse de s'allonger jusqu'à l'atteindre.

Le coût augmente avec l'historique

Comme vous renvoyez l'intégralité de l'historique à chaque échange, le coût n'augmente pas linéairement avec la conversation : il augmente approximativement selon le carré de sa longueur.

L'échange 1 ne facture que quelques jetons. L'échange 20 refacture les 19 échanges précédents, en plus du nouveau. Une conversation de 10 messages refacture les premiers messages 10 fois au cours de son existence.

Pour un architecte, cela signifie qu'un agent bavard qui ne réduit jamais son historique est un agent coûteux.

# Rough illustration of resent input growing each turn
history = []
for turn in range(1, 6):
    history.append({"role": "user", "content": user_msg(turn)})
    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        messages=history,  # ENTIRE history resent every turn
    )
    history.append({"role": "assistant", "content": resp.content})
    print("turn", turn, "input_tokens", resp.usage.input_tokens)

Mesurez avant d'optimiser

Chaque réponse contient un objet usage indiquant input_tokens et output_tokens. C'est votre référence fiable pour le coût.

Vous pouvez également compter les jetons avant l'envoi, afin de prévoir le coût et de vérifier que vous restez sous la limite de la fenêtre — sans payer une génération complète.

Règle générale : instrumentez l'utilisation des jetons en production. Les coûts agrégés masquent les conversations ou les appels d'outils qui sont les plus coûteux.

count = client.messages.count_tokens(
    model="claude-sonnet-4-5",
    system="You are a support agent.",
    messages=history,
)
print("input tokens before send:", count.input_tokens)

resp = client.messages.create(model="claude-sonnet-4-5", max_tokens=512, messages=history)
print("billed:", resp.usage.input_tokens, resp.usage.output_tokens)

La sortie des outils gonfle le contexte

Dans les boucles d'agents, les résultats des outils sont ajoutés à l'historique et renvoyés à chaque échange suivant. Un outil verbeux qui renvoie un bloc JSON de 5 000 jetons continue de vous coûter pendant toute la conversation.

La solution consiste à réduire la sortie détaillée de l'outil aux champs pertinents avant de l'ajouter. Ne stockez pas tout le résultat d'une API dans le contexte lorsque trois champs suffisent au modèle.

raw = lookup_order(order_id)  # huge JSON
# Trim to what the model actually needs
tool_result = {
    "order_id": raw["id"],
    "status": raw["status"],
    "eta": raw["estimated_delivery"],
}
history.append({
    "role": "user",
    "content": [{"type": "tool_result", "tool_use_id": tu_id,
                 "content": json.dumps(tool_result)}],
})

Résumez pour respecter votre budget

Pour les longues conversations, vous pouvez remplacer les tours anciens par un résumé progressif compact afin de garder l’historique réduit et dans la fenêtre.

Mais attention : le résumé rend les nombres, pourcentages et dates vagues. Le modèle réécrit « refund of $482.10 on 2026-03-14 » en « un remboursement au printemps dernier ».

La solution de l’architecte : extraire les faits transactionnels dans un bloc de « faits du dossier » verbatim conservé en dehors du résumé, afin que les valeurs exactes ne soient jamais déformées.

Perdu au milieu

Une fenêtre de contexte plus grande n’est pas une solution gratuite. Les modèles accordent le plus d’attention au début et à la fin de l’entrée, et le moins au milieu. C’est l’effet « perdu au milieu ».

Enfouir une instruction ou un fait critique au milieu d’un historique gigantesque risque donc de le faire ignorer — même si vous avez payé le prix fort pour l’envoyer.

Gardez les instructions essentielles et la tâche actuelle près des extrémités ; réduisez le milieu volumineux.

API de traitement par lots pour les tâches non bloquantes

Un levier de réduction des coûts : l’API Message Batches. Elle est environ 50 % moins chère que les requêtes standard, avec une fenêtre de traitement pouvant atteindre 24 heures.

Les compromis : il n’y a aucun SLA de latence et les appels d’outils multi-tours ne sont pas pris en charge. Utilisez custom_id pour associer les requêtes ; soumettez à nouveau uniquement les échecs.

Utilisez le traitement par lots pour les rapports nocturnes et les audits volumineux. Ne l’utilisez jamais pour les vérifications bloquantes, urgentes ou précédant une fusion — un utilisateur attend leur résultat.

batch = client.messages.batches.create(requests=[
    {"custom_id": "doc-001", "params": {
        "model": "claude-sonnet-4-5", "max_tokens": 1024,
        "messages": [{"role": "user", "content": classify(doc_1)}]}},
    {"custom_id": "doc-002", "params": {
        "model": "claude-sonnet-4-5", "max_tokens": 1024,
        "messages": [{"role": "user", "content": classify(doc_2)}]}},
])  # ~50% cheaper, up to 24h, no latency SLA

Vérification rapide

Le coût par conversation d’un chatbot d’assistance en production augmente rapidement à mesure que les sessions s’allongent, même si chaque réponse de l’utilisateur est courte. Quelle en est la cause principale, et quelle est la correction appropriée au niveau de l’architecture ?

Réponds-y dans la leçon interactive

Récapitulatif : jetons, contexte et coût

Points essentiels :

L’API ne conserve aucun état — vous renvoyez tout l’historique messages à chaque tour.
La facturation se fait par jeton, séparée entre entrée (système + outils + historique) et sortie.
La fenêtre de contexte limite l’entrée + la sortie ; l’historique renvoyé se rapproche progressivement de cette limite et le coût augmente à peu près selon le carré de la longueur de la conversation.
Mesurez avec usage et count_tokens ; réduisez la sortie détaillée des outils aux champs pertinents.
Résumez pour respecter le budget, mais conservez les nombres et dates exacts dans un bloc de faits du dossier verbatim ; surveillez l’effet « perdu au milieu ».
L’API de traitement par lots est environ 50 % moins chère, uniquement pour les tâches non bloquantes — jamais pour les vérifications urgentes.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 26
Leçons: 104

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Tokens, fenêtres de contexte et coût » est-elle gratuite ?

Oui — le texte complet de « Tokens, fenêtres de contexte et coût » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Claude Architect, passe à CoddyKit PRO. Le cours Claude Architect comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tokens, fenêtres de contexte et coût » ?

Pourquoi l’historique complet est envoyé à chaque tour et ce qu’il coûte. Tu pratiques Claude Architect avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Claude Architect ?

Aucune expérience préalable n'est requise. Claude Architect sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Tokens, fenêtres de contexte et coût » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Claude Architect ?

Oui. Chaque leçon Claude Architect inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Claude Architect