Guide pour comprendre, créer et optimiser les agents d'appel d'API

Le rôle de l'intelligence artificielle dans les entreprises technologiques évolue rapidement ; les cas d'utilisation de l'IA sont passés du traitement passif de l'information à des agents proactifs capables d'exécuter des tâches. Selon une enquête de mars 2025 sur l'adoption mondiale de l'IA menée par Géorgien et NewtonX91 % des cadres techniques en phase de croissance et des entreprises utiliseraient ou envisageraient d'utiliser l'IA agentique.

Les agents appelant des API sont un exemple typique de cette transition vers les agents. Ils exploitent les grands modèles de langage (LLM) pour interagir avec les systèmes logiciels via leurs interfaces de programmation d'applications (API).

Par exemple, en traduisant des commandes en langage naturel en appels d'API précis, les agents peuvent récupérer des données en temps réel, automatiser des tâches routinières ou même contrôler d'autres systèmes logiciels. Cette capacité transforme les agents IA en intermédiaires utiles entre l'intention humaine et les fonctionnalités logicielles.

Les entreprises utilisent actuellement des agents d'appel d'API dans divers domaines, notamment :

• Applications grand public : des assistants comme Siri d'Apple ou Alexa d'Amazon ont été conçus pour simplifier les tâches quotidiennes, comme le contrôle des appareils domestiques intelligents et la prise de réservations.
• Flux de travail d'entreprise : les entreprises ont déployé des agents API pour automatiser les tâches répétitives telles que la récupération de données à partir de CRM, la génération de rapports ou la consolidation d'informations à partir de systèmes internes.
• Récupération et analyse des données : les entreprises utilisent des agents API pour simplifier l’accès aux ensembles de données propriétaires, aux ressources par abonnement et aux API publiques afin de générer des informations.

Dans cet article, j'adopterai une approche centrée sur l'ingénierie pour comprendre, développer et optimiser les agents d'appel d'API. Les éléments présentés dans cet article s'appuient en partie sur les travaux de recherche et développement pratiques menés par le laboratoire d'IA de Georgian. La question qui a motivé une grande partie des recherches du laboratoire d'IA dans le domaine des agents d'appel d'API est la suivante : « Si une organisation possède une API, quelle est la méthode la plus efficace pour développer un agent capable d'interagir avec cette API en langage naturel ? »

J'expliquerai le fonctionnement des agents d'appel d'API et comment les concevoir et les optimiser pour optimiser leurs performances. Enfin, je fournirai un workflow systématique que les équipes d'ingénierie pourront utiliser pour implémenter ces agents.

I. Définitions clés :

• API ou interface de programmation d'application : Un ensemble de règles et de protocoles permettant à différentes applications logicielles de communiquer et d'échanger des informations.
• Agent: Un système d’IA conçu pour percevoir son environnement, prendre des décisions et entreprendre des actions pour atteindre des objectifs spécifiques.
• Agent d'appel d'API : Un agent d'IA spécialisé qui traduit les instructions en langage naturel en appels API précis.
• Agent de génération de code : Un système d'IA qui assiste le développement logiciel en écrivant, modifiant et débogant du code. Bien que lié à ce domaine, je me concentre ici principalement sur les agents qui nous appeler Les API, bien que l'IA puisse également aider construire ces agents.
• MCP (Protocole de contexte de modèle) : Un protocole, notamment développé par Anthropic, définissant comment les LLM peuvent se connecter et utiliser des outils et des sources de données externes.

II. Tâche principale : traduire le langage naturel en actions API

La fonction fondamentale d'un agent d'appel d'API est d'interpréter la requête en langage naturel d'un utilisateur et de la convertir en un ou plusieurs appels d'API précis. Ce processus comprend généralement :

1. Reconnaissance d'intention : Comprendre l’objectif de l’utilisateur, même s’il est exprimé de manière ambiguë.
2. Sélection d'outils: Identifier le(s) point(s) de terminaison d’API appropriés (ou « outils ») à partir d’un ensemble d’options disponibles qui peuvent répondre à l’intention.
3. Extraction des paramètres : Identifier et extraire les paramètres nécessaires pour les appels d'API sélectionnés à partir de la requête de l'utilisateur.
4. Exécution et génération de réponses : Effectuer le(s) appel(s) d'API, recevoir la(les) réponse(s), puis synthétiser ces informations en une réponse cohérente ou effectuer une action ultérieure.

