Un aspect crucial des agents d’IA est leur capacité à prendre des actions. Comme nous l’avons vu, cela se fait par l’utilisation des outils.
Dans cette section, nous verrons ce que sont les outils, comment les concevoir efficacement, et comment les intégrer dans votre agent via le message système.
En fournissant à votre agent les bons outils — et en décrivant clairement le fonctionnement de ces outils — vous pouvez augmenter de manière spectaculaire ce que votre IA peut accomplir. Plongeons-nous dedans !
Un outil est une fonction fournie au LLM. Cette fonction doit remplir un objectif clair.
Voici quelques outils couramment utilisés dans les agents d’IA :
| Outil | Description |
|---|---|
| Recherche Web | Permet à l’agent de récupérer des informations à jour depuis Internet. |
| Génération d’images | Crée des images à partir de descriptions textuelles. |
| Récupération | Récupère des informations à partir d’une source externe. |
| Interface API | Interagit avec une API externe (GitHub, YouTube, Spotify, etc.). |
Ce ne sont que des exemples, car en réalité, vous pouvez créer un outil pour n’importe quel cas d’utilisation !
Un bon outil doit être quelque chose qui complémente la puissance d’un LLM.
Par exemple, si vous devez effectuer des opérations arithmétiques, fournir un outil calculatrice à votre LLM donnera de meilleurs résultats que de se fier aux capacités natives du modèle.
De plus, les LLMs prédisent la complétion d’une invite en se basant sur leurs données d’entraînement, ce qui signifie que leur connaissance interne n’inclut que les événements antérieurs à leur entraînement. Par conséquent, si votre agent a besoin de données à jour, vous devez les fournir via un outil.
Par exemple, si vous demandez directement à un LLM (sans outil de recherche) la météo d’aujourd’hui, le LLM pourrait inventer une météo aléatoire.
Un outil doit contenir :
Comme nous l’avons vu, les LLMs ne peuvent recevoir que des entrées textuelles et générer des sorties textuelles. Ils ne peuvent pas appeler des outils par eux-mêmes. Par fournir des outils à un Agent, nous enseignons au LLM l’existence des outils et lui demandons de générer du texte qui invoquera ces outils lorsqu’il en aura besoin. Par exemple, si nous fournissons un outil pour vérifier la météo d’un lieu via Internet, puis que nous demandons au LLM la météo à Paris, le LLM reconnaîtra que cette question constitue une opportunité pertinente pour utiliser l’outil “météo” que nous lui avons enseigné. Le LLM générera du texte, sous forme de code, pour invoquer cet outil. Il incombe à l’Agent d’analyser la sortie du LLM, de reconnaître qu’un appel à un outil est requis, et d’invoquer l’outil au nom du LLM. La sortie de l’outil sera ensuite renvoyée au LLM, qui composera sa réponse finale pour l’utilisateur.
La sortie d’un appel d’outil est un autre type de message dans la conversation. Les étapes d’appel d’outil ne sont généralement pas montrées à l’utilisateur : l’Agent récupère la conversation, appelle l’(les) outil(s), obtient les sorties, les ajoute en tant que nouveau message dans la conversation, et renvoie la conversation mise à jour au LLM. Du point de vue de l’utilisateur, c’est comme si le LLM avait utilisé l’outil, mais en réalité, c’est notre code applicatif (l’Agent) qui l’a fait.
Nous parlerons beaucoup plus de ce processus lors de sessions futures.
La réponse complète peut sembler complexe, mais nous utilisons essentiellement le prompt système pour fournir au modèle des descriptions textuelles des outils disponibles :
Pour que cela fonctionne, nous devons être très précis et rigoureux concernant :
C’est la raison pour laquelle les descriptions d’outils sont généralement fournies en utilisant des structures expressives mais précises, telles que des langages informatiques ou du JSON. Il n’est pas nécessaire de procéder ainsi, tout format précis et cohérent fonctionnerait.
Si cela semble trop théorique, comprenons-le à travers un exemple concret.
Nous allons implémenter un outil calculatrice simplifié qui se contentera de multiplier deux entiers. Voici une implémentation en Python :
def calculator(a: int, b: int) -> int:
"""Multiplie deux entiers."""
return a * b
print(calculator.to_string())Ainsi, notre outil s’appelle calculator, il multiplie deux entiers, et il requiert les entrées suivantes :
a (int): Un entier.b (int): Un entier.La sortie de l’outil est un autre nombre entier que nous pouvons décrire ainsi :
a et b.Tous ces détails sont importants. Rassemblons-les dans une chaîne de texte qui décrit notre outil pour que le LLM puisse le comprendre.
Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: intRappel : Cette description textuelle est ce que nous voulons que le LLM sache à propos de l’outil.
Lorsque nous passons la chaîne précédente dans l’entrée du LLM, le modèle la reconnaîtra comme un outil et saura quelles entrées fournir et ce qu’il doit attendre en sortie.
Si nous souhaitons fournir des outils supplémentaires, nous devons rester cohérents et utiliser toujours le même format. Ce processus peut être fragile, et nous pourrions accidentellement négliger certains détails.
Existe-t-il une meilleure méthode ?
Notre outil a été écrit en Python, et l’implémentation fournit déjà tout ce dont nous avons besoin :
calculatorMultiplie deux entiers.int.Il y a une raison pour laquelle on utilise des langages de programmation : ils sont expressifs, concis et précis.
Nous pourrions fournir le code source Python comme spécification de l’outil pour le LLM, mais la manière dont l’outil est implémenté n’a pas d’importance. Tout ce qui compte, c’est son nom, ce qu’il fait, les entrées qu’il attend et la sortie qu’il fournit.
Nous tirerons parti des fonctionnalités d’introspection de Python pour exploiter le code source et construire automatiquement une description de l’outil. Tout ce dont nous avons besoin, c’est que l’implémentation de l’outil utilise des annotations de types, des docstrings et des noms de fonction pertinents. Nous écrirons un peu de code pour extraire les parties pertinentes du code source.
Une fois cela fait, il nous suffira d’utiliser un décorateur Python pour indiquer que la fonction calculator est un outil :
@tool
def calculator(a: int, b: int) -> int:
"""Multiplie deux entiers."""
return a * b
print(calculator.to_string())Notez le décorateur @tool avant la définition de la fonction.
Avec l’implémentation que nous verrons ensuite, nous serons capables d’extraire automatiquement le texte suivant à partir du code source :
Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: intComme vous pouvez le constater, c’est la même chose que nous avons écrit manuellement précédemment !
Nous créons une classe générique Tool que nous pouvons réutiliser chaque fois que nous avons besoin d’utiliser un outil.
Avertissement : Cette implémentation d’exemple est fictive mais ressemble de près aux implémentations réelles dans la plupart des bibliothèques.
class Tool:
"""
Une classe représentant un morceau de code réutilisable (Outil).
Attributs:
name (str): Nom de l'outil.
description (str): Une description textuelle de ce que fait l'outil.
func (callable): La fonction que cet outil encapsule.
arguments (list): Une liste d'arguments.
outputs (str ou list): Le(s) type(s) de retour de la fonction encapsulée.
"""
def __init__(self,
name: str,
description: str,
func: callable,
arguments: list,
outputs: str):
self.name = name
self.description = description
self.func = func
self.arguments = arguments
self.outputs = outputs
def to_string(self) -> str:
"""
Retourne une représentation sous forme de chaîne de l'outil,
incluant son nom, sa description, ses arguments, et ses sorties.
"""
args_str = ", ".join([
f"{arg_name}: {arg_type}" for arg_name, arg_type in self.arguments
])
return (
f"Tool Name: {self.name},"
f" Description: {self.description},"
f" Arguments: {args_str},"
f" Outputs: {self.outputs}"
)
def __call__(self, *args, **kwargs):
"""
Invoque la fonction sous-jacente (callable) avec les arguments fournis.
"""
return self.func(*args, **kwargs)Cela peut sembler compliqué, mais en y allant pas à pas, nous pouvons voir ce qu’elle fait. Nous définissons une classe Tool qui inclut :
name (str): Le nom de l’outil.description (str): Une brève description de ce que fait l’outil.function (callable): La fonction que l’outil exécute.arguments (list): Les paramètres d’entrée attendus.outputs (str ou list): Les sorties attendues de l’outil.__call__() : Appelle la fonction lorsque l’instance de l’outil est invoquée.to_string() : Convertit les attributs de l’outil en une représentation textuelle.Nous pourrions créer un outil avec cette classe en utilisant le code suivant :
calculator_tool = Tool(
"calculator", # nom
"Multiplie deux entiers.", # description
calculator, # fonction à appeler
[("a", "int"), ("b", "int")], # entrées (noms et types)
"int", # sortie
)Mais nous pouvons également utiliser le module inspect de Python pour récupérer toutes les informations pour nous ! C’est ce que fait le décorateur @tool.
Si cela vous intéresse, vous pouvez afficher la section suivante pour voir l’implémentation du décorateur.
def tool(func):
"""
Un décorateur qui crée une instance de Tool à partir de la fonction donnée.
"""
# Récupérer la signature de la fonction
signature = inspect.signature(func)
# Extraire les paires (nom_param, annotation_param) pour les entrées
arguments = []
for param in signature.parameters.values():
annotation_name = (
param.annotation.__name__
if hasattr(param.annotation, '__name__')
else str(param.annotation)
)
arguments.append((param.name, annotation_name))
# Déterminer l'annotation de retour
return_annotation = signature.return_annotation
if return_annotation is inspect._empty:
outputs = "Pas d'annotation de retour"
else:
outputs = (
return_annotation.__name__
if hasattr(return_annotation, '__name__')
else str(return_annotation)
)
# Utiliser la docstring de la fonction comme description (par défaut si vide)
description = func.__doc__ or "No description provided."
# Le nom de la fonction devient le nom de l'outil
name = func.__name__
# Retourner une nouvelle instance de Tool
return Tool(
name=name,
description=description,
func=func,
arguments=arguments,
outputs=outputs
)Pour réitérer, avec ce décorateur en place, nous pouvons implémenter notre outil comme ceci :
@tool
def calculator(a: int, b: int) -> int:
"""Multiplie deux entiers."""
return a * b
print(calculator.to_string())Et nous pouvons utiliser la méthode to_string de Tool pour récupérer automatiquement un texte adapté à être utilisé comme description d’un outil pour un LLM :
Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: intLa description est injectée dans le prompt système. Prenant l’exemple avec lequel nous avons commencé cette section, voici à quoi cela ressemblerait après avoir remplacé le tools_description :
Dans la section Actions, nous en apprendrons plus sur la façon dont un Agent peut appeler cet outil que nous venons de créer.
Les outils jouent un rôle crucial dans l’amélioration des capacités des agents d’IA.
Model Context Protocol (MCP) est un protocole ouvert qui standardise la manière dont les applications fournissent des outils aux LLMs. MCP offre :
Cela signifie que tout framework implémentant MCP peut utiliser les outils définis dans le protocole, éliminant le besoin de réimplémenter la même interface d’outils pour chaque framework.
Si vous voulez approfondir MCP, vous pouvez consulter notre cours gratuit MCP.
Les outils jouent un rôle crucial dans l’amélioration des capacités des agents IA.
Pour résumer, nous avons appris :
Ce que sont les outils : des fonctions qui offrent des capacités supplémentaires aux LLMs, comme effectuer des calculs ou accéder à des données externes.
Comment définir un outil : en fournissant une description textuelle claire, des entrées, des sorties, et une fonction exécutable.
Pourquoi les outils sont essentiels : ils permettent aux Agents de surmonter les limites de l’entraînement statique des modèles, de gérer des tâches en temps réel, et d’effectuer des actions spécialisées.
Maintenant, nous pouvons passer au Workflow de l’Agent où vous verrez comment un Agent observe, réfléchit et agit. Cela rassemble tout ce que nous avons vu jusqu’à présent et prépare le terrain pour créer votre propre Agent IA entièrement fonctionnel.
Mais d’abord, il est temps pour un autre court quiz !
< > Update on GitHub