Branche la boucle ReAct de l'agent
Voici maintenant le cœur du projet : la boucle ReAct (Raisonner -> Agir -> Observer), la boucle de contrôle derrière pratiquement tous les frameworks d'agents. Le modèle ne répond pas d'un coup. Il réfléchit à une étape, choisit un outil, l'exécute, lit le résultat, et seulement alors décide quoi faire ensuite. Ton travail est d'écrire cette boucle en Python simple, sur des outils factices, pour comprendre la mécanique au lieu de traiter LangChain comme une boîte noire.
Dans un vrai déploiement, l'étape « raisonner » est un appel à un LLM. Ici, on remplace le modèle par une petite politique déterministe pour que tout soit testable hors ligne (pas de réseau, pas d'API). La politique regarde la tâche et les observations recueillies jusque-là, et renvoie l'action suivante. Cette séparation est la vraie leçon : la boucle est générique ; seule la politique est intelligente.
Une tâche est une toute petite spécification que la politique lit :
task = {"need": ["team size", "office floors"], "op": "*"}
# "look up these facts, then combine them with this operator"Tu vas construire run_agent(task, tools, max_steps=8). Elle renvoie une trace : une liste ordonnée de tuples (thought, tool, args, observation), un par étape. Cette trace est tout l'historique du raisonnement de l'agent, et c'est exactement ce que tu journalises, rejoues et (dans les prochaines leçons) évalues.
Le raisonnement que la boucle encode, à chaque itération :
- Si un fait nécessaire est encore inconnu, l'action suivante est
searchpour le premier manquant. Enregistre l'observation et retiens le fait. - Une fois tous les faits réunis, et si la tâche a un
op, l'action suivante estcalcpour combiner les deux faits. Retiens le résultat. - Quand il ne reste plus rien à faire, émets une action finale
finishdont l'observation est la réponse, et arrête-toi.
def run_agent(task, tools, max_steps=8):
trace, facts = [], {}
for _ in range(max_steps):
missing = [k for k in task["need"] if k not in facts]
if missing:
key = missing[0]
obs = tools["search"]({"query": key}) # ACT + OBSERVE
facts[key] = obs
trace.append(("need " + key, "search", {"query": key}, obs))
continue
... # compute if there is an op, else finishLe dict tools est, dans l'esprit, ton registre de la leçon 1 : search(args) résout un fait, calc(args) applique op à a et b. La réponse finale est le résultat de calc quand il y a un op, ou le seul fait cherché quand il n'y en a pas. Le correcteur vérifie la séquence étape par étape (tool, args, observation) et la réponse finale, donc la boucle doit vraiment router correctement, pas deviner. Il exécute aussi une seconde tâche, différente, donc une trace écrite en dur ne peut pas passer. Appuie sur Run pour voir une tâche à deux faits raisonner jusqu'à une réponse.
Écris make_tools() qui renvoie un dict avec search(args) (résout args["query"] dans la table FACTS fournie dans le code de départ ; "not found" si absent) et calc(args) (applique args["op"] à args["a"], args["b"] pour + - * /). Puis écris run_agent(task, tools, max_steps=8) qui implémente la boucle raisonner-agir-observer : cherche chaque clé encore manquante de task["need"] (la première manquante d'abord), puis calc si task["op"] est défini, puis une étape finale finish écrite comme (thought, "finish", {"answer": answer}, answer). Renvoie la liste ordonnée des tuples (thought, tool, args, observation) ; la réponse finale est le résultat de calc, ou le seul fait quand il n'y a pas d'op.
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.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.