Comment un agent utilise les outils (Bases)

Quand on dit qu’un agent peut "utiliser un outil", on dirait qu’il clique sur un bouton ou lance un programme.

Mais à l’intérieur, ça fonctionne autrement. L’agent ne peut pas ouvrir un fichier, envoyer un email ou appeler une API tout seul.

Il travaille uniquement avec du texte.

Alors comment un agent interagit avec le monde réel ?

Comment un modèle texte peut :

• Obtenir des données depuis une base
• Envoyer une requête à un serveur
• Écrire un résultat dans un fichier

La réponse est le tool calling.

Le modèle n’exécute pas les actions lui-même. Il demande au système de les exécuter.

Il décide quand un outil est nécessaire.
Et le système autour exécute.

Ce qu’est vraiment un outil

Un outil est une action dont l’agent peut demander l’exécution.

Ça peut être :

• Obtenir des données depuis une API
• Trouver des informations dans une base
• Lire un fichier
• Envoyer un message
• Écrire un résultat

Pour le modèle, c’est une autre option de réponse.

Au lieu d’écrire du texte, il peut dire :

"Pour avancer, j’ai besoin que cette action soit exécutée."

Et préciser :

• Quel outil utiliser
• Avec quels paramètres

Par exemple :

{
  "tool": "get_user_data",
  "parameters": {
    "user_id": 123
  }
}

À ce moment, le modèle n’exécute pas l’action lui-même. Il propose seulement de l’exécuter.

Si le système autorise l’action, il exécute l’outil et renvoie le résultat (Donnée, Statut ou Erreur) au modèle.

Après ça, l’agent décide quoi faire ensuite.

Comment le modèle sait quels outils existent

Le modèle ne cherche pas des outils tout seul.

On lui indique à l’avance quelles actions sont disponibles.

Avant de commencer, le système envoie au modèle une liste d’outils qu’il peut utiliser.

Chaque outil a :

• Nom - comment il s’appelle
• Description - ce qu’il fait
• Paramètres - quelles données il demande

Par exemple :

{
  "name": "get_user_data",
  "description": "Récupère les informations utilisateur par ID",
  "parameters": {
    "user_id": "number"
  }
}

Pour le modèle, c’est un ensemble d’actions possibles à choisir au bon moment.

Il n’invente pas de nouveaux outils.
Il choisit parmi ceux qui sont autorisés.

C’est pour ça qu’un agent ne peut pas appeler n’importe quelle API.
Seulement celles qui lui ont été données.

Comment l’agent choisit un outil

À n’importe quel moment, l’agent peut avoir plusieurs options d’action.

Il peut :

• Écrire une réponse
• Utiliser un outil
• Ou terminer la tâche

Pour choisir, il regarde :

• L’objectif actuel
• Les données disponibles
• Le résultat des étapes précédentes

Et il se pose une question simple :

"Qu’est-ce qui m’aide à avancer vers le résultat, maintenant ?"

Si la réponse ne suffit pas, il faut peut-être appeler un outil pour obtenir de nouvelles données.

Si les données sont déjà suffisantes, il peut continuer sans outil.

Si la tâche est terminée, il peut arrêter.

Ce n’est pas un script rigide.
C’est un choix que l’agent fait à chaque boucle.

C’est exactement pour ça qu’il peut utiliser différents outils selon la situation, et pas dans un ordre fixe prédéfini.

Ce qui se passe après un appel d’outil

Quand l’agent choisit un outil et demande son exécution, le système autour prend la main.

Il :

• Vérifie si cet outil est autorisé
• Exécute l’action
• Récupère le résultat

Ça peut être :

• Des données depuis une API
• Le contenu d’un fichier
• Un statut d’exécution
• Ou une erreur

Ensuite, le résultat est renvoyé au modèle sous forme de texte.

Pour l’agent, c’est une nouvelle information qu’il peut utiliser.

Il analyse le résultat :

• A-t-il reçu les données nécessaires ?
• S’est-il rapproché de l’objectif ?
• Faut-il une étape supplémentaire ?

