Open · gratuit

Context engineering : ce qu’il faut mettre dans le contexte d’un modèle

Décider ce que voit un modèle ou un agent, à quel moment, et ce qui reste en dehors

Intermedio10 chapitres2 heures de lectureattestation inclusemis à jour le

Un cours écrit complet sur le context engineering, indépendant de tout fournisseur : pourquoi la qualité d’une application fondée sur un modèle dépend de plus en plus de ce que le modèle a sous les yeux, et de moins en moins de la formulation de la demande. On y voit de quoi est fait le contexte, ce qu’il coûte en espace, en temps et en qualité, comment choisir les documents à inclure, comment résumer une longue session sans perdre ce qui compte, quand répartir le travail entre des contextes distincts, que conserver en mémoire d’une session à l’autre, comment concevoir les résultats des outils, comment protéger le contexte des contenus non fiables et comment mesurer l’effet de chaque choix. La réussite de l’épreuve finale donne droit à une attestation de suivi accompagnée d’un Open Badge vérifiable.

Ce que vous apprendrez7 objectifs
  • Expliquer ce qu’on entend par context engineering et pourquoi le problème s’est déplacé de la formulation du prompt vers le contenu du contexte
  • Décomposer le contexte d’un appel en ses composantes et les disposer selon leur stabilité, leur auteur et leur fiabilité
  • Reconnaître les coûts du contexte en espace, en latence et en qualité, et le traiter comme une ressource rare même quand la fenêtre est grande
  • Choisir entre préchargement et récupération à la demande, et reconnaître quand ne rien récupérer du tout
  • Concevoir un compactage qui conserve l’objectif, les contraintes, les décisions et les identifiants exacts
  • Utiliser des contextes séparés et une mémoire persistante sans perdre d’informations ni propager d’erreurs d’une session à l’autre
  • Protéger le contexte des contenus non fiables et mesurer l’effet des choix par des comparaisons et des expériences de suppression

Prérequis

  • Le cours Prompt engineering opérationnel, ou une expérience équivalente de la rédaction de prompts pour des systèmes réels
  • Le cours Agents IA : comment ils fonctionnent vraiment, ou une connaissance de base de la façon dont un agent utilise des outils dans une boucle
  • Savoir lire un JSON et un fichier texte structuré : on n’écrit pas de code pendant le cours

Chapitre 01

Du prompt au contexte : pourquoi le problème s’est déplacé

Pendant quelques années, la question pratique, avec les modèles de langage, a été de savoir comment rédiger la demande. Le prompt était presque tout ce que le modèle lisait : une instruction, peut-être quelques exemples, le texte à traiter. Améliorer le résultat voulait dire améliorer ces quelques lignes. Aujourd’hui, dans une application réelle, le texte écrit à la main par quelqu’un n’est souvent qu’une part minoritaire de ce que reçoit le modèle. Le reste provient des documents récupérés, de l’historique de la conversation, des définitions des outils, des résultats des appels précédents, de notes enregistrées lors de sessions passées. Le problème n’a pas disparu : il s’est déplacé de la manière d’écrire vers ce que l’on met dedans.

Context engineering, ou ingénierie du contexte, est le nom qui s’est répandu pour désigner ce travail : concevoir, à chaque appel, l’ensemble des informations que le modèle a sous les yeux. C’est une définition volontairement large. Elle englobe le choix des documents, la façon dont une longue conversation est résumée, les outils disponibles et le volume de ce qu’ils renvoient, ce dont on se souvient d’une session à l’autre et l’ordre dans lequel tout cela est présenté. Ce n’est pas une discipline inventée de toutes pièces : beaucoup de ses pratiques existaient déjà sous d’autres noms. Le terme est utile parce qu’il les réunit sous une seule question — que doit voir le modèle, maintenant, pour bien faire cette étape ? — au lieu de les traiter comme des problèmes séparés.

Si le problème a pris de l’ampleur, c’est surtout à cause des agents. Un appel isolé a un contexte que l’on conçoit une fois et qui ne bouge plus. Un agent, en revanche, travaille en boucle : à chaque étape, il lit, décide, appelle un outil, et le résultat s’ajoute à ce qu’il lira à l’étape suivante. Le contexte n’est plus un texte que vous écrivez, mais un état qui évolue, en partie par décision du modèle lui-même. Après de nombreuses étapes, il peut contenir des éléments que personne n’a choisis consciemment : des résultats devenus inutiles, des tentatives ratées, des pages lues une fois et plus jamais. Le cours Agents IA introduit ce problème dans son chapitre sur la mémoire et le contexte ; ici, on l’aborde comme un travail de conception à part entière.

Mieux vaut dire d’emblée ce que le context engineering n’est pas. Ce n’est pas remplir la fenêtre au maximum, en espérant que le modèle trouve seul ce dont il a besoin : plus de contexte ne signifie pas de meilleurs résultats, et le chapitre 3 explique pourquoi. Il ne remplace pas le prompt engineering : les instructions restent une partie du contexte, et il faut toujours bien les écrire — le cours Prompt engineering opérationnel en pose les bases. Et ce n’est pas une astuce de formulation pour convaincre le modèle : c’est une décision d’architecture, qui se prend plus souvent dans le code qui assemble l’appel que dans le texte des instructions.

La manière la plus utile d’y penser est celle d’un budget d’attention. Chaque élément du contexte est en concurrence avec les autres pour influencer la réponse. Un élément pertinent aide ; un élément hors sujet distrait ; un élément erroné ou périmé peut égarer le modèle avec autant de force qu’un élément correct. Le travail a donc deux faces : faire parvenir au modèle ce dont il a besoin, au moment où il en a besoin, et tenir tout le reste à l’écart. Les chapitres suivants suivent ce fil : de quoi est fait le contexte, ce qu’il coûte, comment on le choisit, comment on le résume, comment on le sépare, ce dont on se souvient, comment les outils le remplissent, quels risques il comporte et comment mesurer l’effet de chaque choix.