Imaginez une requête du type : « Dis Siri, quel temps fait-il aujourd'hui ? » L'agent doit identifier la nécessité d'appeler une API météo, déterminer la position actuelle de l'utilisateur (ou autoriser la spécification d'une position), puis formuler l'appel d'API pour récupérer les informations météorologiques.

Pour la requête « Dis Siri, quel temps fait-il aujourd'hui ? », un exemple d'appel d'API pourrait ressembler à ceci :

OBTENIR /v1/weather?location=New%20York&units=métrique

Des défis initiaux de haut niveau sont inhérents à ce processus de traduction, notamment l’ambiguïté du langage naturel et la nécessité pour l’agent de maintenir le contexte à travers des interactions en plusieurs étapes.

Par exemple, l'agent doit souvent se souvenir de parties précédentes d'une conversation ou des résultats d'appels API antérieurs pour prendre les mesures nécessaires. La perte de contexte est un mode de défaillance courant si elle n'est pas explicitement gérée.

III. Architecture de la solution : composants et protocoles clés

La création d’agents d’appel d’API efficaces nécessite une approche architecturale structurée.

1. Définition des « outils » pour l'agent

Pour qu'un LLM puisse utiliser une API, ses fonctionnalités doivent lui être décrites de manière compréhensible. Chaque point de terminaison ou fonction d'API est souvent représenté comme un « outil ». Une définition d'outil robuste comprend :

• Une description claire et en langage naturel de l’objectif et des fonctionnalités de l’outil.
• Une spécification précise de ses paramètres d'entrée (nom, type, s'il est obligatoire ou facultatif, et une description).
• Une description de la sortie ou des données renvoyées par l'outil.

2. Le rôle du protocole de contexte modèle (MCP)

Le MCP est un outil essentiel pour une utilisation plus standardisée et plus robuste des outils par les LLM. Il fournit un format structuré pour définir comment les modèles peuvent se connecter à des outils et sources de données externes.

La standardisation MCP est avantageuse car elle facilite l'intégration de divers outils et favorise la réutilisation des définitions d'outils entre différents agents ou modèles. De plus, il s'agit d'une bonne pratique pour les équipes d'ingénierie, qui doivent commencer par des spécifications d'API bien définies, telles qu'une spécification OpenAPI. Des outils comme Stainless.ai sont conçus pour faciliter la conversion de ces spécifications OpenAPI en configurations MCP, simplifiant ainsi le processus de préparation des API pour les agents.

3. Cadres d'agents et choix d'implémentation

Plusieurs frameworks peuvent faciliter la création de l'agent lui-même. Parmi eux :

• Pydantique : Bien qu'il ne s'agisse pas exclusivement d'un framework d'agents, Pydantic est utile pour définir des structures de données et garantir la sécurité des types d'entrées et de sorties d'outils, ce qui est important pour la fiabilité. De nombreuses implémentations d'agents personnalisés exploitent Pydantic pour garantir cette intégrité structurelle.
• mcp_agent de LastMile : Ce cadre est spécifiquement conçu pour fonctionner avec les MCP, offrant une structure plus avisée qui s'aligne sur les pratiques de création d'agents efficaces telles que décrites dans les recherches menées dans des endroits comme Anthropic.
• Cadre interne : Il est également de plus en plus courant d'utiliser des agents générateurs de code IA (à l'aide d'outils comme Cursor ou Cline) pour faciliter l'écriture du code standard de l'agent, de ses outils et de la logique qui l'entoure. L'expérience du laboratoire d'IA de Georgian, travaillant avec des entreprises sur des implémentations d'agents, montre que cela peut être très utile pour créer des frameworks personnalisés très minimalistes.

IV. Ingénierie pour la fiabilité et la performance

S'assurer qu'un agent effectue des appels d'API de manière fiable et performante nécessite un effort d'ingénierie ciblé. Deux méthodes permettent d'y parvenir : (1) la création et la validation d'ensembles de données ; et (2) une ingénierie et une optimisation rapides.

1. Création et validation de l'ensemble de données

L'entraînement (le cas échéant), les tests et l'optimisation d'un agent nécessitent un ensemble de données de haute qualité. Cet ensemble de données doit être composé de requêtes en langage naturel représentatives et des séquences d'appels d'API ou résultats souhaités correspondants.

• Création manuelle : La conservation manuelle d’un ensemble de données garantit une précision et une pertinence élevées, mais peut demander beaucoup de travail.
• Génération synthétique : Générer des données par programmation ou à l'aide de LLM permet de faire évoluer la création d'ensembles de données, mais cette approche présente des défis importants. Les recherches du Georgian AI Lab ont révélé qu'il est très difficile de garantir l'exactitude et la complexité réaliste des appels et requêtes d'API générés synthétiquement. Souvent, les questions générées étaient soit trop triviales, soit d'une complexité impossible, ce qui compliquait la mesure des performances nuancées des agents. Une validation rigoureuse des données synthétiques est absolument essentielle.

