Comment créer des outils pour les agents IA

effectuer une série d’appels LLM. Ces agents reçoivent généralement une tâche d’un utilisateur et utilisent des outils pour résoudre efficacement la tâche. Les outils sont essentiellement des fonctions qu’un agent peut invoquer. Cependant, construire un agent va bien au-delà de la simple définition d’un ensemble d’outils et de leur fourniture dans le contexte de l’agent. Vous devez réfléchir attentivement à la manière dont vos outils sont définis et au contexte que vous fournissez à votre agent.

L’objectif de cet article est de mettre en évidence les points sur lesquels se concentrer lors de la création d’outils pour les agents d’IA. Des outils appropriés sont essentiels pour les agents hautement performants, et je vais donc approfondir l’utilisation des outils agentiques. J’aborderai des sujets tels que les bonnes définitions et descriptions d’outils, ainsi que la manière optimale de mettre les outils à la disposition de votre agent.

Pourquoi les outils sont importants pour les agents IA

Disposer d’outils est en grande partie ce qui rend les agents efficaces. Sans accès aux outils, le LLM n’aurait pas les mêmes options, comme effectuer des recherches sur Internet ou trouver des informations dans une table de base de données. La manière dont vous définissez et utilisez vos outils agentiques est donc essentielle à la performance de votre agent.

Il y a plusieurs considérations à prendre en compte lors de la définition des outils pour vos agents. En travaillant moi-même avec des agents, je trouve que bon nombre de ces considérations s’appliquent également aux humains utilisant les outils, par exemple :

• Les outils doivent être bien définis avec un nom et des descriptions appropriés
• Un outil doit avoir un objectif spécifique
• Vous devez avoir des définitions de type appropriées, à la fois pour les entrées et les sorties de l’outil.

En général, je pense que vous pouvez faire un long chemin en suivant le principe cité ci-dessous. Tous les outils que vous créez doivent être définis de telle manière qu’un humain puisse facilement comprendre l’outil et son fonctionnement.

Les outils doivent être définis de manière à ce qu’ils soient faciles à utiliser pour un être humain.

Je trouve que ce principe s’applique beaucoup lorsque vous travaillez en ML, par exemple, également lors de l’analyse des invites que vous envoyez à vos LLM. Vous devez toujours vous poser la question de savoir si un humain peut comprendre la tâche proposée dans l’invite. Dans le cas contraire, l’invite doit être clarifiée.

Définitions d’outils appropriées

Des définitions d’outils appropriées constituent une simple amélioration que vous pouvez apporter à vos agents IA. Avec des définitions d’outils appropriées, je fais référence à :

• Vos outils doivent avoir un nom clair, représentant la fonction de l’outil
• Vos outils doivent avoir une docstring bien descriptive, comprenant une brève description de ce que fait l’outil, une description de tous les paramètres d’entrée ainsi que leur type et une définition de ce que l’outil renvoie.

Je vais d’abord montrer un mauvais exemple d’outil, mettre en évidence les problèmes, puis fournir un exemple de bonne définition d’outil.

# bad tool definition
def search(query):
    results = search_database() 
    return results

Il s’agit d’une mauvaise définition d’outil en raison des problèmes suivants :

• Le nom de l’outil n’est pas descriptif. La recherche est ambiguë ; cela pourrait, par exemple, également faire référence à l’exécution d’une recherche sémantique
• Il manque une docstring définissant les types d’entrée et de sortie, et ce que fait l’outil
• L’outil ne dispose pas de types pour les paramètres d’entrée et de sortie. Le LLM utilisant cet outil est probablement en mesure de déduire que le requête est une chaîne. Cependant, le modèle devra passer du temps à comprendre le format de sortie une fois qu’il aura utilisé l’outil.

Au lieu de cela, vous devez donc définir l’outil comme suit :

@dataclass
class KeywordSearchResult:
    id: str
    filename: str
    document_content: str
    

# good tool definition
def keyword_search(query: str) -> list[KeywordSearchResult]:
    """
    Performs keyword search in the database. 

    Input parameters:
        query: str - the keywords to search for

    Output:
        A list of all keyword search results, with each result containing:
            - id (str) - the id of the document as defined in the database
            - filename (str) - the filename of the document
            - document_content (str) - the text contents of the document
    """
    results = search_databse()
    return results