Chapitre 02

De quoi est fait le contexte : instructions, historique, documents, outils, mémoire

Avant de décider quoi inclure, il faut savoir ce qu’il y a. Dans le contexte d’un appel à un modèle, on reconnaît généralement cinq familles de contenu. Les instructions : règles, rôle, format, contraintes, écrites par celui qui construit l’application. L’historique : les tours précédents de la conversation ou les étapes précédentes de l’agent, y compris ses appels. Les documents : du matériel de référence inséré pour cette demande, récupéré dans une base de connaissances ou joint par l’utilisateur. Les outils : les définitions de ce que le modèle peut appeler, et les résultats des appels déjà effectués. La mémoire : des informations conservées lors de sessions précédentes et réintroduites au début de celle-ci.

Les classer est utile parce qu’elles diffèrent selon trois axes qui guident toutes les décisions suivantes. Le premier est l’auteur : les instructions, c’est vous qui les écrivez ; les documents et les résultats des outils sont souvent écrits par quelqu’un d’autre ; la mémoire peut avoir été écrite par le modèle lui-même. L’auteur détermine jusqu’à quel point on peut se fier à un contenu, sujet du chapitre 9. Le deuxième est la stabilité : les instructions changent rarement, l’historique s’allonge à chaque étape, les documents changent à chaque demande. Le troisième est qui décide qu’un contenu entre : certaines parties sont insérées par le code de façon déterministe, d’autres sont choisies par le modèle quand il appelle un outil de recherche ou de lecture.

La disposition logique d’un contexte, de ce qui ne change jamais à ce qui change à chaque étape. Les API l’expriment dans des champs différents, mais le modèle la lit comme un tout.text
[INSTRUCTIONS SYSTÈME]           stable · écrites par vous
  rôle, règles, format, interdits

[DÉFINITIONS DES OUTILS]         stable · écrites par vous ou par un serveur externe
  rechercher_documents, lire_commande, ...

[MÉMOIRE]                        change rarement · écrite lors de sessions passées
  conventions du projet, préférences de l’utilisateur

[DOCUMENTS DE CETTE DEMANDE]     change à chaque demande · auteurs externes
  <document id="POL-07" source="intranet" date="2026-03-02"> ... </document>

[HISTORIQUE ET RÉSULTATS]        s’allonge à chaque étape · en partie non fiable
  tours précédents, appels aux outils, résultats

[DEMANDE EN COURS]               change à chaque étape

L’ordre n’est pas un détail esthétique. Placer en tête les parties stables et à la fin les parties variables présente un avantage pratique : beaucoup de fournisseurs proposent une forme de cache du préfixe, qui réutilise le traitement de la partie initiale du contexte quand elle reste identique d’un appel à l’autre, avec une économie de coût et de temps. Une donnée variable insérée en tête — une heure, un identifiant de session — rend différent tout ce qui suit et annule l’avantage. Il y a aussi un effet sur la qualité : on observe souvent en pratique que la demande placée après les longs documents, vers la fin du contexte, est mieux suivie que celle placée avant. Ce que cela pèse dans votre cas, c’est l’évaluation du chapitre 10 qui le dira, pas une règle générale. Il en va de même pour les contenus de fiabilité différente : garder les instructions séparées des contenus externes, jamais mélangées, montre clairement au modèle — et à qui relit les logs — où s’arrêtent les règles et où commence le matériel à traiter.

Une dernière distinction évite bien des erreurs : celle entre ce que voit le modèle et ce que sait le système. Le système peut disposer de tout l’historique d’un client, de tous les fichiers d’un projet, du résultat complet de chaque outil. Le modèle ne voit que ce qui se trouve dans la fenêtre à ce moment-là. Garder les données complètes hors du contexte et n’en faire entrer qu’une vue — un extrait, un résumé, une référence à partir de laquelle récupérer le reste — est le geste fondamental de tout ce cours. Ce qui n’est pas dans le contexte n’est pas perdu : il n’a simplement pas encore été chargé, et on peut le charger quand il le faut.

Chapitre 03

Le contexte a un coût : espace, latence et une qualité qui baisse quand il grandit

Chaque élément du contexte a trois coûts, et seul le premier se voit tout de suite. Le premier est l’espace : la fenêtre de contexte est finie, et tout ce qui y entre — instructions, définitions des outils, documents, historique — prend de la place au reste. Dans un agent, la facture s’alourdit à chaque étape, parce que chaque résultat s’ajoute et, en général, reste. Les définitions des outils sont un coût qu’on oublie souvent : elles occupent de l’espace à chaque appel, même dans ceux où aucun outil n’est utilisé, et un agent relié à de nombreux outils peut dépenser une part importante de la fenêtre rien que pour savoir ce qu’il pourrait faire.

Le deuxième coût est en argent et en temps. Dans la plupart des API, on paie en proportion du texte en entrée, et un texte plus long demande plus de temps de traitement avant que n’arrive le premier mot de la réponse. Dans un agent, ces coûts se multiplient : chaque étape relit l’intégralité du contexte accumulé jusque-là, si bien qu’un résultat volumineux obtenu au début se paie de nouveau à chaque étape suivante. Le cours Prompt engineering opérationnel décrit les leviers généraux sur le coût et la latence ; ici compte un point précis : dans la boucle d’un agent, le coût d’un élément ne dépend pas seulement de sa taille, mais du nombre d’étapes pendant lesquelles il reste dans le contexte.

