#contexte-memoire — IA agentique

Fenêtre de contexte et mémoire d'agent : compter, tronquer, résumer, indexer.

Ce que tu vas manipuler

Bienvenue dans #contexte-memoire. Un LLM n'a pas de mémoire persistante : à chaque appel, on lui repasse tout ce qu'il doit savoir dans sa fenêtre de contexte, une file de tokens de taille bornée (8 k, 128 k, 1 M selon le modèle). Un agent qui tourne longtemps la remplit vite : prompt système, few-shot, historique user et assistant, observations d'outils, documents RAG. À l'écran : la barre = ta fenêtre, la ligne blanche = la limite du modèle, la jauge au-dessus = ton taux de remplissage, et en bas la mémoire externe (des documents indexés qu'on peut aller chercher au besoin). Tu vas la remplir, puis la comprimer.
Commence petit. Tape /modele llama-3 : la limite passe à 8 000 tokens. Sur les modèles à petite fenêtre, chaque token coûte cher — c'est là qu'on voit les stratégies de gestion.
Ajoute un message utilisateur. Tape /ajouter user Un long message user de test explicatif. Un bloc indigo apparaît, la jauge grimpe.
Les few-shot examples sont des paires question/réponse qu'on met en début de contexte pour montrer le format attendu. Tape /few-shot 3 : trois blocs verts arrivent d'un coup.
Passons au RAG (Retrieval-Augmented Generation). Plutôt que tout mettre dans le contexte, on indexe des documents dans une mémoire externe, et on n'apporte que les plus pertinents à chaque requête. Tape /rag documentation API REST : les 3 documents les plus proches (par similarité cosinus sur embeddings) s'allument dans la grille du bas et s'ajoutent au contexte en violet.
La fenêtre commence à se remplir. Première stratégie de compression : la sliding window. Tape /tronquer sliding : les plus anciens messages user/assistant disparaissent, le système et les few-shot sont préservés.
Alternative plus subtile : résumer au lieu de jeter. Tape /resumer 3 : les 3 plus anciens blocs user/assistant fusionnent en un bloc résumé dont le coût tombe à ~un quart des tokens d'origine.
Et si on avait 1 M de contexte ? Tape /modele gemini-flash : la limite explose, tout ce que tu as mis paraît minuscule dans la barre, la jauge redescend presque à zéro. Mais attention — coût : un contexte de 1 M à ~$0.30 le million de tokens en entrée, c'est ~$0.30 par appel rien que pour le contexte.
À toi. Essaie /strategie summary pour activer le résumé automatique quand tu dépasses, /purger-memoire pour vider l'index RAG, ou /reinit pour tout remettre à plat. Les canaux Premium #outils-appel (gratuit) et #planification-reflexion (Premium) montrent la suite : comment un agent choisit ses outils et planifie ses étapes en tenant compte de son contexte.

Commandes du canal

/modele <gpt-4o|claude-sonnet|gemini-flash|llama-3> — Change le modèle et donc la taille de la fenêtre de contexte.
/ajouter <systeme|user|assistant|observation> <texte> — Ajoute un bloc au contexte (message, observation, prompt système).
/few-shot <n=1..5> — Ajoute n exemples few-shot (paires question/réponse).
/rag <requete> — Cherche les 3 documents les plus proches dans la mémoire externe et les ajoute au contexte.
/tronquer <sliding|systeme-only> — Purge les plus anciens messages (garde ce qui est stable).
/resumer <n=2..5> — Remplace les n plus anciens blocs user/assistant par un résumé (~1/4 des tokens).
/strategie <sliding|summary|aucune> — Fixe la stratégie appliquée automatiquement quand la limite est dépassée.
/purger-memoire — Vide la mémoire externe (RAG). Les blocs rag déjà chargés dans le contexte restent.
/reinit — Remet le contexte à zéro (le modèle courant est conservé).

Glossaire