Dans cet exemple, j’ai créé une classe de données distincte, représentant le format de sortie de l’outil. Cela permet à votre agent de comprendre beaucoup plus facilement le fonctionnement de l’outil et facilitera la gestion du résultat. De plus, j’ai défini une docstring appropriée, qui contient une description simple de ce que fait l’outil, ainsi que les paramètres d’entrée et de sortie. J’ai rendu le nom de l’outil plus précis en l’appelant recherche_mot-clé au lieu de juste recherche.

Apporter ces simples améliorations à vos outils entraînera une augmentation considérable des performances de vos agents. Cependant, il existe également d’autres techniques que vous pouvez appliquer à la façon dont vous définissez vos outils, ce qui rend votre agent encore plus efficace.

Fonctionnalité de l’outil

En continuant sur le sujet de votre outil, vous pouvez également améliorer les performances des agents en rendant les outils plus spécifiques et en fournissant au modèle des sorties claires à partir des outils. Je vais continuer avec l’exemple de mot-clé pour préciser ce que je veux dire.

Réaliser des outils spécifiques

Les outils doivent être aussi précis que possible. La création d’outils vagues rend plus difficile pour le modèle de savoir quand utiliser l’outil. Vous rencontrerez donc plus souvent le modèle utilisant incorrectement l’outil. Cela pourrait par exemple être :

• Utiliser l’outil à des moments incorrects. Par exemple, en utilisant recherche_mot-clé quand il devrait être utilisé recherche_sémantique
• Utiliser le modèle avec des paramètres incorrects
• Gestion incorrecte de la sortie de l’outil

Vos outils doivent donc toujours avoir un objectif clair et unique.

Fournir des résultats propres

Une autre façon d’améliorer considérablement la qualité des outils de vos agents est de fournir à l’agent un résultat propre. Cela signifie analyser les résultats dans l’outil dans une chaîne structurée de manière simple à comprendre par l’agent. Je vais à nouveau décrire cela à l’aide d’un exemple ci-dessous.

je vais faire un _parse_keyword_search_output outil qui prend en compte les résultats de la recherche par mot-clé et les analyse dans une chaîne structurée. Dans cet exemple, j’inclus également que KeywordSearchResult contient des résultats inutiles. Ces résultats sont naturellement exclus lorsque nous analysons la sortie.

@dataclass
class KeywordSearchResult:
    id: str
    filename: str
    document_content: str
    uneccesary_field_a: str
    uneccesary_field_b: str    

def _parse_keyword_search_output(keyword_search_results: list[KeywordSearchResult]) -> str:
    """Parse the output from the keyword search tool, into a structured string, only containing necessary information"""
    output_string = ""
    tot_num_documents = len(keyword_search_results)


    for i, result in enumerate(keyword_search_results):
        document_id, filename, document_content = result["id"], result["filename"], result["document_content"]
        output_string += f"""\n\n
                            Document {i+1}/{tot_num_documents}:
                                ID: {document_id}
                                filename: {filename}
                                content: {document_content}
                        """
    return output_string
    
  def keyword_search(query: str, url: str) -> list[KeywordSearchResult]:
    """<docstring>"""
    results = search_databse()
    return parse_results(results)

L’analyse du résultat de cette manière permet à l’agent de gérer beaucoup plus facilement les résultats de l’outil de recherche par mot clé. N’oubliez pas de vous assurer que la docstring du recherche_mot-clé L’outil décrit le format de sortie fourni par l’outil de recherche par mot clé Parse.

Évitez de renvoyer tous les résultats

Lorsque vous utilisez des outils tels que la recherche par mot clé, les outils peuvent parfois renvoyer des centaines, voire des milliers de résultats. Cela gonflera immédiatement le contexte de votre agent. Pour éviter cela, vous devez ajouter des options pour trier les sorties de l’outil et ne renvoyer qu’un nombre maximum d’éléments, comme je le souligne dans l’exemple ci-dessous :

def keyword_search(query: str, url: str, sort_ascending=True, max_return_items=10) -> list[KeywordSearchResult]:
    """<docstring>"""
    
    results = search_databse()
    if sort_ascending:
        results = sort(results, ascending=True)
    else:
        results = sort(results, ascending=False)

    results = parse_results(results)

    if max_return_items < len(results):
        return results[:max_return_items]
    return results

Habituellement, il suffit au modèle de voir les 10 ou 20 premiers résultats, à la fois de récupérer les informations les plus utiles (dans les recherches par mots clés, les meilleurs résultats sont généralement les plus pertinents) et de comprendre le format de sortie.