Le troisième coût est le moins intuitif et le plus important : la qualité. Il serait naturel de penser qu’un modèle qui dispose de plus d’informations répond mieux, ou au pire aussi bien. En pratique, on observe souvent le contraire. Avec des contextes très longs, les modèles tendent à exploiter de façon moins fiable ce qu’ils contiennent : un détail présent dans la fenêtre peut être négligé, surtout s’il se trouve au milieu de beaucoup de matériel similaire ; des instructions données au début peuvent être suivies avec moins de constance après de nombreuses étapes ; une information périmée restée dans le contexte peut l’emporter sur l’information à jour. Parmi ceux qui construisent ces systèmes, le phénomène est parfois appelé context rot, la dégradation du contexte. Son ampleur varie d’un modèle à l’autre et d’une tâche à l’autre, et les modèles s’améliorent ; la tendance est toutefois assez récurrente pour qu’il faille la prendre en compte dès la conception, et non l’ignorer.

Une façon intuitive de le comprendre est de voir l’attention du modèle comme une ressource répartie sur tout ce qu’il lit. Le matériel hors sujet n’est pas neutre : il entre en concurrence avec le matériel pertinent, et d’autant plus fortement qu’il lui ressemble. C’est pourquoi les pires dégâts ne viennent pas du bruit évident, que le modèle écarte facilement, mais du matériel plausible et erroné : l’ancienne version d’un contrat, le résultat d’une recherche sur un client homonyme, une hypothèse écartée de nombreuses étapes plus tôt mais restée écrite dans l’historique, deux procédures presque identiques dont l’une ne s’applique plus.

D’où la règle qui soutient le reste du cours : l’espace de contexte se traite comme une ressource rare, même quand la fenêtre est grande. Une fenêtre plus vaste relève la limite technique, elle ne rend pas gratuit ce qu’on y met. L’objectif n’est pas le contexte le plus court possible, mais le plus petit ensemble d’informations qui rend probable le bon résultat. Parfois cet ensemble est grand — l’analyse d’un long contrat exige le contrat entier — et il faut alors l’inclure sans hésiter. Ce qu’il faut éviter, c’est l’inclusion par inertie : le matériel qui n’est là que parce que personne n’a décidé de le retirer.

Chapitre 04

Choisir quoi inclure : récupérer les bons documents, et savoir quand s’en abstenir

Pour le matériel de référence, il existe deux stratégies, et presque tous les systèmes réels les combinent. Le préchargement insère les informations avant que le modèle ne commence : le code choisit les documents — par exemple au moyen d’une recherche sur la question de l’utilisateur — et les place dans le contexte. La récupération à la demande, elle, donne au modèle des outils pour chercher et lire, et le laisse décider quoi charger et quand. Le premier est prévisible, rapide et facile à contrôler ; la seconde est souple et ne charge que ce qui sert, mais demande plus d’étapes et dépend de la capacité du modèle à bien chercher. Le cours Agents IA présente la récupération à la demande comme le choix habituel pour les agents ; ici, on voit comment choisir au cas par cas.

Le critère pratique est le degré de prévisibilité du besoin. Si l’on sait à l’avance ce dont un certain type de demande a besoin — le règlement interne pour une question sur les congés, la fiche du client pour un ticket —, le préchargement est le choix le plus simple et le plus fiable. Si le besoin ne se découvre qu’en travaillant — enquêter sur une erreur dans une base de code, répondre à une question qui traverse plusieurs documents —, la récupération à la demande évite de tout charger de peur d’oublier quelque chose. Une voie intermédiaire qui fonctionne bien consiste à précharger des références légères plutôt que les contenus : la liste des documents disponibles, les chemins des fichiers, les titres avec une ligne de description. Le modèle sait ce qui existe et décide quoi ouvrir.

Des références légères préchargées à la place des documents : quelques caractères par entrée, et la révision remplacée est signalée au lieu d’être laissée en concurrence avec la révision en vigueur.text
Documents disponibles (à ouvrir avec lire_document(id)) :
- POL-07  Politique de remboursement, en vigueur    remboursements, retours, délais
- POL-12  Conditions du contrat Business            niveaux de service, pénalités
- FAQ-03  Questions fréquentes sur la facturation   TVA, avoirs
- ARC-01  Politique de remboursement, précédente    REMPLACÉE par POL-07

Quand on récupère, la qualité de ce qui arrive compte plus que la quantité. Un bon résultat de recherche a trois propriétés. Il est pertinent : un passage qui répond à la question, pas un document entier où la réponse se trouve quelque part. Il est contextualisé : il porte avec lui sa source, sa date et sa position, afin que le modèle sache d’où il vient et puisse le citer, et qu’un fragment extrait d’un tableau ou d’une liste reste compréhensible hors de son document. Il est non redondant : dix passages presque identiques prennent la place de dix informations différentes. Récupérer peu de bons résultats et laisser le modèle en demander d’autres si nécessaire fonctionne en général mieux que d’en récupérer beaucoup de médiocres.

La décision la plus négligée est celle de ne rien récupérer du tout. Toutes les demandes n’ont pas besoin de documents : une reformulation, un calcul, une question de clarification à l’utilisateur. Un système qui lance toujours une recherche remplit le contexte de matériel vaguement lié, que le modèle se sent ensuite tenu d’utiliser. Mieux vaut aussi ne rien récupérer quand l’information est déjà dans le contexte, ou quand la seule source disponible est périmée et qu’un « je ne sais pas » est préférable à une réponse fondée sur une donnée ancienne. Et il faut garder à l’esprit la limite déjà vue dans le cours Prompt engineering opérationnel : si la recherche documentaire n’a pas trouvé le bon passage, aucune instruction ne peut compenser. La recherche documentaire doit donc être mesurée à part, comme le montre le chapitre 10.

Chapitre 05

Résumer sans perdre : le compactage, et ce qu’il ne faut jamais couper