Et sur cette base, il décide :

• D’utiliser un autre outil
• De continuer sans outil
• Ou de terminer la tâche

C’est ainsi que chaque appel d’outil devient une partie de la boucle d’action.

En code, cela ressemble à ça

Imagine que l’agent veut obtenir des données utilisateur. Il ne peut pas appeler une fonction tout seul. Il peut seulement demander au système de le faire, sous forme de requête texte :

# Le modèle décide :
# "Pour avancer, j'ai besoin des données utilisateur"

model_output = {
    "tool": "get_user_data",
    "parameters": {
        "user_id": 123
    }
}

Le modèle n’exécute rien. Il dit seulement : "S’il te plaît, exécute cet outil."

Cette requête est ensuite reçue par le système autour de l’agent :

def get_user_data(user_id: int):
    return {"id": user_id, "name": "Anna"}


TOOLS = {
    "get_user_data": get_user_data
}

Le système vérifie :

• si cet outil existe
• si son utilisation est autorisée

Et seulement après, il exécute :

tool_name = model_output["tool"]
params = model_output["parameters"]

result = TOOLS[tool_name](**params)

Après cela, le résultat est renvoyé au modèle sous forme de texte :

tool_result = f"User data: {result}"

Et maintenant, l’agent peut décider de :

• utiliser ces données
• appeler un autre outil
• ou terminer la tâche

Dans cet exemple, nous avons créé model_output manuellement. Dans un agent réel, il est généré par le modèle de langage lui-même. Il analyse la tâche, décide qu’un outil est nécessaire, puis forme automatiquement la même requête.

Analogie de la vie réelle

Imagine que tu prépares le dîner.

Tu as :

• un frigo
• une cuisinière
• un couteau
• un micro-ondes

Ce sont tous les outils que tu peux utiliser.

Tu ne peux pas :

• utiliser un four s’il n’y en a pas
• ou prendre un blender s’il n’est pas dans la cuisine

Maintenant, tu veux faire une soupe.

Tu penses :

Qu’est-ce qui m’aide tout de suite ?

Tu peux :

• ouvrir le frigo
• allumer la cuisinière
• ou prendre un couteau

Tu choisis un outil, tu l’utilises, puis tu regardes ce qui a changé.

Ensuite, tu choisis le suivant.

Et ainsi de suite, jusqu’à ce que le plat soit prêt.

C’est pareil pour l’agent.

Il reçoit une liste d’outils disponibles.
Il ne peut pas en inventer de nouveaux, seulement choisir parmi ceux qui existent.

À chaque étape, il décide :

quel outil aide à avancer vers le résultat

Il l’utilise et continue.

En bref

Le tool calling est la manière dont un agent interagit avec le monde réel.

Le modèle n’exécute pas les actions lui-même. Il demande au système de les exécuter en son nom.

Le système lui donne la liste des outils disponibles. Le modèle choisit le bon outil au bon moment. Le système vérifie les permissions, exécute l’action et renvoie le résultat.

Et sur cette base, l’agent décide quoi faire ensuite.

FAQ

Q : Est-ce que l’agent exécute des actions tout seul ?
A : Non. Le modèle n’exécute pas les actions lui-même. Il demande seulement au système d’exécuter un outil en son nom.

Q : Qu’est-ce que le tool calling ?
A : C’est une façon pour le modèle de demander une action, par exemple obtenir des données ou écrire un résultat, afin d’avancer vers l’objectif.

Q : Comment l’agent sait quels outils il peut utiliser ?
A : Avant de commencer, le système fournit au modèle une liste d’outils disponibles dans laquelle il peut choisir à chaque étape.

Et ensuite

Maintenant, tu comprends les bases du tool calling.

Mais dans le travail réel, des questions plus difficiles arrivent :

Comment contrôler quels outils l’agent peut utiliser ?
Que faire si un outil est coûteux et un autre risqué ?
Comment donner à l’agent accès aux données mais interdire la suppression ?

Ce ne sont plus des bases.
C’est la réalité de la production.