Pour une évaluation critique, un ensemble de données plus petit, de haute qualité et vérifié manuellement fournit souvent des informations plus fiables qu'un ensemble de données synthétiques volumineux et bruyant.

2. Ingénierie et optimisation rapides

Les performances d’un agent basé sur LLM sont fortement influencées par les invites utilisées pour guider son raisonnement et la sélection de ses outils.

• Une invite efficace implique de définir clairement la tâche de l'agent, de fournir des descriptions des outils disponibles et de structurer l'invite pour encourager une extraction précise des paramètres.
• Optimisation systématique à l'aide de cadres tels que DSpy peut améliorer considérablement les performances. DSPy vous permet de définir les composants de votre agent (par exemple, les modules de génération de pensées, la sélection d'outils, le formatage des paramètres), puis utilise une approche de type compilateur avec quelques exemples tirés de votre ensemble de données pour trouver des invites ou des configurations optimisées pour ces composants.

V. Un chemin recommandé vers des agents API efficaces

Le développement d'agents d'IA robustes appelant des API est une discipline d'ingénierie itérative. D'après les résultats des recherches du Georgian AI Lab, un workflow systématique, tel que le suivant, pourrait améliorer considérablement les résultats :

1. Commencez par des définitions d’API claires : Commencez par une présentation bien structurée Spécifications OpenAPI pour les API avec lesquelles votre agent interagira.
2. Standardiser l’accès aux outils : Convertissez vos spécifications OpenAPI en MCP Des outils comme Stainless.ai peut faciliter cela, en créant une manière standardisée pour votre agent de comprendre et d'utiliser vos API.
3. Implémenter l'agent : Choisir un cadre ou une approche appropriée. Cela peut impliquer l'utilisation Pydantique pour la modélisation des données au sein d'une structure d'agent personnalisée ou en exploitant un framework comme mcp_agent de LastMile qui est construit autour de MCP.
   • Avant de faire cela, pensez à connecter le MCP à un outil comme Claude Desktop ou Cline, et à utiliser manuellement cette interface pour avoir une idée de la façon dont un agent générique peut l'utiliser, du nombre d'itérations qu'il faut généralement pour utiliser correctement le MCP et de tout autre détail qui pourrait vous faire gagner du temps lors de la mise en œuvre.
4. Organiser un ensemble de données d’évaluation de la qualité : Créez manuellement ou validez méticuleusement un ensemble de données de requêtes et d'interactions API attendues. Ceci est essentiel pour des tests et une optimisation fiables.
5. Optimiser les invites et la logique de l'agent : Utiliser des cadres comme DSpy pour affiner les invites et la logique interne de votre agent, en utilisant votre ensemble de données pour améliorer la précision et la fiabilité.

VI. Un exemple illustratif du flux de travail

Voici un exemple simplifié illustrant le flux de travail recommandé pour la création d'un agent d'appel d'API :

Étape 1 : Commencez par des définitions d’API claires

Imaginez une API pour gérer une simple liste de tâches à faire, définie dans OpenAPI :

openapi : 3.0.0

Renseignements:

titre : API de liste de tâches

Version: 1.0.0

chemins:

/tâches :

poster:

résumé : Ajouter une nouvelle tâche

Corps de la requête :

obligatoire : vrai

contenu:

application/json :

schéma:

type : objet

Propriétés:

description:

type : chaîne

réponses:

'201':

description : tâche créée avec succès

obtenir:

résumé : Obtenir toutes les tâches

réponses:

'200':

description : Liste des tâches

Étape 2 : Standardiser l’accès aux outils

Convertissez la spécification OpenAPI en configurations MCP (Model Context Protocol). Avec un outil comme Stainless.ai, vous obtiendrez :

Étape 3 : Implémenter l'agent

En utilisant Pydantic pour la modélisation des données, créez des fonctions correspondant aux outils MCP. Utilisez ensuite un LLM pour interpréter les requêtes en langage naturel et sélectionner l'outil et les paramètres appropriés.

Étape 4 : Organiser un ensemble de données d’évaluation de la qualité

Créer un ensemble de données :

Étape 5 : Optimiser les invites et la logique de l'agent

Utilisez DSPy pour affiner les invites, en vous concentrant sur des instructions claires, la sélection d'outils et l'extraction de paramètres à l'aide de l'ensemble de données organisé pour l'évaluation et l'amélioration.

En intégrant ces éléments de base (des définitions d’API structurées et des protocoles d’outils standardisés aux pratiques de données rigoureuses et à l’optimisation systématique), les équipes d’ingénierie peuvent créer des agents d’IA d’appel d’API plus performants, plus fiables et plus faciles à maintenir.