Le compactage est la réponse la plus directe au contexte qui grandit : à un certain moment, l’historique accumulé est remplacé par une version condensée de lui-même, et le travail continue à partir de là. Le cours Agents IA en décrit le principe et l’ordre de priorité de ce qu’il faut conserver. Ce qui nous intéresse ici, c’est la manière de le concevoir, car un compactage mal fait est pire que pas de compactage du tout : un contexte long est lent et coûteux, mais il contient encore tout ; un résumé qui a perdu une contrainte contient une erreur que personne ne verra plus, parce que la version complète n’est plus sous les yeux du modèle.

Il en existe plusieurs formes, à utiliser par ordre d’agressivité. La plus légère est le nettoyage des résultats : les résultats d’outils déjà exploités — une page lue, la sortie d’une commande — sont remplacés par un marqueur qui rappelle que l’appel a eu lieu et comment le refaire. Elle est sûre parce qu’elle ne réécrit rien : elle retire du matériel que l’on peut récupérer. Plus incisif est le compactage par résumé, dans lequel un modèle réécrit l’historique sous forme de note structurée. La plus radicale consiste à repartir d’un contexte neuf qui ne contient que cette note et l’état enregistré à l’extérieur, dans des fichiers ou dans le système, comme le fichier d’avancement vu pour les tâches longues. Les formes réversibles s’utilisent avant celles qui réécrivent.

Le point critique, c’est ce qu’on ne coupe jamais. L’objectif dans les mots de l’utilisateur, sans paraphrase : chaque paraphrase déplace un peu le sens, et après quelques compactages l’objectif est devenu un autre. Les contraintes explicites, avec qui les a posées. Les décisions prises et leur motif, car sans le motif le modèle les remettra en question. Les identifiants exacts — noms de fichiers, numéros de commande, codes — qu’un résumé a tendance à approximer. Les pistes tentées et écartées, qui sinon seront tentées de nouveau. Les questions encore ouvertes. On peut en revanche retirer le détail des étapes réussies, déjà reflété dans l’état du travail, et les contenus bruts que l’on peut relire à la source.

Un modèle de note de compactage à sections fixes : une section vide se remarque, une omission dans un texte libre non.markdown
## Objectif (les mots de l’utilisateur, ne pas paraphraser)
« Aligne les prix de la grille tarifaire B2B sur le nouveau taux de change,
sans toucher aux clients sous contrat bloqué. »

## Contraintes (et qui les a posées)
- Ne pas modifier les clients sous contrat bloqué (utilisateur, début de session)
- Arrondi comme dans la grille actuelle (comptabilité, e-mail transféré)

## Décisions prises et pourquoi
- Nous travaillons sur une copie de la grille : l’original alimente le site

## État
- Fait : première moitié des lignes mise à jour et vérifiée
- Suivant : seconde moitié, puis comparaison des totaux avec l’original

## Tenté et écarté
- Import direct via l’API : elle refuse les fichiers de cette taille

## Questions ouvertes
- Les prix en francs suisses suivent-ils le même taux ? (demandé, pas de réponse)

## Références exactes
grille_b2b_copie.xlsx · clients_bloques.csv

Deux précautions rendent le compactage vérifiable. La première est de donner au résumé une structure fixe, comme celle ci-dessus, au lieu de demander de façon générique de « résumer la conversation ». La seconde est de contrôler la note avant de remplacer l’historique, au moins dans les flux importants : vérifier dans le code que les identifiants présents dans l’historique figurent aussi dans la note, et conserver l’historique complet hors du contexte, dans les logs, pour qu’une perte puisse être diagnostiquée. Le moment compte autant que le contenu : compacter à un point de passage naturel — une sous-tâche terminée, une phase close — fait perdre moins que compacter au milieu d’un raisonnement simplement parce que la fenêtre s’est remplie. Enfin, les instructions qui produisent le résumé sont elles aussi un prompt : il faut les tester sur des historiques réels, en comparant ce que le modèle parvient à faire après le compactage avec ce qu’il faisait avant, selon la méthode du chapitre 10.

Chapitre 06

Séparer les contextes : sous-agents et tâches isolées

Le compactage réduit le contexte une fois qu’il s’est rempli. La séparation évite qu’il se remplisse : une tâche qui exige beaucoup de matériel mais produit un petit résultat est exécutée dans un contexte à part, et seul le résultat entre dans le contexte principal. C’est la même idée qu’une fonction dans un programme, qui travaille avec des variables locales et renvoie une valeur. Le cours Agents IA examine quand un système multi-agents est rentable en général ; ici, on le regarde sous un seul angle : ce qui entre dans chaque contexte, et ce qui passe de l’un à l’autre.

Les candidats naturels sont les tâches exploratoires dans lesquelles ce qu’on lit dépasse de loin ce qu’on renvoie. Chercher dans une base de code où naît une certaine erreur peut obliger à ouvrir de nombreux fichiers, presque tous hors sujet ; la réponse utile tient en quelques lignes. Examiner un long document pour en extraire les clauses sur les pénalités suit le même schéma. Effectuées dans le contexte principal, ces tâches le laissent plein de matériel lu une seule fois ; effectuées dans un contexte séparé, elles ne laissent que la réponse. Le critère est simple : si, de tout ce qu’une tâche lit, seule une petite partie servira ensuite, cette tâche est un bon candidat. Quand les sous-tâches sont réellement indépendantes, les contextes séparés peuvent aussi travailler en parallèle et réduire le temps total ; le coût total, lui, ne baisse pas.

