Gestion du contexte - FAQ

La gestion du contexte dans Claude Code détermine la qualité de chaque réponse générée. Maîtriser la fenêtre de contexte, la compaction automatique et le mode Plan vous permet de réduire significativement vos coûts tout en obtenant des résultats plus précis. Voici les réponses aux questions les plus fréquentes pour optimiser votre utilisation du contexte.

La gestion du contexte dans Claude Code est l'ensemble des techniques permettant de contrôler quelles informations l'agent reçoit dans sa fenêtre de tokens pour produire des réponses pertinentes. Les modèles actuels (Opus 4.6 et plus récents, Sonnet 4.6) exploitent une fenêtre allant jusqu'à 1 million de tokens (disponibilité générale), ce qui en fait l'un des contextes les plus larges disponibles pour un outil de coding agentique. La limite de 200 000 tokens reste la valeur par défaut des modèles plus anciens et des déploiements Bedrock, Vertex et Foundry.

Sur les offres Max, Team et Enterprise, Opus passe automatiquement à la fenêtre de 1 million de tokens. Pour Sonnet, le 1 million de tokens nécessite des crédits d'usage.

Comment fonctionne la fenêtre de contexte dans Claude Code ?

La fenêtre de contexte est la mémoire de travail que Claude Code utilise pour chaque conversation. Elle contient l'ensemble des messages, fichiers lus et résultats d'outils accumulés pendant votre session.

