L'IA qui agit : comment les agents artificiels prennent le contrôle ?

QUAND L'IA PASSE DE LA PAROLE À L'ACTION

Imaginez un assistant qui répondrait toujours à vos questions. mais en inventant ses réponses. Impossible de savoir si ce qu'il dit est vrai. C'est exactement ce que font les modèles d'IA classiques : ils génèrent du texte sans vérifier les faits. Mais que se passerait-il si cet assistant pouvait vérifier la météo en direct, convertir des devises ou interroger une base de données ?

C'est là qu'intervient le tool calling. Ce mécanisme permet à un modèle d'IA de ne plus se limiter à parler, mais d'agir. Au lieu de simplement répondre « Il fait beau à Paris », il peut vérifier en temps réel la température à Paris grâce à une API météo, puis vous donner l'information exacte. L'IA devient un agent, capable d'interagir avec le monde réel.

LE TOOL CALLING : LE CERVEAU QUI DÉCIDE, LE CODE QUI EXÉCUTE

Le tool calling fonctionne en deux étapes distinctes, comme un cerveau qui donne des ordres et un corps qui les exécute. D'abord, le modèle d'IA décide quelle action entreprendre. Ensuite, votre code exécute cette action et renvoie le résultat à l'IA, qui peut alors formuler une réponse finale.

Prenons un exemple concret avec la météo. Vous demandez : « Quel temps fait-il à Athènes ? ». L'IA ne répond pas directement. Elle identifie d'abord qu'il existe un outil capable de récupérer la météo, puis elle génère une instruction structurée pour l'appeler. Votre code reçoit cette instruction, exécute l'appel à l'API météo, récupère la température, puis renvoie les données à l'IA. Enfin, l'IA vous répond : « Il fait actuellement 29°C à Athènes. »

COMMENT FONCTIONNE UN TOOL CALL ?

Un tool call est une instruction précise envoyée par l'IA. Elle se présente sous la forme d'un message structuré, presque comme un formulaire à remplir. Par exemple :

ChatCompletionMessage(
    content=None,
    role='assistant',
    tool_calls=[
        ChatCompletionMessageToolCall(
            id='call_abc123',
            type='function',
            function=Function(
                name='getcurrentweather',
                arguments='{"city": "Athens", "unit": "celsius"}'
            )
        )
    ]
)

Ici, l'IA indique : « Je veux appeler la fonction getcurrentweather avec les paramètres city=Athens et unit=celsius. » Le champ content est vide car l'IA ne répond pas encore : elle donne simplement l'ordre d'agir.

Votre rôle est alors d'exécuter cet ordre. Dans ce cas, vous allez appeler une API météo avec ces paramètres, récupérer la température, puis renvoyer le résultat à l'IA sous forme de message structuré.

PREMIER PAS : DÉFINIR L'OUTIL DISPONIBLE

Avant que l'IA puisse utiliser un outil, vous devez lui indiquer quels Outils existent et comment les utiliser. Cela se fait en définissant une liste d'outils, chacun décrit par :