Le contexte d’un sous-agent, c’est exactement ce qui est écrit dans sa tâche, plus ce qu’il lit lui-même. Il ne voit pas la conversation principale, ne sait pas ce que l’utilisateur a dit de nombreux tours plus tôt, ne connaît pas les contraintes qu’on ne lui transmet pas. C’est pourquoi le texte de la délégation relève pleinement du context engineering : il doit suffire à quelqu’un qui ne sait rien d’autre. Le format de retour est tout aussi important, et doit être demandé explicitement : ce qu’il a trouvé, avec les références exactes pour le vérifier, où il a cherché sans trouver, et quel est son degré de certitude. Un sous-agent laissé libre tend à renvoyer le récit de son propre travail, et ce récit finit dans le contexte principal.

Une délégation qui contient tout le contexte nécessaire et fixe la forme du résultat, afin que seul ce qui sert entre dans le contexte principal.text
TÂCHE
Trouver où l’application génère l’erreur « session expirée »
juste après la connexion.

DÉJÀ CONNU, À NE PAS REFAIRE
- Le délai d’expiration de session dans le fichier de configuration est correct : vérifié.

CONTRAINTES
- Lecture seule : ne modifier aucun fichier.

RENVOYER, EN QUELQUES LIGNES
- Trouvé : fichier et ligne de chaque endroit où l’erreur prend naissance
- Pourquoi c’est selon vous la cause, en deux phrases
- Cherché sans trouver : où vous avez regardé
- Certitude : haute / moyenne / basse

La séparation a des coûts qu’il faut prendre en compte. Chaque passage de relais perd de l’information : ce que le sous-agent ne rapporte pas n’existe pas pour le contexte principal. Le travail total augmente, parce que le sous-agent reconstruit de lui-même une partie du contexte que le principal avait déjà. Et deux contextes séparés qui travaillent sur le même objet prennent des décisions implicites différentes qu’aucun des deux ne voit. Il en découle une règle pratique : séparer les tâches qui lisent beaucoup et décident peu, garder ensemble celles qui décident beaucoup. Quand plusieurs contextes doivent partager des informations volumineuses, mieux vaut les faire transiter par un fichier ou un espace de stockage que chacun lit quand il en a besoin, plutôt que de les copier dans chaque message. Enfin, le résultat d’un sous-agent se traite comme celui d’un outil : une entrée à vérifier, surtout s’il a lu des contenus non fiables.

Chapitre 07

La mémoire entre les sessions : quoi enregistrer, comment le relire, comment arrêter une erreur

Chaque session d’un modèle part de zéro : ce qui ressemble à de la mémoire est toujours un contenu que le système réintroduit dans le contexte, qu’il s’agisse d’une note enregistrée, d’un profil ou d’un fichier de projet. La mémoire est donc un cas particulier du problème de tout ce cours, avec une complication supplémentaire : celui qui décide quoi enregistrer le fait dans une session, et celui qui le relit le fait dans une autre, sans savoir dans quelles conditions la note a été écrite. Le cours Agents IA explique pourquoi la mémoire persistante est utile et délicate ; ici, on voit comment la concevoir.

Ce qui vaut la peine d’être enregistré, c’est ce qui est coûteux à redécouvrir, stable dans le temps et utile sur plusieurs sessions. En pratique, cela tient en quelques catégories : des faits sur l’environnement, comme l’organisation d’un projet ou la commande qui lance les tests ; les préférences et les décisions de l’utilisateur, à ne pas lui reproposer chaque fois ; les leçons apprises, comme un problème déjà diagnostiqué ou une approche qui ne fonctionne pas. Ne valent pas la peine d’être enregistrés ce qu’on retrouve en un instant à la source, ce qui change souvent — le statut d’un ticket, un solde — ni les données personnelles ou confidentielles qui ne doivent pas passer d’un contexte à l’autre. L’état d’une tâche en cours a déjà son outil adapté, le fichier d’avancement, qui vit et meurt avec la tâche.

Chaque entrée devrait indiquer d’où elle vient et quand elle a été écrite. Une note sans source ni date est relue comme un fait ; la même note, avec l’indication du fichier et du jour où la chose a été observée, est relue comme une observation à revérifier si du temps a passé. Il est utile aussi de séparer ce qui a été observé de ce qui a été déduit : « le test échoue de façon intermittente » est une observation ; « le test échoue à cause d’un problème réseau » est une hypothèse, et l’enregistrer comme un fait la transforme en certitude pour toutes les sessions futures.

Un fichier de mémoire lisible par une personne : chaque entrée a une source et une date, et les hypothèses sont tenues à l’écart des leçons vérifiées.markdown
# Mémoire de projet : portail clients
<!-- Chaque entrée a une source et une date. Avant d’agir sur une
     entrée ancienne, relisez la source. -->

## Environnement
- Les tests se lancent avec « make test », pas avec la commande par défaut
  (source : Makefile, 2026-10-14)

## Décisions de l’utilisateur
- Aucune nouvelle dépendance sans demander (utilisateur, 2026-10-02)

## Leçons vérifiées
- L’export CSV échouait sur les noms accentués : problème d’encodage,
  corrigé dans export.py (observé et vérifié, 2026-10-20)

## Hypothèses non vérifiées
- La lenteur de la connexion pourrait venir du cache
  (déduit, non vérifié, 2026-10-21)

Relire la mémoire pose le même problème qu’au chapitre 4 : la charger en entier à chaque session remplit le contexte de notes sans rapport avec la tâche du jour. Quand elle grandit, mieux vaut ne charger au démarrage qu’un index court et les entrées toujours valables, et laisser le reste à une recherche à la demande. Il faut aussi l’entretenir : fusionner les doublons, corriger les entrées dépassées, supprimer celles qui ne servent à rien. Le risque spécifique, cependant, est la propagation. Une erreur dans le contexte d’une session meurt avec la session ; une erreur enregistrée en mémoire est relue à chaque session suivante avec l’autorité de quelque chose que le système sait, et peut engendrer de nouvelles notes qui la confirment. Les défenses relèvent du processus : n’enregistrer que ce qui est vérifié, ou le marquer comme hypothèse ; relire la source avant d’agir sur une entrée importante ou ancienne ; rendre la mémoire lisible et modifiable par une personne ; et ne pas laisser des contenus non fiables y entrer sans contrôle, sujet du chapitre 9.

