Comment les agents IA pensent, agissent et résolvent tes problèmes pas à pas

UNE QUESTION, PLUSIEURS ÉTAPES : COMMENT LES AGENTS IA FONCTIONNENT VRAIMENT

Prenez cette question : « Quel temps fait-il à Athènes et combien valent 100 dollars en euros ? » Pour y répondre, un agent IA doit d'abord vérifier la météo, puis faire une conversion de devise. Deux actions simples, mais qui nécessitent chacune un outil différent. Maintenant, imaginez une question plus complexe : « J'ai parié 100 euros avec mon ami qu'il pleuvrait à Athènes aujourd'hui. Si j'ai gagné, combien cela fait-il en dollars ? » Ici, la réponse dépend d'un résultat extérieur : il faut d'abord savoir s'il a plu avant de pouvoir convertir la somme. C'est exactement ce genre de problème que le ReAct Loop résout.

LE TOOL CALLING : LA BASE DE TOUT AGENT INTELLIGENT

Avant de plonger dans le ReAct Loop, il faut comprendre son ancêtre : le Tool Calling. Cette technique permet à un modèle d'IA de décider seul quel outil utiliser et avec quels paramètres, au lieu de simplement générer du texte. Par exemple, face à la question « Quel temps fait-il à Athènes ? », l'IA peut choisir d'appeler une fonction comme getcurrentweather avec la ville « Athènes » en paramètre. Une fois l'information récupérée, l'IA peut alors répondre directement à l'utilisateur. Mais que se passe-t-il si la question nécessite plusieurs Outils ? Le Tool Calling permet aussi d'appeler plusieurs fonctions en parallèle, comme vérifier la météo et convertir des devises en même temps. Cependant, cette méthode a une limite : elle suppose que l'IA sait à l'avance quels outils utiliser et dans quel ordre. Or, dans la réalité, certaines réponses dépendent des résultats intermédiaires.

LE REACT LOOP : LA BOUCLE QUI REND LES AGENTS VRAIMENT INTELLIGENTS

Le ReAct Loop (pour Reason + Act) est une version améliorée du Tool Calling. Au lieu de s'arrêter après une seule série d'actions, l'IA entre dans une boucle où elle peut raisonner, agir et observer plusieurs fois de suite. Voici comment ça marche :

• Raisonner : L'IA analyse ce qu'elle sait déjà et identifie ce qui lui manque pour répondre à la question.
• Agir : Elle utilise un outil pour obtenir l'information manquante.
• Observer : Elle intègre le résultat de l'outil dans son raisonnement et recommence.

Cette boucle se répète jusqu'à ce que l'IA ait suffisamment d'informations pour répondre. Par exemple, pour la question du pari, l'IA doit d'abord vérifier s'il a plu à Athènes. Si oui, elle convertit les 100 euros en dollars. Si non, elle arrête là et répond directement. Le ReAct Loop permet donc à l'IA de s'adapter en fonction des résultats qu'elle obtient, comme un humain qui ajusterait son plan en fonction des informations nouvelles.

UN EXEMPLE CONCRET : LE PARI SUR LA PLUIE À ATHÈNES

Prenons l'exemple de la question : « J'ai parié 100 euros avec mon ami qu'il pleuvrait à Athènes aujourd'hui. Si j'ai gagné, combien cela fait-il en dollars ? » Voici comment le ReAct Loop fonctionne en pratique :

Étape 1 : Vérifier la météo à Athènes

L'IA commence par raisonner : « Pour savoir si le pari est gagné, j'ai besoin de savoir s'il a plu à Athènes aujourd'hui. » Elle appelle donc l'outil getcurrentweather avec la ville « Athènes ». Le résultat est : précipitations de 3,2 mm. Il a donc plu. L'IA observe ce résultat et met à jour son raisonnement : « Le pari est gagné, il faut maintenant convertir les 100 euros en dollars. »

Étape 2 : Convertir les euros en dollars

L'IA appelle l'outil convert_currency avec les paramètres suivants : montant = 100, devise de départ = EUR, devise d'arrivée = USD. Le résultat est : 108,50 dollars. L'IA observe ce résultat et peut enfin répondre : « Il a plu à Athènes aujourd'hui (3,2 mm de précipitations), donc tu as gagné le pari . Tes 100 euros valent 108,50 dollars au taux de change d'aujourd'hui. »

