Tool calling des LLM : function calling et agents IA
Comment fonctionne le tool calling d'un LLM : décrire les outils, faire tourner et arrêter une boucle d'agent, et les pannes à prévoir.
Dans cet article
- À quoi ressemble la définition d'un outil ?
- Comment écrire des descriptions d'outils que le modèle utilise correctement ?
- Comment fonctionne une boucle d'agent ?
- Comment un agent doit-il décider de s'arrêter ?
- Quelles sont les pannes d'agent les plus courantes ?
- Et la sécurité ?
- Avez-vous vraiment besoin d'un agent ?
- Où se place MCP ?
Le tool calling (ou function calling) permet à un modèle de langage de demander à votre application d'exécuter une fonction : vous décrivez les outils disponibles avec des noms, des descriptions et des schémas de paramètres, le modèle répond par un appel structuré comme get_order_status(order_id="A-1042"), votre code l'exécute et le résultat repart vers le modèle. Un agent est ce même mécanisme dans une boucle, où le modèle continue de choisir des outils et de lire des résultats jusqu'à décider que la tâche est terminée.
Le modèle n'exécute jamais rien lui-même. Il produit du texte qui se trouve être une requête bien formée. Gardez cela en tête et la plupart des choix de conception autour des agents deviennent plus clairs, surtout ceux de sécurité.
À quoi ressemble la définition d'un outil ?
Chez OpenAI, Anthropic et Google, les formats de requête diffèrent légèrement, mais toute définition d'outil a les mêmes trois parties : un nom, une description en langage naturel et un JSON Schema pour les paramètres.
Une définition faible :
{
"name": "search",
"description": "Cherche des trucs.",
"parameters": {
"type": "object",
"properties": { "q": { "type": "string" } }
}
}
Une meilleure :
{
"name": "search_help_center",
"description": "Recherche en texte intégral dans les articles publics du centre d'aide de l'application Ledgerly. À utiliser quand l'utilisateur demande comment fonctionne une fonctionnalité ou comment résoudre un problème. Ne cherche pas dans les données du compte de l'utilisateur ; utilise get_account_summary pour cela. Renvoie jusqu'à 5 articles avec titre, URL et un court extrait.",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Une courte expression de recherche en anglais, par ex. 'export invoices to CSV'. Reformule la question de l'utilisateur en mots-clés au lieu de la transmettre telle quelle."
}
},
"required": ["query"]
}
}
La description est un prompt. Le modèle la lit pour décider quand utiliser l'outil, quoi lui passer et à quoi s'attendre en retour. La documentation d'Anthropic sur l'utilisation d'outils insiste sur des descriptions détaillées comme premier facteur de performance des outils, ce qui correspond à ce qu'on observe en pratique.
Comment écrire des descriptions d'outils que le modèle utilise correctement ?
Répondez aux questions qu'un nouveau développeur poserait avant d'appeler une API inconnue :
- Que fait-il, et que ne fait-il pas ? « Ne cherche pas dans les données du compte de l'utilisateur » évite toute une catégorie d'appels erronés.
- Quand l'utiliser plutôt qu'un outil voisin ? Les outils qui se recoupent sont la première cause de mauvaise sélection. Si deux outils pourraient raisonnablement traiter une demande, dites lequel l'emporte.
- Que signifient les paramètres, avec des exemples ? Les formats (dates ISO, centimes ou euros, identifiants avec ou sans préfixe) et une valeur d'exemple pour tout ce qui est ambigu.
- Que renvoie-t-il ? Y compris ce que signifie un résultat vide.
- A-t-il des effets de bord ? « Envoie l'e-mail immédiatement ; irréversible » change le comportement d'un modèle prudent, et devrait changer la façon dont votre application le contrôle.
Nommez les outils pour qu'ils se lisent clairement les uns à côté des autres : search_help_center, get_account_summary, create_support_ticket. Évitez les noms génériques comme search ou run, qui invitent au mauvais usage.
Renvoyez aussi des erreurs utiles. Si un appel échoue, un résultat d'outil comme "error": "order_id must look like A-1234; got 1234" permet au modèle de corriger son propre appel à l'étape suivante. Un simple 500 ne le permet pas.
Comment fonctionne une boucle d'agent ?
La boucle de base, que la plupart des frameworks d'agents implémentent avec des variantes :
- Envoyez au modèle la conversation, le system prompt et les définitions d'outils.
- Si le modèle répond uniquement par du texte, le tour est terminé.
- S'il répond par un ou plusieurs appels d'outils, votre code les valide et les exécute.
- Ajoutez les résultats à la conversation comme résultats d'outils.
- Retournez à l'étape 1.
Ce schéma, qui entrelace raisonnement, actions et observations, a été décrit dans l'article ReAct (Yao et al., 2022), et c'est l'ossature de la plupart des agents construits depuis. Les API modernes le prennent en charge nativement, y compris plusieurs appels d'outils dans un même tour.
La boucle est simple. Le travail, c'est de la faire se comporter correctement.
Comment un agent doit-il décider de s'arrêter ?
Deux types de conditions d'arrêt, et il vous faut les deux.
Au niveau de la tâche, dans le prompt. Dites à l'agent ce que « terminé » veut dire :
Tu as terminé quand la question de l'utilisateur a reçu une réponse ou
quand tu as établi qu'on ne peut pas y répondre avec les outils disponibles.
Si après deux recherches tu n'as pas trouvé d'articles pertinents, arrête
de chercher et dis à l'utilisateur ce que tu as essayé.
Pose une question de clarification au lieu de deviner quand la demande
peut concerner plus d'un compte ou d'une facture.
Sans consignes de ce genre, les agents ont tendance soit à s'arrêter trop tôt (répondre avec leurs propres connaissances sans chercher), soit à continuer (relancer des recherches avec de légères variations en espérant un meilleur résultat).
Des limites strictes, dans le code. Un nombre maximal d'itérations, un budget de tokens ou de coût, et un délai d'expiration. Quand une limite est atteinte, terminez proprement : renvoyez ce qui a été trouvé jusque-là et indiquez que la tâche n'a pas été menée à bien. Ne comptez jamais sur le seul modèle pour arrêter une boucle qui dépense de l'argent.
Quelles sont les pannes d'agent les plus courantes ?
Mauvaise sélection d'outil. Souvent causée par des outils qui se recoupent ou des descriptions floues. Corrigez d'abord les descriptions ; si cela ne suffit pas, réduisez le nombre d'outils disponibles pour cette tâche.
Arguments hallucinés. Le modèle invente un identifiant de commande parce que l'utilisateur a dit « ma dernière commande ». Demandez-lui de chercher les identifiants avec un outil ou de les demander à l'utilisateur, et validez les arguments dans le code avant d'exécuter.
Bouclage. L'agent répète un appel qui échoue avec de minuscules variations. Détectez dans votre boucle les appels identiques ou quasi identiques répétés pour en sortir, et rendez les erreurs d'outils assez informatives pour qu'on puisse corriger.
Succès prématuré. L'agent annonce « C'est fait, j'ai mis à jour la fiche » alors que l'appel de mise à jour a en réalité échoué. Rendez les résultats d'outils explicites sur le succès ou l'échec et, pour les tâches importantes, vérifiez le résultat avec un appel de lecture distinct.
Contexte gonflé. Les résultats d'outils peuvent être énormes (une page web entière, une requête de 2 000 lignes). Les longues boucles remplissent le contexte de sorties périmées et le modèle perd de vue l'objectif initial. Réduisez ou résumez les résultats d'outils avant de les renvoyer, et ne renvoyez que les champs dont le modèle a besoin.
Trop d'outils. La précision tend à baisser quand on ajoute des outils, surtout similaires. Donnez à chaque tâche le plus petit ensemble utile, ou chargez les outils dynamiquement selon la demande.
Et la sécurité ?
Chaque outil est une capacité qu'une prompt injection peut emprunter. Si votre agent lit des pages web ou des e-mails et dispose aussi d'un outil qui envoie des messages, un attaquant qui écrit le bon texte dans une page peut lui faire envoyer des messages.
Règles pratiques :
- Autorisez dans le code, pas dans le prompt. L'outil doit s'exécuter avec les permissions de l'utilisateur final, pour qu'un modèle induit en erreur ne puisse pas atteindre des données que l'utilisateur ne pourrait pas atteindre.
- Confirmez les actions importantes. Paiements, suppressions, messages sortants, changements de permissions : montrez à l'utilisateur exactement ce qui va se passer et exigez son accord.
- Validez les arguments. Validation du schéma plus règles métier (plafonds de montant, destinataires autorisés) avant l'exécution.
- Séparez les outils de lecture et d'écriture. Une étape de recherche qui n'a que des outils de lecture ne peut rien abîmer, aussi confus que le modèle devienne.
Avez-vous vraiment besoin d'un agent ?
Souvent non. Si les étapes sont connues d'avance (récupérer, puis résumer, puis mettre en forme), un pipeline fixe d'appels de modèle individuels est moins cher, plus rapide, plus facile à tester et à déboguer. Les agents justifient leur complexité quand le chemin dépend vraiment de résultats intermédiaires : le modèle doit chercher quelque chose pour savoir quoi chercher ensuite.
Une progression raisonnable : commencez par un prompt unique ; ajoutez de la récupération si des faits sont nécessaires (ce qu'est la RAG) ; ajoutez un seul appel d'outil pour une action ; ensuite seulement, construisez une boucle.
Où se place MCP ?
Le Model Context Protocol, introduit par Anthropic fin 2024 et adopté depuis par d'autres éditeurs et outils, standardise la façon dont les applications exposent outils et données aux modèles. Il résout la plomberie : une définition de serveur utilisable depuis de nombreux clients. Il ne change rien aux conseils ci-dessus. Un outil mal décrit est tout aussi déroutant via MCP, et connecter de nombreux serveurs tiers ajoute à la fois des capacités et de la surface d'attaque.
Pour le côté sortie des appels d'outils (schémas, modes stricts, validation), voir obtenir du JSON fiable des LLM. Le thème outils et agents transforme ces décisions de conception en questions d'entraînement.
Questions fréquentes
Qu'est-ce que le tool calling dans les LLM ?
Le tool calling, aussi appelé function calling, permet à un modèle de répondre par une demande structurée d'exécution d'une fonction que vous avez définie, comme interroger une base de données ou envoyer un e-mail. Votre code exécute la fonction et renvoie le résultat au modèle, qui poursuit ensuite.
Le modèle exécute-t-il l'outil lui-même ?
Non. Le modèle ne produit que le nom de l'outil et ses arguments. Votre application décide de l'exécuter ou non, l'exécute et renvoie le résultat : c'est pourquoi les contrôles de permissions relèvent de votre code.
Quelle différence entre le tool calling et un agent IA ?
Le tool calling est une capacité unique : le modèle demande l'exécution d'une fonction. Un agent est une boucle dans laquelle le modèle décide à répétition quel outil appeler ensuite, observe les résultats et continue jusqu'à ce que la tâche soit terminée ou qu'une limite soit atteinte.
Combien d'outils peut-on donner à un agent ?
Il n'y a pas de limite fixe, mais la précision tend à baisser quand la liste d'outils s'allonge et que les outils se recoupent. Gardez un ensemble réduit et distinct pour chaque tâche, ou chargez dynamiquement les outils pertinents.
- #tool calling
- #function calling
- #agents IA
- #boucle d'agent
- #MCP