Chapitre 08

Les outils comme contexte : descriptions, résultats et quantité à renvoyer

Un outil entre deux fois dans le contexte. La première fois par sa définition — nom, description, paramètres — que le modèle lit à chaque appel où l’outil est disponible. La seconde par ses résultats, qui restent dans le contexte pendant toutes les étapes suivantes. Celui qui conçoit un outil écrit donc du contexte, même s’il pense écrire une API. Les cours Agents IA et Prompt engineering opérationnel expliquent comment rédiger une bonne description et pourquoi les erreurs doivent être lisibles ; ici, on se concentre sur le volume et la forme de ce qui entre.

Côté définitions, le problème est la quantité. Chaque outil disponible occupe de l’espace même quand il n’est pas utilisé, et des outils similaires se font concurrence au moment du choix. Relier un agent à tout ce qui pourrait lui servir, par précaution, dégrade à la fois le coût et le choix. Il y a trois parades : n’offrir pour chaque tâche que le sous-ensemble d’outils pertinent ; regrouper en un seul outil les opérations que le modèle utiliserait toujours à la suite ; et, quand les outils sont vraiment nombreux, charger leurs définitions à la demande, en donnant au modèle un moyen de chercher le bon outil au lieu de tous les énumérer. Certaines plateformes proposent cette recherche comme fonction intégrée, mais on peut aussi la construire dans le code qui assemble l’appel.

Côté résultats, la question est : de quoi le modèle aura-t-il besoin aux étapes suivantes ? Presque jamais du résultat brut. Une API renvoie des dizaines de champs techniques, des identifiants internes illisibles, des métadonnées de pagination, des valeurs nulles ; le modèle a besoin des champs utiles pour décider, de noms reconnaissables et d’un identifiant à réutiliser dans les appels suivants. Les deux résultats ci-dessous répondent au même appel : le second occupe une fraction de l’espace, se lit sans ambiguïté et indique quoi faire pour obtenir le reste. Les identifiants lisibles comptent plus qu’il n’y paraît : un code court et parlant se recopie d’une étape à l’autre avec moins de risques qu’une longue chaîne aléatoire, et un identifiant mal recopié produit un appel erroné qui a toutes les apparences d’un appel correct.

Le résultat brut d’une API, transmis tel quel : identifiants illisibles, codes de statut numériques, montants en centimes, champs internes.json
{
  "data": [{
    "id": "8f3a2c1e-77b0-4d2e-9a51-0c6e2b9f1d44",
    "obj_type": "order",
    "created_ts": 1760003421,
    "updated_ts": 1760091877,
    "cust_ref": "a91e0f52-3b7c-4c11-8e2d-5f0a9b6c7d18",
    "status_cd": 4,
    "lines": [ ...trente-sept objets de dix champs chacun... ],
    "shipping": { "carrier_id": 12, "tracking": null, "addr_id": "c3d9e1f0" },
    "internal_flags": { "legacy_import": false, "audit_rev": 17 },
    "currency": "EUR",
    "total_cents": 184500
  }],
  "page": { "cursor": "eyJvZmZzZXQiOjUwfQ==", "has_more": true }
}
Le même résultat réduit à ce qui sert : noms lisibles, identifiants réutilisables, et une note qui déclare que le résultat n’est pas complet et comment poursuivre.json
{
  "commandes": [
    {
      "commande": "ORD-2291",
      "client": "Ferri Ameublement (C-10482)",
      "statut": "expédiée, suivi pas encore disponible",
      "date": "2026-10-09",
      "total": "1 845,00 EUR",
      "lignes": 37
    }
  ],
  "complet": false,
  "note": "Ce client a d’autres commandes. Pour les voir : rechercher_commandes(client='C-10482', page=2). Pour les lignes d’une commande : lire_commande(commande='ORD-2291')."
}

Trois précautions complètent le tableau. La première est de laisser au modèle le choix du niveau de détail, au moyen d’un paramètre explicite — une réponse synthétique par défaut et une réponse détaillée sur demande — au lieu de trancher une fois pour toutes. La deuxième concerne les résultats inévitablement volumineux, comme un fichier de log ou le résultat d’une requête large : au lieu de les déverser dans le contexte, l’outil peut les enregistrer à l’extérieur, dans un fichier ou un espace de stockage, et renvoyer un récapitulatif avec une référence permettant d’en lire une partie. La troisième, déjà vue dans le cours Agents IA, est de ne jamais tronquer en silence : une liste coupée sans le dire pousse le modèle à conclure qu’il n’existe rien d’autre, et c’est une cause fréquente de réponses fausses données avec assurance. Un résultat bien conçu dit toujours s’il est complet.

Chapitre 09

Contexte et sécurité : des contenus non fiables dans la fenêtre

Le chapitre 2 a classé le contexte par auteur. Sur le plan de la sécurité, ce classement devient décisif, pour une raison que les cours Agents IA et Prompt engineering opérationnel ont déjà introduite : le modèle ne distingue pas de façon fiable les instructions de celui qui l’utilise du texte qu’il lit en travaillant. Tout contenu présent dans la fenêtre peut influencer son comportement, quel qu’en soit l’auteur. Du point de vue du context engineering, il en découle un principe simple : chaque canal qui apporte du contenu dans le contexte est une porte d’entrée possible, et doit être traité en fonction de qui peut y écrire.

