Guide pour comprendre, créer et optimiser les agents appelant les API API de liste de tâches version : 1.0.0 paths : /tâches : post : résumé : Ajouter une nouvelle tâche corps de la requête : requis : true 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 get : résumé : Récupérer toutes les tâches réponses : ‘200’ : description : Liste de tâches Étape 2 : Standardiser l’accès aux outils Convertir la spécification OpenAPI en configurations MCP. En utilisant un outil comme Stainless.ai, cela pourrait donner : Nom de l’outil Description Paramètres d’entrée Description de la sortie Ajouter une tâche Ajoute une nouvelle tâche à la liste de tâches. `description` (chaîne, requis) : La description de la tâche. Confirmation de création de tâche. Récupérer les tâches Récupère toutes les tâches de la liste de tâches. Aucun Une liste de tâches avec leurs descriptions. Étape 3 : Mettre en œuvre l’agent En utilisant Pydantic pour la modélisation de données, créez des fonctions correspondant aux outils MCP. Ensuite, utilisez un LLM pour interpréter les requêtes en langage naturel et sélectionner l’outil et les paramètres appropriés. Étape 4 : Curater un jeu de données d’évaluation de haute qualité Créez un jeu de données : Requête Appel d’API attendu Résultat attendu « Ajouter ‘Acheter des courses’ à ma liste. » « Ajouter une tâche » avec `description` = « Acheter des courses » Confirmation de création de tâche « Qu’est-ce qui est sur ma liste ? » « Récupérer les tâches » Liste de tâches, y compris « Acheter des courses » É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 en utilisant le jeu de données curé 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 à des pratiques de données rigoureuses et une optimisation systématique – les équipes d’ingénierie peuvent créer des agents appelant les API plus capables, fiables et maintenables.

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 capables d’exécuter des tâches. Selon une enquête menée en mars 2025 sur l’adoption de l’IA à l’échelle mondiale par Georgian et NewtonX, 91 % des dirigeants techniques dans les entreprises en croissance et les entreprises sont censés utiliser ou planifier l’utilisation de l’IA agente.

