Programme Leçon 231 sur 250 · Projet : agent de recherche qui utilise des outils
Projet : agent de recherche qui utilise des outils

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 search pour 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 est calc pour combiner les deux faits. Retiens le résultat.
  • Quand il ne reste plus rien à faire, émets une action finale finish dont 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 finish

Le 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.

À ton tour

É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.