Cas où il ne pleut pas

Que se passe-t-il si le résultat de la météo est différent ? Imaginons que les précipitations soient de 0,0 mm. L'IA observe ce résultat et raisonne : « Il n'a pas plu, donc le pari est perdu. Pas besoin de convertir les euros. » Elle répond directement : « Malheureusement, il n'a pas plu à Athènes aujourd'hui, donc il semble que tu aies perdu le pari. Aucune conversion de devise n'est nécessaire . »

Dans ce deuxième cas, l'IA n'a appelé qu'un seul outil. Elle a décidé elle-même d'arrêter la boucle une fois qu'elle avait assez d'informations, sans avoir besoin d'une instruction supplémentaire. C'est la magie du ReAct Loop : il permet à l'IA de s'adapter en temps réel et d'éviter les appels inutiles.

POURQUOI LE REACT LOOP EST-IL PLUS PUISSANT QUE LE TOOL CALLING ?

Le Tool Calling et le ReAct Loop partagent la même base technique, mais leur approche est radicalement différente. Voici pourquoi le ReAct Loop est bien plus puissant :

• Flexibilité : Le ReAct Loop permet à l'IA de s'adapter en fonction des résultats qu'elle obtient. Par exemple, si la météo indique qu'il a plu, l'IA convertit les euros en dollars. Si ce n'est pas le cas, elle arrête là. Le Tool Calling ne permet pas cette adaptabilité : il faudrait prévoir tous les cas possibles à l'avance.
• Économie : Chaque appel à un outil coûte de l'argent. Le ReAct Loop permet d'éviter les appels inutiles. Par exemple, si l'IA sait déjà qu'il ne pleuvra pas, elle n'appellera pas l'outil de conversion. Le Tool Calling, lui, appellerait les deux outils en parallèle, même si l'un d'eux est inutile.
• Complexité : Le ReAct Loop permet de résoudre des problèmes bien plus complexes, où les étapes dépendent les unes des autres. Par exemple, pour répondre à la question « Combien de temps faut-il pour aller de Paris à Marseille en train si je pars à 15h ? », l'IA doit d'abord vérifier les horaires des trains, puis calculer la durée du trajet. Le Tool Calling ne pourrait pas gérer cette dépendance sans une programmation complexe.

En résumé, le ReAct Loop est bien plus efficace que le Tool Calling pour les problèmes qui nécessitent plusieurs étapes ou des résultats intermédiaires. Il permet à l'IA de raisonner comme un humain, en ajustant ses actions en fonction des informations qu'elle découvre.

COMMENT FONCTIONNE UN REACT LOOP EN PRATIQUE ?

Voici comment implémenter un ReAct Loop en code Python. Le principe est simple : on crée une boucle qui s'exécute jusqu'à ce que l'IA ait assez d'informations pour répondre. Voici les étapes clés :

1. Définir les outils disponibles

L'IA doit connaître les outils qu'elle peut utiliser. Dans notre exemple, nous avons deux outils : getcurrentweather pour vérifier la météo et convert_currency pour convertir des devises. Chaque outil est défini par un nom, une description et des paramètres obligatoires. Par exemple, l'outil getcurrentweather prend en paramètre le nom de la ville et retourne la température et les précipitations.

tools = [
    {
        "type": "function",
        "function": {
            "name": "getcurrentweather",
            "description": "Get the current weather for a given city, including temperature and precipitation",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "The name of the city"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "Convert an amount from one currency to another",
            "parameters": {
                "type": "object",
                "properties": {
                    "amount": {"type": "number", "description": "The amount to convert"},
                    "from_currency": {"type": "string", "description": "The source currency code, e.g. EUR"},
                    "to_currency": {"type": "string", "description": "The target currency code, e.g. USD"}
                },
                "required": ["amount", "fromcurrency", "tocurrency"]
            }
        }
    }
]

2. Créer un dictionnaire pour lier les noms des outils aux fonctions Python