• Un nom (ex: getcurrentweather)
• Une description (ex: « Récupérer la météo actuelle pour une ville donnée »)
• Un schéma précisant les paramètres nécessaires (ex: le nom de la ville, l'unité de température)

Voici comment cela se traduit en code :

tools = [
    {
        "type": "function",
        "function": {
            "name": "getcurrentweather",
            "description": "Get the current weather for a given city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The name of the city, e.g. Athens"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "The temperature unit to use"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

L'IA va utiliser cette description pour comprendre quand et comment appeler l'outil. Si vous décrivez mal l'outil, l'IA risque de ne pas l'utiliser correctement. Par exemple, si vous oubliez de préciser que le paramètre unit est obligatoire, l'IA pourrait ne pas l'inclure dans son appel.

DEUXIÈME ÉTAPE : ENVOYER LE MESSAGE À L'IA

Une fois les outils définis, vous envoyez à l'IA le message de l'utilisateur, accompagné de la liste des outils disponibles. L'IA analyse alors la demande et décide si elle a besoin d'utiliser un outil pour répondre.

Exemple avec la question : « Quel temps fait-il à Athènes ? »

messages = [
    {"role": "user", "content": "What's the weather like in Athens right now?"}
]

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

print(response.choices[0].message)

L'IA répond en générant un tool call : elle indique qu'elle veut appeler getcurrentweather avec city=Athens et unit=celsius.

TROISIÈME ÉTAPE : EXÉCUTER L'OUTIL ET RÉCUPÉRER LES DONNÉES

Votre code doit maintenant exécuter l'outil demandé. Dans cet exemple, vous allez appeler une API météo (Open-Meteo) pour récupérer la température à Athènes. Voici comment faire :

import requests

def getcurrentweather(city: str, unit: str = "celsius"):
    # Convertir le nom de la ville en coordonnées géographiques
    geo = requests.get(
        "https://geocoding-api.open-meteo.com/v1/search",
        params={"name": city, "count": 1}
    ).json()
    lat = geo["results"][0]["latitude"]
    lon = geo["results"][0]["longitude"]

    # Récupérer la météo actuelle
    weather = requests.get(
        "https://api.open-meteo.com/v1/forecast",
        params={
            "latitude": lat,
            "longitude": lon,
            "current": "temperature2m,weathercode",
            "temperature_unit": unit
        }
    ).json()

    temp = weather["current"]["temperature_2m"]
    return {"city": city, "temperature": temp, "unit": unit}

# Extraire les arguments du tool call
toolcall = response.choices[0].message.toolcalls[0]
arguments = json.loads(tool_call.function.arguments)

# Exécuter la fonction
weatherresult = getcurrent_weather(**arguments)

Cette fonction utilise deux API : une pour convertir le nom de la ville en coordonnées, et une autre pour récupérer la météo. Les résultats sont ensuite formatés pour être renvoyés à l'IA.

QUATRIÈME ÉTAPE : RENVoyer LES RÉSULTATS À L'IA

Une fois l'outil exécuté, vous devez renvoyer les résultats à l'IA sous forme de message structuré. Ce message doit inclure :

• Le tool call original (pour que l'IA sache à quel appel correspond le résultat)
• Les données récupérées (la température, dans ce cas)

Exemple de code :

# Ajouter le tool call et le résultat à l'historique des messages
messages.append(response.choices[0].message)  # Ajoute le tool call
messages.append({
    "role": "tool",
    "toolcallid": tool_call.id,  # Lie le résultat à l'appel spécifique
    "content": json.dumps(weather_result)
})

L'IA reçoit maintenant un message contenant à la fois l'ordre initial et le résultat de l'exécution. Elle peut alors formuler une réponse finale pour l'utilisateur.

CINQUIÈME ÉTAPE : OBTENIR LA RÉPONSE FINALE

Enfin, vous renvoyez l'historique complet des messages (y compris le tool call et le résultat) à l'IA. Elle génère alors une réponse naturelle, basée sur les données récupérées. Dans cet exemple, elle répond : « Il fait actuellement 29°C à Athènes. »

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

print(final_response.choices[0].message.content)

C'est cette boucle qui permet à l'IA de passer de la parole à l'action : décision → exécution → réponse.

DES OUTILS EN PLUSIEURS EXEMPLES : LA CONVERSION DE DEVISES

Pour illustrer la puissance du tool calling, ajoutons un deuxième outil : la conversion de devises. Supposons que vous voulez que votre IA puisse répondre à des questions comme « Combien valent 200 dollars en euros ? ».

D'abord, définissez l'outil convert_currency :

tools = [
    {
        "type": "function",
        "function": {
            "name": "getcurrentweather",
            "description": "Get the current weather for a given city",
            "parameters": { . }
        }
    },
    {
        "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. USD"},
                    "to_currency": {"type": "string", "description": "The target currency code, e.g. EUR"}
                },
                "required": ["amount", "fromcurrency", "tocurrency"]
            }
        }
    }
]

Ensuite, créez la fonction qui exécute la conversion en appelant une API de taux de change (Frankfurter) :

def convertcurrency(amount: float, fromcurrency: str, to_currency: str):
    response = requests.get(
        f"https://api.frankfurter.dev/v2/rate/{fromcurrency}/{tocurrency}"
    ).json()

    rate = response["rate"]
    converted = round(amount * rate, 2)
    return {
        "amount": amount,
        "fromcurrency": fromcurrency,
        "tocurrency": tocurrency,
        "converted_amount": converted,
        "rate": rate
    }

Avec ces deux outils, votre IA peut répondre à des questions de météo et de conversion de devises. Si l'utilisateur demande « Combien valent 200 dollars en euros ? », l'IA identifie qu'il faut appeler convert_currency avec les paramètres amount=200, from_currency=USD et to_currency=EUR.

APPELER PLUSIEURS OUTILS EN MÊME TEMPS : LE POUVOIR DU PARALLÈLE

Certains modèles, comme gpt-4o, peuvent appeler plusieurs outils en une seule fois. Cela s'appelle le parallel tool calling. Imaginons que l'utilisateur pose une question complexe : « Quel temps fait-il à Athènes et combien valent 100 dollars en euros ? »

L'IA peut répondre en appelant simultanément les deux outils :

messages = [
    {"role": "user", "content": "What's the weather in Athens and how much is 100 USD in EUR?"}
]

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

for toolcall in response.choices[0].message.toolcalls:
    print(tool_call.function.name)
    print(tool_call.function.arguments)

L'IA génère deux appels :

getcurrentweather
{"city": "Athens"}

convert_currency
{"amount": 100, "fromcurrency": "USD", "tocurrency": "EUR"}

Votre code exécute les deux appels en parallèle, récupère les résultats, puis les renvoie à l'IA. Cette dernière combine alors les deux informations pour formuler une réponse unique : « Il fait actuellement 29°C à Athènes, et 100 dollars valent 92,50 euros. »

QU'EST-CE QU'UN AGENT ? LA RÉPONSE EN 4 POINTS

Le terme « agent » est souvent utilisé à tort et à travers. Mais qu'est-ce qu'un agent, au juste ? Voici les quatre caractéristiques qui définissent un agent :

1. Perception : L'agent doit pouvoir recevoir des informations sur son environnement. Dans le cas de l'IA, cela passe par les messages utilisateur et les outils disponibles.
2. Traitement : L'agent analyse ces informations pour comprendre ce qu'il doit faire. L'IA utilise le tool calling pour décider quelle action entreprendre.
3. Objectif : L'agent a un but à atteindre. Ici, c'est de répondre correctement à la question de l'utilisateur.
4. Action : L'agent exécute une action pour atteindre son objectif. L'IA appelle un outil ou génère une réponse.

Le tool calling est donc le mécanisme qui permet à l'IA d'agir. Sans lui, l'IA reste un simple générateur de texte. Avec lui, elle devient un agent capable d'interagir avec le monde réel.

AU-DELÀ DU SIMPLE TOOL CALL : LES BOUCLES D'AGENTS

Dans les applications réelles, les agents ne se contentent pas d'un seul appel d'outil. Ils utilisent les résultats d'un outil pour décider de l'action suivante. Cela forme une boucle appelée ReAct loop (Reason + Act).

Prenons un exemple : un utilisateur demande « Quel est le prix d'un billet d'avion pour New York demain ? ». L'IA commence par appeler un outil pour vérifier les vols disponibles. Une fois les résultats obtenus, elle réalise qu'elle a besoin de plus d'informations (comme le prix exact). Elle appelle alors un autre outil pour récupérer ces données. Cette boucle peut se répéter plusieurs fois jusqu'à ce que l'IA ait toutes les informations nécessaires pour répondre.

Cette capacité à enchaîner les actions fait des agents des outils puissants pour résoudre des problèmes complexes, comme planifier un voyage ou analyser des données.

L'IA DEVIENT UN SYSTÈME : DE L'ENTRÉE-SORTIE AUX AGENTS MULTIFONCTIONS

Avant le tool calling, un modèle d'IA était comme une machine à écrire ultra-rapide : il prenait du texte en entrée et produisait du texte en sortie. Avec le tool calling, il devient un système capable de combiner la puissance du raisonnement avec des outils externes.

Imaginez un agent qui peut :

• Vérifier la météo
• Convertir des devises
• Interroger une base de données
• Envoyer un email
• Lancer une recherche web

Chaque outil ajoute une nouvelle capacité à l'agent, comme des pièces de Lego qui s'assemblent pour former un robot. L'IA n'est plus limitée à ce qu'elle a appris pendant son entraînement : elle peut accéder à des informations en temps réel et agir sur le monde.

LIMITES ET DÉFIS : QUAND L'IA NE PEUT PAS AGIR

Le tool calling n'est pas une solution miracle. Il y a des limites importantes à garder à l'esprit :

• Les outils doivent être définis : Si vous n'avez pas défini un outil pour une tâche, l'IA ne pourra pas l'exécuter. Par exemple, si vous n'avez pas d'outil pour vérifier l'heure d'un film au cinéma, l'IA ne pourra pas répondre à cette question.
• Les outils doivent être bien décrits : Une description vague ou incomplète peut entraîner des erreurs. Si vous décrivez mal un outil, l'IA risque de l'utiliser de manière incorrecte.
• Les erreurs d'exécution : Si l'outil échoue (par exemple, si l'API météo est indisponible), l'IA ne pourra pas récupérer les données et devra improviser une réponse.
• La sécurité : Appeler des outils externes peut poser des problèmes de sécurité. Par exemple, si un outil permet d'envoyer des emails, il faut s'assurer qu'il ne peut pas être utilisé pour spammer des utilisateurs.

Ces limites montrent que le tool calling est puissant, mais pas magique. Il nécessite une bonne conception et une gestion rigoureuse des outils disponibles.

UNE RÉVOLUTION EN MARCHE : L'IA QUI AGIT

Le tool calling n'est pas qu'une fonctionnalité technique : c'est une révolution dans la façon dont nous utilisons l'IA. Avant, les modèles étaient des boîtes noires qui généraient du texte. Aujourd'hui, ils deviennent des assistants actifs, capables d'interagir avec le monde réel.

Cette capacité ouvre la porte à des applications inédites :

• Un assistant personnel qui gère vos rendez-vous, vérifie vos emails et planifie vos trajets.
• Un agent de support client qui consulte votre base de données et répond à vos questions en temps réel.
• Un outil de recherche qui combine plusieurs sources d'information pour vous donner une réponse précise.

Le tool calling est la clé qui permet à l'IA de passer du statut de « machine à écrire » à celui d'agent autonome.

COMMENT CRÉER VOTRE PROPRE AGENT ?

Si vous voulez expérimenter avec le tool calling, voici les étapes à suivre :

1. Choisissez un modèle compatible : Utilisez un modèle qui supporte le tool calling, comme gpt-4o ou gpt-4o-mini.
2. Définissez vos outils : Listez les actions que votre agent doit pouvoir effectuer et décrivez-les clairement.
3. Écrivez les fonctions d'exécution : Pour chaque outil, créez une fonction qui exécute l'action réelle (appel API, requête base de données, etc.).
4. Intégrez le tout : Envoyez les messages à l'IA, exécutez les outils, renvoyez les résultats et obtenez la réponse finale.
5. Testez et améliorez : Vérifiez que l'IA utilise correctement les outils et améliorez les descriptions si nécessaire.

Avec ces étapes, vous pouvez créer un agent capable de réaliser des tâches complexes, comme un assistant personnel ou un outil de productivité.

EXEMPLE CONCRET : UN ASSISTANT MÉTÉO ET FINANCIER

Pour illustrer tout cela, voici un exemple complet d'un assistant capable de répondre à des questions de météo et de conversion de devises. Le code est structuré en cinq étapes, comme expliqué précédemment :

from openai import OpenAI
import json
import requests

client = OpenAI(apikey="votreclé_api")

# Étape 1 : Définir les outils
def getcurrentweather(city: str, unit: str = "celsius"):
    # . (code de l'API météo)

def convertcurrency(amount: float, fromcurrency: str, to_currency: str):
    # . (code de l'API de conversion)

tools = [
    {
        "type": "function",
        "function": {
            "name": "getcurrentweather",
            "description": "Get the current weather for a given city",
            "parameters": { . }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "Convert an amount from one currency to another",
            "parameters": { . }
        }
    }
]

# Étape 2 : Envoyer le message de l'utilisateur
messages = [
    {"role": "user", "content": "What's the weather in Athens and how much is 100 USD in EUR?"}
]

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

# Étape 3 : Exécuter les outils demandés
toolcalls = response.choices[0].message.toolcalls
for toolcall in toolcalls:
    if toolcall.function.name == "getcurrent_weather":
        arguments = json.loads(tool_call.function.arguments)
        weatherresult = getcurrent_weather(**arguments)
    elif toolcall.function.name == "convertcurrency":
        arguments = json.loads(tool_call.function.arguments)
        currencyresult = convertcurrency(**arguments)

# Étape 4 : Renvoyer les résultats à l'IA
messages.append(response.choices[0].message)
for toolcall, result in zip(toolcalls, [weatherresult, currencyresult]):
    messages.append({
        "role": "tool",
        "toolcallid": tool_call.id,
        "content": json.dumps(result)
    })

# Étape 5 : Obtenir la réponse finale
final_response = client.chat.completions.create(
    model="gpt-4o-mini",
    tools=tools,
    messages=messages
)

print(final_response.choices[0].message.content)

Avec ce code, votre assistant peut répondre à des questions complexes en combinant plusieurs outils. C'est la base de tout agent autonome.

LE FUTUR DES AGENTS : VERS DES SYSTÈMES PLUS INTELLIGENTS

Le tool calling est encore une technologie jeune, mais elle évolue rapidement. Les prochaines étapes pourraient inclure :

• Des agents capables d'apprendre : Aujourd'hui, les agents exécutent des outils prédéfinis. Demain, ils pourraient apprendre à utiliser de nouveaux outils sans intervention humaine.
• Des agents plus autonomes : Les agents pourraient prendre des décisions plus complexes, comme planifier un voyage ou gérer un budget.
• Une intégration plus poussée : Le tool calling pourrait être intégré directement dans les applications grand public, comme les assistants vocaux ou les chatbots.

Cette technologie a le potentiel de transformer notre relation avec l'IA : plus besoin de faire des recherches manuelles ou de naviguer entre plusieurs applications. L'IA devient votre assistant personnel, capable d'agir pour vous.

EN CONCLUSION : L'IA N'EST PLUS UNE MACHINE À ÉCRIRE

Le tool calling marque un tournant dans l'histoire de l'IA. Il transforme les modèles de langage, autrefois cantonnés à générer du texte, en agents capables d'interagir avec le monde réel. Grâce à cette technologie, l'IA peut vérifier des faits, effectuer des actions et combiner plusieurs outils pour résoudre des problèmes complexes.

Mais attention : cette puissance s'accompagne de responsabilités. Il est crucial de bien concevoir les outils, de gérer les erreurs et de garantir la sécurité. Avec le bon cadre, le tool calling peut révolutionner la façon dont nous utilisons l'IA au quotidien.

Alors, prêt à faire de votre IA un agent actif ? Le futur de l'intelligence artificielle est en marche, et il agit déjà.

GLOSSAIRE : LES MOTS-CLÉS À RETENIR

Pour mieux comprendre le tool calling, voici un glossaire des termes essentiels :

• Tool calling : Mécanisme permettant à une IA de déclencher des actions externes en appelant des outils prédéfinis.
• Tool call : Instruction structurée envoyée par l'IA pour appeler un outil spécifique avec des paramètres précis.
• Agent : Système capable de percevoir son environnement, de prendre des décisions et d'agir pour atteindre un objectif.
• ReAct loop : Boucle de raisonnement et d'action où l'IA utilise les résultats d'un outil pour décider de l'action suivante.
• Parallel tool calling : Capacité d'un modèle à appeler plusieurs outils simultanément.
• Fonction calling : Autre nom pour le tool calling, souvent utilisé dans la documentation technique.