Agent avec boucle de decision

Un agent, c'est un programme qui decide quoi faire tout seul. Au lieu de suivre un pipeline fixe, il observe la situation, choisit une action, l'execute, observe le resultat, et recommence. C'est une boucle : observer -> decider -> agir -> observer.

Pense a un robot aspirateur. Il observe (detecte un obstacle), decide (tourner a gauche), agit (tourne), observe le resultat (voie libre), et continue.

Pour un agent LLM, le "decide" c'est le LLM qui choisit quel outil appeler. Le "agit" c'est l'execution de l'outil. Le "observe" c'est le resultat de l'outil renvoye au LLM. Et la boucle continue jusqu'a ce que le LLM decide qu'il a la reponse finale.

Tu vas creer une classe SimpleAgent avec :

__init__(self, outils, decideur, max_iterations=5) :
- outils : dictionnaire {nom: fonction}
- decideur : fonction qui prend (question, historique) et renvoie soit {"action": "outil", "outil": nom, "args": dict} pour appeler un outil, soit {"action": "repondre", "reponse": texte} pour donner la reponse finale
- max_iterations : nombre maximum de tours de boucle

executer(self, question) : lance la boucle agent. A chaque tour :
1. Appelle le decideur avec la question et l'historique des actions precedentes
2. Si le decideur dit "repondre", renvoie {"reponse": texte, "iterations": n, "historique": historique}
3. Si le decideur dit "outil", execute l'outil correspondant, ajoute le resultat a l'historique, et continue
4. Si max_iterations est atteint, renvoie {"reponse": "Max iterations atteint", "iterations": max_iterations, "historique": historique}

L'historique est une liste de dictionnaires {"outil": nom, "args": args, "resultat": resultat}.

Exemple :

outils = {"meteo": lambda ville: f"25 degres a {ville}"}

def decideur(question, historique):
if not historique:
return {"action": "outil", "outil": "meteo", "args": {"ville": "Paris"}}
return {"action": "repondre", "reponse": f"Il fait {historique[-1]['resultat']}"}

agent = SimpleAgent(outils, decideur)
agent.executer("Quel temps fait-il ?")
renvoie {"reponse": "Il fait 25 degres a Paris", "iterations": 2, "historique": [...]}

Tests (4/5)

Agent repond directement

def decideur(q, h): return {'action': 'repondre', 'reponse': 'Salut'}
agent = SimpleAgent({}, decideur)
r = agent.executer('Bonjour')
assert r['reponse'] == 'Salut'
assert r['iterations'] == 1

Agent utilise un outil puis repond

outils = {'calc': lambda x: x * 2}
def decideur(q, h):
    if not h:
        return {'action': 'outil', 'outil': 'calc', 'args': {'x': 5}}
    return {'action': 'repondre', 'reponse': str(h[-1]['resultat'])}
agent = SimpleAgent(outils, decideur)
r = agent.executer('Calcule')
assert r['reponse'] == '10'
assert r['iterations'] == 2
assert len(r['historique']) == 1

Max iterations atteint

outils = {'noop': lambda: 'done'}
def decideur(q, h): return {'action': 'outil', 'outil': 'noop', 'args': {}}
agent = SimpleAgent(outils, decideur, max_iterations=3)
r = agent.executer('Loop')
assert r['reponse'] == 'Max iterations atteint'
assert r['iterations'] == 3

Outil inconnu gere proprement

def decideur(q, h):
    if not h:
        return {'action': 'outil', 'outil': 'inexistant', 'args': {}}
    return {'action': 'repondre', 'reponse': h[0]['resultat']}
agent = SimpleAgent({}, decideur)
r = agent.executer('Test')
assert 'inconnu' in r['reponse'].lower()

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class SimpleAgent:
    def __init__(self, outils, decideur, max_iterations=5):
        self.outils = outils
        self.decideur = decideur
        self.max_iterations = max_iterations

    def executer(self, question):
        historique = []
        for i in range(self.max_iterations):
            decision = self.decideur(question, historique)
            if decision["action"] == "repondre":
                return {
                    "reponse": decision["reponse"],
                    "iterations": i + 1,
                    "historique": historique,
                }
            elif decision["action"] == "outil":
                nom_outil = decision["outil"]
                args = decision.get("args", {})
                if nom_outil in self.outils:
                    resultat = self.outils[nom_outil](**args)
                else:
                    resultat = f"Outil inconnu: {nom_outil}"
                historique.append({
                    "outil": nom_outil,
                    "args": args,
                    "resultat": resultat,
                })
        return {
            "reponse": "Max iterations atteint",
            "iterations": self.max_iterations,
            "historique": historique,
        }

← Observabilite : tracer les appels … Projet : mini agent autonome … →

solution.py

Bravo!

Agent avec boucle de decision

Tests (4/5)

Indices (3 disponibles)

Solution officielle