Pour que l'IA puisse appeler les outils, il faut un moyen de faire le lien entre le nom de l'outil (par exemple « getcurrentweather ») et la fonction Python qui l'exécute. On utilise un dictionnaire pour cela :

available_functions = {
    "getcurrentweather": getcurrentweather,
    "convertcurrency": convertcurrency
}

3. Initialiser la conversation avec le message de l'utilisateur

On commence par enregistrer le message de l'utilisateur dans une liste appelée messages. Cette liste servira à garder une trace de toute la conversation, y compris les appels aux outils et leurs résultats.

messages = [
    {
        "role": "user",
        "content": "I bet my friend 100 EUR that it would rain in Athens today. If I won, how many USD is that?"
    }
]

4. Créer la boucle ReAct Loop

La boucle s'exécute un nombre limité de fois (par exemple 5) pour éviter une boucle infinie. À chaque itération, l'IA raisonne, agit et observe :

max_iterations = 5

for i in range(max_iterations):
    print(f"--- Step {i + 1}: Reason ---")

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )

    message = response.choices[0].message
    messages.append(message)

    # Si l'IA n'appelle pas d'outil, elle peut répondre directement
    if not message.tool_calls:
        print("Final answer:")
        print(message.content)
        break

    # Sinon, on exécute chaque appel d'outil demandé par l'IA
    for toolcall in message.toolcalls:
        functionname = toolcall.function.name
        functionargs = json.loads(toolcall.function.arguments)

        print(f"--- Step {i + 1}: Act ({function_name}) ---")
        print(f"Calling {functionname} with {functionargs}")

        functionresponse = availablefunctions[functionname](**functionargs)

        print(f"--- Step {i + 1}: Observe ---")
        print(function_response)

        # On ajoute le résultat de l'outil à la conversation pour le prochain raisonnement
        messages.append({
            "role": "tool",
            "toolcallid": tool_call.id,
            "content": json.dumps(function_response)
        })

5. Résultat final

À la fin de la boucle, l'IA a soit appelé tous les outils nécessaires, soit décidé qu'elle avait assez d'informations pour répondre directement. Dans les deux cas, elle fournit une réponse claire et complète à l'utilisateur.

QUAND UTILISER LE REACT LOOP ?

Le ReAct Loop est particulièrement utile dans les cas suivants :

• Problèmes dépendants : Quand la réponse à une question dépend des résultats d'une autre action. Par exemple, « Si j'achète ce billet d'avion, combien vais-je dépenser en dollars ? » nécessite de connaître le prix en euros avant de convertir.
• Problèmes multi-étapes : Quand la résolution d'un problème nécessite plusieurs actions successives. Par exemple, « Trouve-moi un restaurant végétarien près de chez moi, vérifie s'il est ouvert ce soir, et réserve une table pour deux. »
• Problèmes adaptatifs : Quand l'IA doit ajuster son plan en fonction de résultats intermédiaires. Par exemple, « Si le film est à l'affiche, achète deux billets, sinon propose une alternative. »

En revanche, pour les problèmes simples où tous les outils nécessaires sont évidents dès le départ, le Tool Calling reste plus efficace. Il permet d'éviter les allers-retours inutiles et réduit la latence.

LE REACT LOOP : LA CLÉ POUR CRÉER DES AGENTS IA VRAIMENT UTILES

Le ReAct Loop est bien plus qu'une simple technique : c'est la base de la plupart des agents IA modernes. Grâce à lui, une IA peut :

• Résoudre des problèmes en plusieurs étapes sans avoir besoin de tout prévoir à l'avance.
• S'adapter en temps réel aux résultats qu'elle obtient.
• Éviter les appels inutiles aux outils, ce qui réduit les coûts et améliore l'efficacité.
• Fournir des réponses plus précises et plus utiles aux utilisateurs.

Que ce soit pour automatiser des tâches complexes, créer des assistants personnels ultra-efficaces ou développer des outils de productivité, le ReAct Loop est une technique incontournable. Et le plus beau ? Il ne nécessite que quelques lignes de code pour être implémenté. Une petite boucle, une condition, et un dictionnaire suffisent pour transformer un modèle d'IA en un agent capable de raisonner comme un humain.