Les portes sont plus nombreuses qu’il n’y paraît. Il y a les évidentes : pages web, e-mails, documents téléversés, résultats de recherche. Il y en a de moins évidentes : les descriptions des outils fournis par des serveurs tiers, que le modèle lit comme des instructions et qui peuvent en contenir de malveillantes ; les résultats d’un sous-agent qui a lu du matériel non fiable ; et surtout les textes que le système produit lui-même en retravaillant des contenus externes, comme une note de compactage ou une entrée de mémoire. Ces derniers sont les plus insidieux, parce qu’ils effacent la provenance : une instruction cachée dans une page, une fois résumée, devient une phrase du système ; enregistrée en mémoire, elle est relue lors des sessions futures comme une connaissance propre.

La première parade consiste à conserver la provenance tout au long du parcours. Les contenus externes entrent délimités et étiquetés avec leur source ; les instructions de compactage demandent de rapporter ce qui vient de sources non fiables comme un contenu attribué à cette source, jamais comme un fait établi ni comme une tâche à accomplir ; les entrées de mémoire nées de contenus externes ne sont pas enregistrées sans contrôle. Aucune de ces mesures ne rend le modèle immunisé : elles servent à ne pas perdre une information que les défenses suivantes, et les personnes qui relisent, doivent pouvoir utiliser.

La seconde parade, plus robuste, est architecturale : limiter ce que peut faire un contexte exposé à des contenus non fiables. Le schéma le plus solide sépare la lecture de l’action. Un contexte de lecture, sans outils ayant des effets et sans accès aux données confidentielles, traite le contenu externe et ne renvoie que des données structurées, avec des champs fermés et des valeurs que le code valide. Le contexte qui agit reçoit ces champs, pas le texte d’origine. Une instruction cachée dans un e-mail pourrait peut-être fausser la classification, mais elle n’arrive pas sous forme de texte libre au contexte qui a les permissions d’agir, et une valeur hors de l’ensemble autorisé est écartée par le code.

Ce que renvoie le contexte de lecture après avoir traité un e-mail : des champs fermés, validés par le code. Le texte libre de l’e-mail ne passe pas au contexte qui agit.json
{
  "expediteur_client_connu": true,
  "categorie": "demande_remboursement",
  "numero_commande": "ORD-2291",
  "montant_demande_eur": 184.50,
  "langue": "fr"
}

Enfin, le contexte doit aussi être considéré comme un lieu d’où les informations peuvent sortir. Tout ce qui s’y trouve peut finir, par erreur ou par manipulation, dans une réponse, dans le paramètre d’un appel, dans un log. Il en découle deux règles. Ne pas mettre dans le contexte de secrets que le modèle n’a pas à utiliser : clés, mots de passe et jetons restent dans le code qui exécute les outils, et le modèle reçoit au plus une référence. Et n’inclure que les données personnelles nécessaires à la tâche, car le principe de minimisation vaut pour le contexte comme pour tout autre traitement. Les règles qui comptent, comme le rappellent les cours précédents, s’appliquent dans le code : le contexte informe le modèle, il ne le contraint pas.

Chapitre 10

Mesurer l’effet : évaluer les choix de contexte avant et après

Chaque choix de ce cours — quoi récupérer, quand compacter, quoi déléguer, combien renvoyer — est une hypothèse. Ils paraissent tous raisonnables, et c’est précisément pour cela qu’il faut les vérifier : un résumé plus agressif peut économiser de l’espace et perdre une contrainte justement dans le cas qui compte ; un document de plus peut aider sur une question et semer la confusion sur une autre. Les cours Prompt engineering opérationnel et Agents IA expliquent comment construire un ensemble de cas d’évaluation et quoi mesurer. Ici, on voit comment l’utiliser pour les décisions sur le contexte, qui ont quelques particularités.

La comparaison se fait toutes choses égales par ailleurs : mêmes cas, même modèle, mêmes instructions, et seul le choix de contexte change. Pour chaque configuration, il est utile de mesurer ensemble quatre choses : la qualité du résultat, y compris les échecs graves ; la quantité de contexte utilisée ; le coût et le temps par tâche ; et, pour les agents, le nombre d’étapes. Il faut les lire ensemble parce que les choix de contexte déplacent presque toujours l’équilibre entre elles : une configuration peut être un peu moins précise et beaucoup moins chère, ou plus précise mais trop lente. Le compromis acceptable se décide avant de regarder les résultats.

Une comparaison illustrative, avec des données fictives : deux stratégies de récupération sur les mêmes cas, avec qualité, contexte, étapes et coût lus ensemble, et les cas dégradés listés à part.text
Comparaison illustrative, données fictives
A : dix passages préchargés
B : trois passages préchargés + recherche à la demande
Mêmes 60 cas, même modèle, mêmes instructions, chaque cas exécuté 3 fois

                               A            B
Cas résolus correctement      51           53
Échecs graves                  3            1
Contexte moyen par cas        élevé        faible
Étapes moyennes par cas       1,0          1,6
Coût moyen par tâche          plus élevé   plus faible

Dégradés en passant de A à B : 2 cas (dans les deux, le modèle
n’a pas cherché le document qui lui manquait)

Pour le contexte, la technique la plus instructive est l’expérience de suppression : retirer un composant à la fois — une section des instructions, la mémoire, un groupe d’outils, les documents récupérés — et relancer les cas. Si les résultats ne changent pas, ce composant ne travaillait pas et on peut le retirer, avec une économie à chaque appel. S’ils se dégradent, on sait à quoi il sert. Une variante utile pour les agents consiste à faire grossir délibérément le contexte, en ajoutant de l’historique ou des documents hors sujet mais plausibles, pour voir à partir de quel point la qualité commence à baisser : c’est ainsi que l’on passe de la tendance générale du chapitre 3 à un seuil mesuré sur votre propre système.