Visualisez cette fenêtre comme un budget fixe (jusqu'à 1 million de tokens sur les modèles actuels, 200 000 tokens sur les modèles plus anciens et les défauts Bedrock/Vertex/Foundry). Chaque action consomme une partie de ce budget : un fichier de 500 lignes représente environ 4 000 tokens, une réponse longue entre 1 000 et 3 000 tokens.

En pratique, la majeure partie du contexte est consommée par les lectures de fichiers et les résultats d'outils, et une faible part par vos messages et les réponses de l'agent.

Pour comprendre les bases de l'interaction avec Claude Code, consultez la FAQ sur vos premières conversations qui couvre les fondamentaux.

À retenir : la fenêtre de contexte est un budget partagé entre vos messages, les fichiers lus et les résultats d'outils, surveillez votre consommation.

Comment savoir combien de tokens il reste dans ma session ?

Exécutez la commande /usage (alias /cost) dans Claude Code pour afficher votre consommation en temps réel. Cette commande affiche le nombre de tokens utilisés et le coût estimé de la session.

# Afficher la consommation de tokens et le coût
$ claude
> /cost

L'indicateur de contexte apparaît aussi dans la barre de statut de Claude Code. Un avertissement apparaît lorsque vous approchez de la limite de la fenêtre et que la compaction automatique se rapproche.

Concrètement, une session typique de développement consomme entre 50 000 et 120 000 tokens avant de déclencher la compaction. Les commandes slash essentielles incluent /cost et /compact parmi les outils de diagnostic indispensables.

À retenir : utilisez /cost régulièrement pour anticiper la compaction et garder le contrôle sur votre budget de tokens.

Quelles stratégies permettent d'optimiser le contexte au quotidien ?

Adoptez trois pratiques clés : limitez les fichiers lus, découpez vos tâches et utilisez des instructions ciblées dans CLAUDE.md. Ces trois leviers réduisent sensiblement la consommation de tokens.

Précisez les fichiers à lire plutôt que de laisser l'agent explorer tout le projet. Un prompt comme « Lis uniquement src/auth/login.ts et corrige le bug ligne 42 » consomme nettement moins de contexte qu'un prompt vague.

# Mauvaise pratique : exploration large
$ claude "Trouve et corrige les bugs dans le projet"

# Bonne pratique : ciblage précis
$ claude "Lis src/auth/login.ts et corrige l'erreur TypeError ligne 42"

Le guide complet de gestion du contexte détaille chaque stratégie avec des exemples concrets adaptés à différents types de projets.

À retenir : cibler les fichiers, découper les tâches et configurer CLAUDE.md sont les trois piliers d'une gestion de contexte efficace.

Comment le mode Plan permet-il d'économiser des tokens ?

Le mode Plan consomme uniquement des tokens d'entrée, sans générer d'appels d'outils coûteux. Activez-le avec le raccourci Shift+Tab (ou Alt+M) pour que Claude Code analyse sans agir.

En mode Plan, l'agent lit votre codebase, propose une stratégie et attend votre validation avant d'exécuter quoi que ce soit. Ce mode réduit sensiblement la consommation totale de tokens sur les tâches complexes, en évitant les explorations et les appels d'outils inutiles.

# Activer le mode Plan
$ claude
> Shift+Tab # Bascule en mode Plan
> "Refactorise le module d'authentification pour utiliser JWT"
# Claude Code propose un plan sans exécuter d'actions

En pratique, le mode Plan est particulièrement utile pour les tâches de refactoring touchant plus de 5 fichiers. Il vous évite de consommer des tokens sur des explorations inutiles. Consultez le tutoriel dédié à la gestion du contexte pour apprendre à combiner le mode Plan avec d'autres techniques.

À retenir : le mode Plan vous fait économiser des tokens en séparant la phase de réflexion de la phase d'exécution.

Comment fonctionne la compaction automatique dans Claude Code ?

La compaction automatique se déclenche lorsque le contexte approche de la limite de la fenêtre, quelle que soit sa taille (jusqu'à 1 million de tokens sur les modèles actuels, 200 000 tokens sur les modèles plus anciens). Claude Code résume alors les échanges précédents pour libérer de l'espace tout en conservant les informations essentielles.

Comprenez que la compaction n'est pas une perte de mémoire : l'agent conserve un résumé structuré des décisions prises, des fichiers modifiés et des erreurs rencontrées. En revanche, les détails fins comme les numéros de ligne exacts ou les blocs de code intermédiaires peuvent être perdus.

Vous pouvez aussi déclencher la compaction manuellement avec la commande /compact :

# Compaction manuelle avec instruction de résumé
$ claude
> /compact "Conserve uniquement les modifications sur auth/ et les tests"

Le paramètre optionnel après /compact guide le résumé. Spécifiez les éléments critiques à conserver pour que la compaction préserve ce qui compte pour votre tâche en cours.

Pour éviter les erreurs fréquentes liées à la compaction, lisez les erreurs courantes de gestion du contexte qui couvre les pièges à éviter.

À retenir : la compaction résume intelligemment votre session. Déclenchez-la manuellement avec /compact pour garder le contrôle sur ce qui est conservé.

Quels sont les hooks PreCompact et comment les configurer ?

Les hooks PreCompact sont des scripts shell exécutés automatiquement juste avant chaque compaction. Configurez-les dans votre fichier .claude/settings.json pour sauvegarder l'état critique de votre session.

Un hook PreCompact typique sauvegarde le diff en cours, l'état git ou un résumé personnalisé dans un fichier temporaire que vous pourrez relire après la compaction.

{
 "hooks": {
 "PreCompact": [
 {
 "matcher": "",
 "hooks": [
 {
 "type": "command",
 "command": "git diff --stat > /tmp/claude-pre-compact-diff.txt",
 "timeout": 5
 }
 ]
 }
 ]
 }
}

Concrètement, les hooks PreCompact résolvent un problème fréquent : perdre la trace des modifications non commitées après une compaction. En sauvegardant le diff avant compaction, vous créez un filet de sécurité.

Pour aller plus loin sur la configuration des hooks et des commandes slash, consultez la FAQ sur les commandes slash essentielles. Vous trouverez aussi des astuces avancées dans les astuces de gestion du contexte.

À retenir : configurez un hook PreCompact pour sauvegarder automatiquement votre diff git avant chaque compaction. C'est votre filet de sécurité.

Comment utiliser les multi-sessions pour scaler horizontalement ?

Lancez plusieurs instances de Claude Code en parallèle, chacune dédiée à une tâche spécifique, pour multiplier votre capacité de traitement sans saturer une seule fenêtre de contexte.

Le scaling horizontal consiste à répartir le travail sur plusieurs sessions indépendantes plutôt que de tout charger dans une seule fenêtre de contexte. Chaque session dispose de son propre budget de tokens.

# Terminal 1 : refactoring du module auth
$ claude "Refactorise src/auth/ pour utiliser des tokens JWT"

# Terminal 2 : écriture des tests
$ claude "Écris les tests unitaires pour src/api/users.ts"

# Terminal 3 : documentation
$ claude "Génère la documentation JSDoc pour src/lib/"

En pratique, chaque session parallèle dispose de sa propre fenêtre de contexte indépendante : les contextes ne s'additionnent pas en une fenêtre unique plus large, mais chaque instance travaille sur sa tâche sans empiéter sur le budget des autres. Le travail en parallèle peut réduire significativement le temps de complétion des tâches complexes par rapport à une session unique.

Le fichier CLAUDE.md sert de mémoire partagée entre les sessions. Chaque instance le charge au démarrage, ce qui garantit la cohérence des conventions de code.

À retenir : répartissez les tâches indépendantes sur 2 à 4 sessions parallèles pour multiplier votre capacité sans compromettre la qualité du contexte.

Peut-on récupérer du contexte perdu après une compaction ?

Non, les tokens supprimés lors d'une compaction ne sont pas récupérables directement. Utilisez les commandes --continue / --resume et les hooks PreCompact pour atténuer cette limitation.

La compaction est un processus destructif : le résumé remplace les échanges originaux. Cependant, trois mécanismes vous protègent. Le fichier CLAUDE.md persiste entre les sessions. Les hooks PreCompact sauvegardent l'état critique. Et les commandes de reprise permettent de reprendre une session précédente avec son contexte résumé. Vous pouvez aussi utiliser /rewind (ou Esc+Esc) pour revenir en arrière dans la conversation avant qu'une compaction ne se produise.

# Reprendre la dernière conversation
$ claude --continue  # ou claude -c

# Reprendre une session spécifique par ID ou nom
$ claude --resume  # ou claude -r

Pour comprendre comment le système de mémoire CLAUDE.md complète la gestion du contexte, consultez la FAQ dédiée. Cette mémoire persistante survit aux compactions et aux changements de session.

À retenir : préparez-vous à la compaction avec des hooks et CLAUDE.md. Une fois les tokens compactés, seul le résumé subsiste.

Quels fichiers consomment le plus de tokens et comment les identifier ?

Les fichiers générés (lock files, bundles, maps) consomment souvent plus de 50 000 tokens chacun. Ajoutez-les à votre .gitignore pour les exclure automatiquement du contexte (Claude Code respecte le .gitignore par défaut).

Un fichier package-lock.json typique représente 30 000 à 80 000 tokens. Un fichier bundle.js compilé peut dépasser 100 000 tokens, soit une part considérable de votre fenêtre de contexte consommée par un seul fichier inutile.

# .gitignore - fichiers à exclure du contexte (Claude Code respecte le .gitignore par défaut)
node_modules/
*.lock
dist/
build/
*.min.js
*.map
coverage/

Pour comprendre ce qu'est le coding agentique et pourquoi la gestion des fichiers est centrale dans ce paradigme, consultez la FAQ dédiée.

À retenir : un .gitignore bien configuré peut économiser une part significative de votre budget de tokens en excluant les fichiers générés (Claude Code respecte le .gitignore par défaut).

Comment combiner CLAUDE.md et gestion du contexte pour des sessions productives ?

Rédigez un fichier CLAUDE.md concis (moins de 200 lignes) qui charge automatiquement les conventions critiques sans gaspiller de tokens. Ce fichier est la mémoire persistante de Claude Code entre les sessions.

CLAUDE.md est chargé au début de chaque session et consomme entre 500 et 2 000 tokens selon sa taille. Un fichier trop long gaspille du contexte. Un fichier trop court oblige l'agent à explorer le projet pour redécouvrir les conventions.

# CLAUDE.md - exemple optimisé (< 800 tokens)
## Stack
- Next.js 15, TypeScript 5.7, Tailwind CSS 4.0
## Conventions
- Tests avec Vitest, nommage : *.test.ts
- Commits conventionnels (feat:, fix:, chore:)
## Commandes
- npm run dev : serveur local
- npm run test : lancer les tests

SFEIR Institute propose une formation Claude Code d'une journée qui inclut un lab pratique sur la création d'un fichier CLAUDE.md optimisé et les techniques de gestion du contexte. Vous y apprendrez à configurer votre environnement pour maximiser la productivité de l'agent.

À retenir : gardez votre CLAUDE.md sous 200 lignes et 2 000 tokens pour charger les conventions essentielles sans gaspiller votre fenêtre de contexte.

Faut-il privilégier une longue session ou plusieurs courtes sessions ?

Privilégiez des sessions courtes et ciblées de 30 à 45 minutes pour maintenir un contexte propre et des réponses précises. Les sessions longues accumulent du bruit dans le contexte.

Une session de 2 heures atteint souvent 2 à 3 compactions, ce qui dilue progressivement la qualité du résumé. À l'inverse, des sessions de 30 minutes restent généralement sous les 80 000 tokens, loin du seuil de compaction.

Pour les développeurs qui souhaitent approfondir ces techniques et les pratiquer sur des cas réels, la formation Développeur Augmenté par l'IA de SFEIR (2 jours) couvre l'optimisation du contexte parmi d'autres compétences avancées d'intégration d'IA dans le workflow de développement.

À retenir : des sessions de 30 à 45 minutes avec des objectifs précis produisent de meilleurs résultats qu'une session marathon.

Comment le protocole MCP interagit-il avec la fenêtre de contexte ?

Chaque appel à un serveur MCP (Model Context Protocol) injecte sa réponse dans la fenêtre de contexte. Surveillez les outils MCP qui retournent de grands volumes de données pour éviter de saturer votre budget de tokens.

Le MCP permet à Claude Code de communiquer avec des services externes : bases de données, APIs, systèmes de fichiers distants. Chaque résultat d'outil MCP consomme des tokens proportionnellement à la taille de la réponse.

Un outil MCP qui retourne 500 lignes de résultats SQL consomme environ 4 000 tokens. Limitez les résultats avec des clauses LIMIT ou des filtres pour contrôler la consommation.

Pour configurer et comprendre le protocole MCP en détail, référez-vous à la FAQ MCP : Model Context Protocol. Si vous débutez avec Claude Code, commencez par la FAQ d'installation et premier lancement.

Pour maîtriser les interactions avancées entre MCP, contexte et agents, la formation Développeur Augmenté par l'IA – Avancé de SFEIR (1 jour) propose des labs dédiés à l'orchestration de serveurs MCP dans des workflows complexes.

À retenir : chaque réponse MCP consomme des tokens. Filtrez et limitez les résultats pour préserver votre fenêtre de contexte.

Y a-t-il une différence de coût entre les tokens d'entrée et de sortie ?

Oui, les tokens de sortie coûtent environ 5 fois plus cher que les tokens d'entrée sur la gamme Opus. Optimisez vos prompts pour réduire la longueur des réponses générées. Le modèle par défaut dépend de votre offre : Sonnet 4.6 sur Pro et Team Standard, Opus 4.8 sur Max, Team Premium, Enterprise et l'API.

Ce ratio entrée/sortie d'environ 1:5 se retrouve sur l'ensemble de la gamme : Opus est le plus capable et le plus coûteux, Sonnet offre un excellent compromis, et Haiku est le plus économique.

Concrètement, comme les tokens de sortie coûtent environ 5 fois plus que les tokens d'entrée, le mode Plan, qui limite les tokens de sortie, permet de réduire ce coût significativement. Reportez-vous à la grille tarifaire officielle d'Anthropic pour les tarifs exacts par modèle.

À retenir : les tokens de sortie coûtent environ 5 fois plus cher, le mode Plan et les prompts concis sont vos meilleurs alliés pour contrôler la facture.

Comment déboguer une session où le contexte semble "pollué" ?

Lancez une nouvelle session propre ou reprenez avec claude --continue quand les réponses de l'agent perdent en pertinence. Un contexte pollué se manifeste par des hallucinations ou des répétitions.

Trois signaux indiquent un contexte pollué : l'agent répète des informations déjà données, il mélange des fichiers de modules différents, ou il applique des conventions obsolètes d'un échange précédent. Ces symptômes apparaissent généralement après 2 compactions ou plus.

# Démarrer une session propre
$ claude

# Ou reprendre la dernière conversation
$ claude --continue  # ou claude -c

# Compacter manuellement en ciblant les informations utiles
> /compact Ne conserve que les modifications sur le module payments/

En pratique, démarrer une nouvelle session ciblée ne prend que quelques secondes et vous évite de longues minutes de réponses imprécises. C'est le réflexe le plus rentable en gestion du contexte. Les astuces de gestion du contexte proposent d'autres techniques de diagnostic.

À retenir : quand les réponses se dégradent, démarrez une session propre plutôt que de lutter contre un contexte pollué. C'est plus rapide et plus fiable.

---