Les agents appelant les API sont un exemple primordial de ce déplacement vers les agents. Les agents appelant les API utilisent des modèles de langage à grande échelle (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 la fonctionnalité logicielle.

Les entreprises utilisent actuellement des agents appelant les API dans divers domaines, notamment :

• Applications grand public : Les assistants comme Siri d’Apple ou Alexa d’Amazon ont été conçus pour simplifier les tâches quotidiennes, telles que la gestion des appareils intelligents pour la maison et la prise de réservations.
• Flux de travail d’entreprise : Les entreprises ont déployé des agents API pour automatiser des tâches répétitives comme 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 de données : Les entreprises utilisent des agents API pour simplifier l’accès à des ensembles de données propriétaires, à des ressources basées sur abonnement et à des API publiques afin de générer des informations.

Dans cet article, je vais utiliser une approche centrée sur l’ingénierie pour comprendre, créer et optimiser les agents appelant les API. Le contenu de cet article est basé en partie sur la recherche et le développement pratiques menés par le laboratoire d’IA de Georgian. La question motrice pour une grande partie de la recherche du laboratoire d’IA dans le domaine des agents appelant les API a été : « Si une organisation dispose d’une API, quelle est la manière la plus efficace de créer un agent capable d’interagir avec cette API à l’aide du langage naturel ? »

Je vais expliquer comment les agents appelant les API fonctionnent et comment architecturer et concevoir ces agents pour les performances. Enfin, je vais fournir un flux de travail systématique que les équipes d’ingénierie peuvent utiliser pour mettre en œuvre les agents appelant les API.

I. Définitions clés :

• API ou Interface de programmation d’applications : Un ensemble de règles et de protocoles permettant à différents logiciels d’échanger des informations.
• Agent : Un système d’IA conçu pour percevoir son environnement, prendre des décisions et agir pour atteindre des objectifs spécifiques.
• Agent appelant les API : Un agent d’IA spécialisé qui traduit des instructions en langage naturel en appels d’API précis.
• Agent de génération de code : Un système d’IA qui aide au développement logiciel en écrivant, en modifiant et en déboguant du code. Bien que lié, mon accent ici est principalement sur les agents qui appellent 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 la façon dont les LLM peuvent se connecter à des outils et des sources de données externes.

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

La fonction fondamentale d’un agent appelant les API est d’interpréter une demande en langage naturel de l’utilisateur et de la convertir en un ou plusieurs appels d’API précis. Ce processus implique 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 les points de terminaison d’API appropriés (ou « outils ») parmi les options disponibles qui peuvent remplir l’intention.
3. Extraction de 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 les appels d’API, recevoir les réponses et synthétiser ces informations en une réponse cohérente ou effectuer une action ultérieure.

Considérez une demande comme « Hé Siri, quel temps fait-il aujourd’hui ? » L’agent doit identifier le besoin d’appeler une API météorologique, déterminer l’emplacement actuel de l’utilisateur (ou permettre la spécification d’un emplacement) et formuler l’appel d’API pour récupérer les informations météorologiques.

Pour la demande « Hé Siri, quel temps fait-il aujourd’hui ? », un exemple d’appel d’API pourrait ressembler à ceci :

GET /v1/weather?location=New%20York&units=metric

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

Par exemple, l’agent doit souvent « se souvenir » de parties précédentes d’une conversation ou de résultats d’appels d’API antérieurs pour éclairer les actions actuelles. La perte de contexte est un mode de défaillance courant si elle n’est pas explicitement gérée.

III. Architecturer la solution : composants clés et protocoles

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

1. Définir les « outils » pour l’agent

Pour qu’un LLM utilise une API, les capacités de cette API doivent lui être décrites de manière qu’il puisse la comprendre. Chaque point de terminaison d’API ou fonction est souvent représenté comme un « outil ». Une définition d’outil robuste inclut :

• Une description claire en langage naturel de l’objectif et de la fonctionnalité de l’outil.
• Une spécification précise de ses paramètres d’entrée (nom, type, si requis ou facultatif, et description).
• Une description de la sortie ou des données que l’outil renvoie.

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

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

La standardisation du MCP est bénéfique car elle permet une intégration plus facile d’outils divers, elle 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, en commençant par des spécifications d’API bien définies, telles qu’une spécification OpenAPI. Des outils comme Stainless.ai sont conçus pour aider à convertir ces spécifications OpenAPI en configurations MCP, rationalisant le processus de mise à disposition des API « prêtes pour les agents ».

3. Cadres d’agent et choix d’implémentation

Plusieurs cadres peuvent aider à construire l’agent lui-même. Ceux-ci incluent :

• Pydantic : Bien que ce ne soit pas exclusivement un cadre d’agent, Pydantic est utile pour définir des structures de données et assurer la sécurité des types pour les entrées et les sorties d’outils, ce qui est important pour la fiabilité. De nombreuses implémentations d’agents personnalisés utilisent Pydantic pour cette intégrité structurelle.
• mcp_agent de LastMile : Ce cadre est spécifiquement conçu pour fonctionner avec les MCP, offrant une structure plus opinée qui correspond aux pratiques pour construire des agents efficaces, comme décrit dans la recherche menée par des entreprises comme Anthropic.
• Cadre interne : Il est également de plus en plus courant d’utiliser des agents de génération de code d’IA (en utilisant des outils comme Cursor ou Cline) pour aider à écrire le code de base pour l’agent, ses outils et la logique environnante. L’expérience du laboratoire d’IA de Georgian en travaillant avec des entreprises sur les implémentations d’agents montre que cela peut être excellent pour créer des cadres personnalisés très minimaux.

IV. Ingénierie pour la fiabilité et les performances

Assurer qu’un agent effectue des appels d’API de manière fiable et performante nécessite un effort d’ingénierie ciblé. Deux moyens de le faire sont (1) la création et la validation de jeux de données et (2) l’ingénierie et l’optimisation des invites.

1. Création et validation de jeux de données

La formation (si applicable), le test et l’optimisation d’un agent nécessitent un jeu de données de haute qualité. Ce jeu de données doit se composer de requêtes en langage naturel représentatives et de leurs séquences d’appels d’API ou de résultats souhaités correspondants.

• Création manuelle : La curation manuelle d’un jeu de données garantit une grande précision et une pertinence, mais peut être fastidieuse.
• Génération synthétique : La génération de données de manière programmatique ou en utilisant des LLM peut rationaliser la création de jeux de données, mais cette approche présente des défis importants. La recherche du laboratoire d’IA de Georgian a constaté que garantir la correction et la complexité réaliste des appels d’API et des requêtes générés synthétiquement est très difficile. Souvent, les questions générées étaient soit trop triviales, soit impossiblement complexes, rendant difficile la mesure des performances nuancées de l’agent. Une validation minutieuse des données synthétiques est absolument critique.

Pour une évaluation critique, un jeu de données manuel de haute qualité et de petite taille offre souvent des informations plus fiables qu’un grand jeu de données synthétique bruyant.

2. Ingénierie et optimisation des invites

Les performances d’un agent basé sur un LLM sont fortement influencées par les invites utilisées pour guider sa réflexion et sa sélection d’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 de paramètres précise.
• L’optimisation systématique à l’aide de cadres comme DSPy peut considérablement améliorer les performances. DSPy permet de définir les composants de l’agent (par exemple, des modules pour la génération de pensées, la sélection d’outils, la mise en forme de paramètres) et utilise ensuite une approche de type compilateur avec quelques exemples de votre jeu de données pour trouver des invites ou des configurations optimisées pour ces composants.

V. Un chemin recommandé pour les agents API efficaces

Le développement d’agents appelant les API robustes est une discipline d’ingénierie itérative. Sur la base des résultats de la recherche du laboratoire d’IA de Georgian, les résultats peuvent être améliorés de manière significative en utilisant un flux de travail systématique comme suit :

1. Commencer avec des définitions d’API claires : Commencer avec des spécifications OpenAPI bien structurées pour les API avec lesquelles l’agent interagira.
2. Standardiser l’accès aux outils : Convertir vos spécifications OpenAPI en outils MCP. Des outils comme Stainless.ai peuvent faciliter cela, créant une manière standardisée pour que votre agent comprenne et utilise vos API.
3. Mettre en œuvre l’agent : Choisir un cadre ou une approche appropriés. Cela pourrait impliquer l’utilisation de Pydantic pour la modélisation de données dans une structure d’agent personnalisée ou l’utilisation d’un cadre comme mcp_agent de LastMile qui est conçu autour des MCP.
   • Avant de le faire, envisagez de connecter le MCP à un outil comme Claude Desktop ou Cline, et utilisez manuellement cette interface pour avoir une idée de la façon dont un agent générique peut l’utiliser, combien d’itérations il faut généralement pour utiliser correctement le MCP et tout autre détail qui pourrait vous faire gagner du temps pendant la mise en œuvre.
4. Curater un jeu de données d’évaluation de haute qualité : Créer manuellement ou valider soigneusement un jeu de données de requêtes et d’interactions d’API souhaitées. C’est crucial 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 l’agent, en utilisant votre jeu de données pour conduire l’amélioration de la précision et de 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 appelant les API :

Étape 1 : Commencer avec des définitions d’API claires

Imaginez une API pour la gestion d’une liste de tâches simple, définie dans OpenAPI :

openapi : 3.0.0

info :