Le résultat final ne suffit pas : pour les choix de contexte, ce sont les traces qui comptent. Pour chaque cas en échec, la question utile est de savoir si l’information nécessaire était dans le contexte au moment de la décision. Si elle n’y était pas, le problème est un problème de sélection : la récupération, la délégation, le compactage ou la mémoire l’ont perdue ou ne l’ont pas apportée. Si elle y était et a été ignorée, le problème est un problème de présentation ou de surcharge : trop de matériel concurrent, une position défavorable, une information contredite par une autre. Les deux diagnostics mènent à des corrections opposées — ajouter dans le premier cas, retirer ou réordonner dans le second —, et c’est pourquoi il est utile d’enregistrer, pour chaque appel, le contexte exact que le modèle a reçu.

Quelques habitudes complètent le tableau : inclure parmi les cas ceux qui mettent le contexte sous pression, comme des sessions qui exigent un compactage, des redémarrages à partir de la mémoire, des documents en versions contradictoires, des contenus contenant des instructions cachées ; exécuter chaque cas plusieurs fois, parce que la variabilité entre exécutions peut être aussi grande que l’effet recherché ; et tout refaire quand le modèle change, parce que le meilleur choix pour un modèle peut ne pas l’être pour le suivant.

Épreuve finaleseuil 80%

Obtenez votre attestation

Réussissez l’épreuve finale en répondant correctement à au moins 80 % des questions. L’attestation est délivrée automatiquement et reste vérifiable en ligne grâce à un lien permanent : il s’agit d’un Open Badge conforme à la norme 2.0, que vous pouvez ajouter à LinkedIn et à vos portefeuilles numériques de compétences.

Aucune inscription. Votre nom figurera sur l’attestation ; l’adresse e-mail sert uniquement à identifier l’attestation numérique et à éviter les doublons.

Votre nom et l’intitulé du cours seront visibles publiquement sur la page de vérification de l’attestation, accessible à toute personne disposant du lien.

Questions fréquentes

Attestation, badge et accès au cours

Le cours est-il gratuit ? Est-ce que je reçois une attestation ?

Oui aux deux questions. Le cours est entièrement gratuit : les contenus, l’épreuve finale et l’attestation, sans module payant et sans qu’aucun moyen de paiement ne vous soit jamais demandé. Lorsque vous réussissez l’épreuve finale avec au moins 80 % de bonnes réponses, vous recevez une Attestation de suivi à votre nom, avec un code de vérification, une page publique que chacun peut consulter pour en confirmer l’authenticité, le PDF à télécharger et un Open Badge à ajouter à votre profil LinkedIn. Votre nom et votre e-mail ne vous sont demandés qu’à la fin, si vous décidez de passer l’épreuve.

Qui propose le cours ? Est-il lié à un fournisseur de modèles ?

C’est un cours indépendant de Rinoova Academy, et l’attestation est délivrée par Rinoova. Il n’est affilié à aucun fournisseur d’intelligence artificielle ni approuvé par l’un d’eux. Les concepts ont été choisis précisément parce qu’ils valent quel que soit le modèle ou la plateforme : lorsque le cours cite une fonction proposée par certaines plateformes, comme le cache du préfixe, il la décrit en termes génériques et vous renvoie à la documentation de votre fournisseur pour les détails.

Quelle différence y a-t-il entre context engineering et prompt engineering ?

Le prompt engineering porte sur la façon d’écrire les instructions ; le context engineering porte sur tout ce que le modèle a sous les yeux à chaque appel — instructions, historique, documents, outils et mémoire — et sur la façon dont cela évolue au fil d’une tâche. Le second ne remplace pas le premier, il le contient. Le cours Prompt engineering opérationnel est la base recommandée ; ce cours part de là et se concentre sur les systèmes dans lesquels le contexte est assemblé par le code ou par l’agent lui-même.

Combien de temps dure le cours et comment les heures sont-elles calculées ?

Environ deux heures. Dix chapitres pour environ 5 000 mots de texte technique, qui demandent un peu moins d’une heure de lecture attentive, plus neuf exemples — dispositions du contexte, notes de compactage, délégations, fichiers de mémoire, résultats d’outils et comparaisons — sur lesquels il vaut la peine de s’arrêter, et l’épreuve finale. Ce n’est pas un cours en vidéo : vous pouvez le lire à votre rythme, l’interrompre et le reprendre quand vous le souhaitez.

Quels sont les prérequis ? Faut-il savoir programmer ?

Le cours est de niveau intermédiaire : il suppose que vous savez rédiger un prompt pour un système réel et que vous savez comment un agent utilise des outils dans une boucle, les sujets des cours Prompt engineering opérationnel et Agents IA. On n’écrit pas de code pendant le cours : les exemples sont de courts fichiers texte et JSON, expliqués par le texte qui les entoure. Pour appliquer bon nombre des techniques, en revanche, il faut pouvoir intervenir sur le code qui assemble les appels au modèle, vous-même ou avec ceux qui le développent.

Que se passe-t-il si je ne réussis pas l’épreuve finale ?

Vous pouvez la repasser. Le seuil est de 80 % et les questions couvrent tous les chapitres : si une partie n’est pas claire, mieux vaut revenir au chapitre concerné et le relire avant de réessayer. L’attestation n’est délivrée qu’en cas de réussite, et jamais deux fois pour le même cours à la même personne.

Le cours est-il à jour ? Le domaine évolue vite.

Oui, et il est écrit précisément pour le rester. Le cours se concentre sur ce qui reste valable quand les modèles et les produits changent — quoi inclure, comment résumer, comment séparer, de quoi se souvenir, comment protéger et mesurer le contexte —, et c’est là-dessus que porte l’épreuve. Les noms de modèles, les versions, les prix, les statistiques et les tailles des fenêtres de contexte sont volontairement laissés de côté, parce qu’ils vieillissent plus vite que le reste. La date de la dernière révision est indiquée en haut de la page.

Pour continuer

Autres cours Open