Gestion informative des erreurs

La gestion informative des erreurs est une sécurité essentielle à mettre en place lorsque vos agents rencontrent inévitablement des problèmes. Ce problème peut être dû à :

• L’agent utilise un outil de manière incorrecte. Dans ce cas, vous devez informer l’agent de la raison pour laquelle il a mal utilisé l’outil et éventuellement de la manière de le corriger.
• Une API échoue à cause d’un fournisseur tiers. Dans ce cas, vous pouvez demander au modèle d’attendre ou d’informer l’utilisateur du problème.
• Packages manquants, auquel cas vous devez informer votre agent pour qu’il installe les packages requis

def keyword_search(query: str, url: str) -> list[KeywordSearchResult]:
    """<docstring>"""
    try:
        results = search_database()
        return parse_results(results)
    except RatelimitError as e:
        raise RuntimeError(
            f"Rate limit error: {e}. "
            f"Wait before retrying. If this error persists, contact support."
        )
    except APINotAvailableError as e:
        raise RuntimeError(
            f"API not available: {e}. "
            f"Check that the provided URL is correct and the endpoint is operational."
        )
    except Exception as e:
        raise RuntimeError(
            f"Unexpected error: {e}. Please try again."
        )

Cette gestion informative des erreurs permet à votre agent de gérer beaucoup plus facilement le scénario d’échec d’un outil. Vous devez, en général, garantir les points suivants dans votre gestion des erreurs :

• Vous renvoyez un message d’erreur descriptif, comprenant à la fois la trace de l’erreur et une chaîne décrivant l’erreur.
• Idéalement, vous devriez informer l’agent de la manière dont il doit agir après avoir reçu cette erreur. Par exemple, si le modèle rencontre une erreur de limite de débit, il doit exécuter time.sleep() si c’est la première fois qu’il rencontre cette erreur, sinon il doit en informer l’utilisateur.

Mettez des outils à disposition de vos agents

Maintenant que vous disposez d’outils à la fois fonctionnels et bien définis, il est temps de les mettre à disposition de vos agents. Il y a cependant encore quelques considérations à prendre en compte lorsque vous fournissez des outils à votre agent.

• Combien d’outils s’intègrent dans le contexte ?
• Quand mettre à disposition des outils ?
• Comment rendre les outils disponibles dans le contexte ?

Concernant le premier point, je pense qu’il est important de considérer le nombre d’outils que vous devez corriger dans votre contexte. En fournissant à l’agent trop d’outils, il est difficile pour l’agent de savoir quand utiliser quels outils, et par conséquent, le modèle aura du mal à utiliser efficacement les outils. Vous devez donc revoir vos outils et déterminer s’ils sont tous nécessaires au bon fonctionnement de votre agent.

En poursuivant sur ce sujet, vous pouvez également réfléchir au moment où rendre les outils disponibles. Par exemple, le recherche_mot-clé L’outil peut ne pas être pertinent lorsque l’agent effectue des tâches de synthèse simples pour l’utilisateur. Vous pouvez modifier le contexte de votre agent pour rendre certains outils disponibles uniquement lorsqu’ils sont pertinents à utiliser.

Enfin, vous devez également réfléchir à la manière dont vous mettez les outils à disposition. Dans votre invite, vous devez créer une section distincte pour vos outils, soit en utilisant un en-tête markdown, soit une balise XML distincte. Vous devez ensuite mettre tous vos outils et les descriptions expliquant comment et quand utiliser vos outils dans cette section.

Conclusion

Dans cet article, j’ai expliqué comment travailler avec des outils pour vos agents. J’ai expliqué à quel point les outils constituent l’aspect le plus important pour les agents d’IA, ce qui leur permet d’être aussi efficaces qu’eux. De plus, j’ai également expliqué comment créer des définitions d’outils appropriées et comment créer des outils spécialisés. Je pense que travailler avec vos outils, améliorer la façon dont ils sont définis et la façon dont votre agent les utilise, est l’aspect le plus important sur lequel vous pouvez consacrer du temps lorsque vous travaillez sur votre agent IA.

👉 Retrouvez-moi sur les réseaux sociaux :

🧑‍💻 Entrer en contact

🔗 LinkedIn

🐦 X/Twitter

✍️ Moyen

Vous pouvez également lire certains de mes autres articles :