Programme Leçon 175 sur 250 · Créer des Agents (Utilisation d'outils et ReAct)
Créer des Agents (Utilisation d'outils et ReAct)

Mémoire de l'agent et accumulation d'état

La boucle ReAct que tu as construite a de l'amnésie : chaque étape appelle un outil et oublie. Un vrai agent doit transporter ce qu'il a appris vers l'avant - les faits qu'il a cherchés, les résultats que les outils ont renvoyés - pour qu'une étape ultérieure puisse les utiliser. Ce notebook en cours d'exécution est la mémoire de l'agent (les gens l'appellent aussi le scratchpad ou le contexte de travail). Ton code le possède ; le modèle ne le fait jamais.

Mais le contexte n'est pas gratuit. Tout ce qui est en mémoire est remis dans le prompt à l'étape suivante, et le modèle a une fenêtre context window fixe mesurée en tokens. Si la mémoire grandit sans fin, tu finis par dépasser la fenêtre (et tu payes pour chaque token en plus). La mémoire a donc besoin de deux moitiés : accumulate les nouveaux faits au fur et à mesure, et trim pour revenir à un Budget quand elle devient trop grande.

Sa forme de cela

State est un dictionnaire : une note system permanente (les instructions permanentes de l'agent, que tu ne jettes jamais) et une liste de facts qu'il a rassemblées :

state = {"system": "You are a research agent.", "facts": []}

Chaque observation devient une ligne de fait. Après qu'un outil s'exécute, tu ajoutes un enregistrement lisible de ce qui s'est passé :

state["facts"].append(f"{tool}({args}) -> {observation}")

Tronçage à un Budget de jetons

Les tokeniseurs réels sont appris et basés sur des sous-mots ; nous ne pouvons pas en exécuter un ici, alors nous estimons un token comme un mot séparé par un espace (len(text.split())) - même astuce que le module LLM. (En production, tu utiliserais le compte réel de sous-mots du champ usage de l'API, ou la règle empirique des caractères len(text) / 4 ; l'estimation par espace garde simplement cet exercice déterministe.) La règle de suppression reflète ce que font réellement les agents en production : toujours garder la note système, puis garder autant de faits les plus récents que possible dans ce qu'il reste du Budget. La récence gagne parce que les derniers résultats sont généralement ceux dont l'étape suivante a besoin.

budget = max_tokens - est_tokens(state["system"])
# walk facts newest-first, keep while they fit, then stop

Parcoure les faits du plus récent au plus ancien, en ajoutant le coût du token de chacun jusqu'à ce que le fait suivant dépasse le Budget, puis arrête-toi. Inverse l'ordre pour que les faits gardés restent dans leur ordre original. Si le Budget est minuscule, tu peux garder zéro fait, mais la note du système survit toujours.

Dans un agent en direct, le modèle lirait render(state) au début de chaque étape et le même cycle accumulate-then-trim s'exécuterait après chaque tool call, pour que la fenêtre ne déborde jamais. Le tuteur sur l'appareil peut piloter cette boucle, mais le grading n'inspecte que l'état déterministe. Appuie sur Run pour accumuler une courte transcription et regarde les faits les plus anciens disparaître sous un Budget serré.

À ton tour

Construis la mémoire de l'agent. Écris new_state(system_note) -> {"system": note, "facts": []}; record(state, tool, args, observation) qui ajoute la ligne de fait "<tool>(<args>) -> <observation>" et retourne l'état; est_tokens(text) -> nombre de tokens d'espaces; et trim(state, max_tokens) qui garde la note système plus les faits les plus récents dont les tokens (la note système compte dans le Budget) tiennent dans max_tokens. Ensuite écris accumulate(system_note, transcript, max_tokens): commence un état frais, record à chaque (tool, args, observation) étape dans l'ordre, trim une fois à la fin, et retourne l'état tronqué.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.