fenêtre de contexte: File de tokens qu'un LLM lit à chaque appel : instructions système, historique de conversation, retours d'outils, documents RAG. Sa taille est bornée par l'architecture (8 k pour un llama-3, 128 k pour un GPT-4o, 200 k pour un Claude, 1 M pour un Gemini Flash). Toute info qui ne rentre pas dedans est invisible pour le modèle à cet appel.
token: Unité de découpage du texte utilisée par un LLM (généralement un sous-mot BPE). En français, un token vaut environ 0.75 mot en moyenne — d'où l'approximation courante tokens ≈ mots × 1.3. C'est l'unité de facturation des APIs (par million de tokens en entrée et en sortie).
tokenisation vs comptage tokens: La tokenisation découpe un texte en tokens précis via un vocabulaire appris (BPE, SentencePiece, tiktoken). Le comptage peut être exact (en passant par le tokenizer du modèle) ou approché (mots × 1.3). Le canal #tokenisation détaille l'algorithme ; ici on approche pour rester léger.
sliding window: Stratégie de purge : quand la fenêtre est pleine, on jette les plus anciens messages user/assistant, en préservant le prompt système et les few-shot. Rapide, sans coût, mais l'information supprimée est perdue pour le modèle. Utilisée par Claude Code et Cursor pour tenir sur les sessions longues.
résumé (summarization): Alternative à la troncature : au lieu de jeter les anciens blocs, on demande à un LLM de les résumer, et on remplace les originaux par le résumé (~1/4 des tokens). L'information est comprimée, pas perdue. Coût : un appel LLM supplémentaire, et une perte de fidélité.
RAG (retrieval-augmented generation): Plutôt que tout mettre dans le contexte, on indexe les documents dans une base vectorielle (embeddings), et à chaque requête on ne charge que les k plus pertinents (similarité cosinus). C'est la parade principale contre la limite du contexte. Détaillé dans le canal #rag (Premium).
embedding: Représentation d'un texte sous forme de vecteur dans un espace de haute dimension (typiquement 384 à 3072). Deux textes de sens proche donnent des vecteurs proches. Ici, on utilise un embedding jouet déterministe (taille 8, dérivé du vocabulaire) — la mécanique similarité cosinus → top-k reste fidèle aux vrais modèles.
similarité cosinus: Métrique de proximité entre deux vecteurs, calculée comme le cosinus de leur angle : a · b / (‖a‖ · ‖b‖). Bornée dans [−1, 1] : 1 = identiques, 0 = orthogonaux, −1 = opposés. C'est l'opération élémentaire du RAG : elle sert à trier les documents indexés par pertinence à la requête.
mémoire de travail vs mémoire à long terme: La mémoire de travail = ce qui est dans la fenêtre de contexte à cet appel (immédiat, coûteux, borné). La mémoire à long terme = ce qui est indexé dans une base vectorielle externe, rappelé au besoin par RAG (persistant, presque illimité, mais nécessite une bonne requête). Un agent utile combine les deux.
coût par million de tokens: Unité tarifaire des APIs LLM. En 2026, un GPT-4o coûte environ 2,50 $ le million de tokens en entrée ; un Claude Sonnet ~3 $ ; un Gemini Flash ~0,15 $. La raison économique de gérer le contexte : un contexte 10× plus gros = un appel 10× plus cher. Un agent qui tourne 20 fois avec 100 k tokens de contexte coûte plus qu'un ticket de cinéma.

Autres canaux du thème IA agentique

#boucle-agentique — Boucle ReAct d'un agent : Pensée → Action → Observation en direct.
#outils-appel — Appel d'outil (function calling / MCP) : le JSON qui fait agir le LLM.
#slash-commands — Slash commands à la Claude Code / Cursor : templates, arguments, enchaînement.
#contexte-memoire — Fenêtre de contexte et mémoire d'agent : compter, tronquer, résumer, indexer.
#planification-reflexion — Planification, réflexion et self-correction : de 60 % à 90 % de succès.
#multi-agents — Multi-agents : planner, workers, verifier. Un DAG qui bat l'agent monolithique.