Connecter un agent à une API : hypermédia ou MCP ?
Un agent peut suivre les liens et les actions d’une API hypermédia. Voici comment cela fonctionne, ce que MCP apporte et les critères utiles pour choisir.
Article
Un agent combine des appels d’API dans un script au lieu de multiplier les échanges avec le modèle. Bénéfices, limites et place de MCP dans cette approche.
Pour préparer un rapport, un agent doit parfois chercher des commandes, filtrer les résultats et calculer des totaux. Il peut appeler un outil à chaque étape, ou écrire un script qui enchaîne ces opérations. Quand vaut-il mieux lui faire écrire du code ? Le code devient intéressant lorsque ces combinaisons se multiplient : il permet de travailler sur les données sans renvoyer chaque résultat intermédiaire au modèle. Il demande en retour un contrat d’API exact et un environnement d’exécution limité.
Le coût d’un grand catalogue d’outils pose le problème, et un rapport sur des commandes paginées, écrit en code, sert d’exemple, pannes comprises. Viennent ensuite ce que mesurent les publications, la place de MCP sous ce code, l’environnement qui l’exécute, et ce que devient le script une fois qu’il a fait ses preuves.
Un outil décrit une action disponible, ses paramètres et son résultat. Quand le modèle l’appelle, il produit une demande ; le programme qui l’héberge exécute l’action et renvoie le résultat dans le contexte, le texte que le modèle reçoit pour préparer sa réponse suivante. Chaque résultat repasse donc par le modèle avant l’étape suivante.
Avec quelques opérations bien nommées, cette interface peut être facile à utiliser. Avec des centaines d’outils proches, l’agent doit trouver le bon et comprendre des différences parfois subtiles. Les descriptions occupent aussi une partie du contexte : présenter tout le catalogue à chaque appel peut coûter cher, même lorsque la tâche n’en utilise qu’une petite partie. L’article Outils d’un agent IA : montrer ce qui aide vraiment à choisir détaille ce coût.
Une découverte à la demande limite ce coût : le modèle cherche d’abord les capacités pertinentes, puis lit leur documentation. L’exécution de code peut compléter cette approche pour combiner les appels retenus. L’agent dispose alors d’un outil de plus, qui exécute un script, et ce script enchaîne lui-même les appels.
Une API fictive expose un instantané S42 : une version figée des commandes, qu’elle sert par pages. Chaque page indique un curseur, le repère qui permet de demander la page suivante. Une fonction hôte autorisée, lirePage(curseur), renvoie l’identifiant de l’instantané, les commandes et le curseur suivant, ou lève une erreur. Elle conserve les identifiants d’accès et vérifie la destination. Le script compose ces lectures ; il ne reçoit ni une clé ni un accès réseau général.
Le rapport retient les commandes expédiées dont le montant est strictement supérieur à 100 euros. Les montants sont des entiers en centimes, tous en EUR. L’API garantit que les pages d’un même instantané restent stables pendant sa durée de consultation.
async function rapport(lirePage, seuil = 10000) {
let curseur = null, instantane = null, total = 0;
const preuves = [], pages = new Set(), ids = new Set();
do {
if (pages.has(curseur)) throw new Error('curseur cyclique');
pages.add(curseur);
const page = await lirePage(curseur);
if (!page.instantane || !Array.isArray(page.commandes))
throw new Error('page invalide');
instantane ??= page.instantane;
if (page.instantane !== instantane) throw new Error('instantane change');
for (const c of page.commandes) {
if (ids.has(c.id)) throw new Error('commande repetee');
ids.add(c.id);
if (c.devise !== 'EUR' || !Number.isSafeInteger(c.centimes))
throw new Error('montant invalide');
if (c.statut === 'expediee' && c.centimes > seuil) {
total += c.centimes;
if (!Number.isSafeInteger(total)) throw new Error('total trop grand');
preuves.push({id: c.id, centimes: c.centimes});
}
}
curseur = page.suivant;
if (curseur !== null && typeof curseur !== 'string')
throw new Error('curseur invalide');
} while (curseur !== null);
return {instantane, complet: true, total_centimes: total, preuves};
}
Chaque throw protège le calcul ou son aboutissement. Un curseur déjà vu ferait relire des pages à l’infini. Un changement d’instantané mélangerait deux états des commandes. Une commande répétée pourrait être comptée deux fois. Une devise inattendue ou un montant qui n’est pas un entier fausserait la somme sans bruit.
La première page contient C1 expédiée à 120 euros et C2 annulée à 300 euros. La seconde contient C3 expédiée à exactement 100 euros et C4 expédiée à 180 euros. Le résultat vaut 30 000 centimes avec les preuves C1 et C4 ; C3 est exclue par le seuil strict. Ces lignes et ce contrat sont fictifs. Le code a été exécuté sur ces jeux de données de test, y compris les branches de panne.
Si la seconde page échoue, la promesse du script est rejetée. Il ne retourne pas complet: true avec les seuls 120 euros de C1. Dans cet exemple de lecture sans effet métier, le programme qui appelle rapport peut relancer entièrement le calcul sur le même instantané S42, s’il est encore disponible. S’il a expiré, ce programme doit obtenir un nouvel instantané et relancer tout le calcul ; la fonction, elle, refuse de mélanger la première page de S42 et la seconde de S43. Cette reprise n’est pas implémentée dans la fonction montrée.
Les essais vérifient le total, l’échec sur la deuxième page, une nouvelle invocation après cet échec, le changement d’instantané, un identifiant dupliqué, un curseur cyclique et une devise incorrecte. Ils contrôlent le code de composition, pas la sécurité de la fonction hôte ni une API réelle. Un gros rapport exigerait aussi un budget de pages, de temps et de preuves retournées : le détail peut alors rester dans un fichier autorisé, dont le script renvoie la référence.
Des outils séparés peuvent accomplir le même travail. Mais dans une boucle d’appels directs qui lui renvoie toutes les pages, chaque page reviendrait dans le contexte, et le modèle devrait garder les montants d’une page à l’autre pour les additionner, à moins qu’un outil dédié n’agrège les montants côté serveur. Avec le script, seul l’objet final, le total et ses preuves, revient au modèle. C’est le choix de composition que décrit Code Mode de Cloudflare : convertir les outils en une API TypeScript que le modèle appelle depuis du code. Cloudflare en avance une explication, présentée d’abord comme une hypothèse : les modèles ont vu beaucoup de code réel pendant leur entraînement, et jamais, dans les textes réels, les jetons spéciaux des appels d’outils.
Plusieurs travaux comparent les approches. Ils comptent en tokens, les unités de texte que traite le modèle. Leurs résultats portent sur des configurations et des tâches particulières ; ils ne prédisent pas à eux seuls le coût de votre agent.
| Source et contexte | Résultat rapporté | Ce qu'il faut comparer chez vous |
|---|---|---|
| Cloudflare, février 2026, exposition de plus de 2 500 points d'accès | Environ mille tokens pour l'interface proposée, contre 1,17 million pour le catalogue complet | Volume de documentation réellement chargé pendant une tâche |
| Anthropic, novembre 2025, exemple d'exécution de code avec MCP : copier une transcription de Google Drive vers Salesforce, outils lus à la demande | Passage de 150 000 à 2 000 tokens dans l'exemple | Définitions d’outils réellement chargées, résultats intermédiaires évités et appels supplémentaires nécessaires |
| CodeAct, 2024, 17 modèles comparés sur API-Bank et un banc d’essai construit par les auteurs | Taux de réussite annoncé jusqu’à 20 % plus élevé que les alternatives courantes, des actions en JSON ou en texte | Taux de réussite sur vos propres opérations et erreurs de code |
Réduire le nombre de tokens peut diminuer le coût, mais un script incorrect peut demander plusieurs corrections. Mesurez donc la tâche complète, y compris les reprises. Pour le rapport, cela revient à comparer deux parcours sur les mêmes pages : le nombre d’appels au modèle, les tokens envoyés, les scripts à corriger et le temps total, jusqu’à un total juste.
MCP, ou Model Context Protocol, est un protocole ouvert qui relie les applications de LLM à des sources de données et à des outils externes. Dans sa version de spécification du 28 juillet 2026, un serveur MCP peut offrir des ressources, des modèles de messages et des outils ; chaque outil est identifié par un nom et décrit par le schéma de ses paramètres, et le client l’appelle par des messages JSON-RPC. MCP ne décide pas à lui seul si l’agent doit appeler chaque outil séparément ou les combiner par du code.
Cloudflare et Anthropic conservent MCP sous leur couche d’exécution. Le script compose des outils fournis par ce protocole. Une autre architecture peut appeler directement des API HTTP, si leurs contrats et leurs contrôles d’accès sont disponibles. Dans le rapport, lirePage peut ainsi s’appuyer sur un outil MCP ou sur un appel HTTP direct à l’API des commandes : le script ne voit pas la différence.
L’accès direct à une API claire est préférable lorsqu’une couche supplémentaire ne répond à aucun besoin d’intégration. Un outil MCP est un appel de procédure nommé, propre à un serveur ; une API HTTP aux ressources claires reprend des conventions que le modèle a déjà rencontrées, même s’il doit toujours lire son contrat métier : ses ressources, ses paramètres et ses règles. Si MCP apporte la découverte, l’authentification ou la compatibilité avec les outils déjà utilisés, le conserver peut au contraire simplifier l’ensemble. Cloudflare le garde d’ailleurs sous Code Mode pour connecter et documenter les API de façon uniforme : son argument porte sur le code, pas sur le choix entre HTTP et MCP.
Le code et l’API ne sont d’ailleurs pas deux réponses concurrentes : le script est ce avec quoi l’agent s’adresse au système, et l’API ce à quoi il s’adresse. Combinez-les de préférence : du code qui suit les liens et les actions que décrivent les réponses d’une API hypermédia, c’est-à-dire une API dont chaque réponse indique ce qu’il est possible de faire ensuite. Le programme conserve les variables, compose les appels et traite les erreurs, ce qu’un appel d’outil isolé ne fait pas. Le curseur du rapport n’en donne qu’une forme minimale : il dit où lire la page suivante, pas quelles actions sont permises. L’article Connecter un agent à une API : hypermédia ou MCP ? traite la forme de cette API. Le critère utile pour l’agent reste la clarté du contrat : quelle action est possible, avec quels paramètres, et comment interpréter son résultat ?
Un script généré peut contenir une erreur ou demander une action inadaptée. Son environnement doit donc limiter les accès réseau, les données accessibles, la durée de calcul et la mémoire. Anthropic le rappelle dans le même article : exécuter du code produit par un agent demande un environnement d’exécution sûr, avec des limites de ressources et une surveillance. Les services appelés continuent à vérifier les droits et les règles métier.
Les identifiants restent dans la couche qui exécute les appels, comme dans lirePage. Le modèle choisit une opération autorisée sans avoir à lire la clé qui l’authentifie. Dans Code Mode, Cloudflare interdit au bac à sable de joindre Internet et lui donne seulement des liaisons déjà autorisées vers les serveurs MCP, si bien que le code écrit par le modèle ne peut pas divulguer ces clés, qu’il ne voit jamais. Les destinations réseau et les redirections demandent aussi un contrôle explicite.
Le bac à sable JavaScript avec QuickJS et WebAssembly illustre une manière d’organiser cette séparation. Le choix d’un interpréteur ne remplace pas l’analyse de ce que ses fonctions autorisent.
Après validation, un script peut être conservé, testé et exécuté sans redemander au modèle de le produire. Si le rapport des commandes revient chaque semaine, la fonction rapport peut être gardée telle quelle, avec ses essais, et lancée sans modèle. Cela convient aux tâches qui finissent par suivre toujours les mêmes étapes ; l’article Quand remplacer un agent IA par un workflow prévisible suit ce passage.
Le résultat n’est pas automatiquement fiable parce qu’il est écrit en code. Il faut définir les entrées, traiter les erreurs et vérifier les effets en cas de nouvelle tentative. Les outils dédiés peuvent eux aussi être réutilisés dans un workflow classique.
Pour le rapport, le code a apporté trois choses : les pages et les calculs sont restés hors du contexte, les cas de panne ont produit des erreurs explicites au lieu d’un total partiel, et la fonction validée peut resservir. Il a demandé en échange une fonction hôte qui garde les identifiants, un contrat d’API précis et un environnement limité. Ce bilan vaut pour un travail de lecture et de calcul aux combinaisons variables. Gardez quelques outils spécialisés lorsque leur contrat protège une action sensible ou simplifie un usage fréquent ; préférez la composition par code lorsque les combinaisons variables apportent un bénéfice mesuré et que vous disposez d’un environnement d’exécution correctement limité.
Explorer
Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.
Un agent peut suivre les liens et les actions d’une API hypermédia. Voici comment cela fonctionne, ce que MCP apporte et les critères utiles pour choisir.
Quand les étapes et les règles se stabilisent, un workflow peut remplacer le travail répété de l’agent. Il reste à tester le code et à organiser sa maintenance.
Un grand catalogue occupe du contexte et peut compliquer le choix des outils. La découverte à la demande aide, à condition de mesurer la réussite de la tâche.
Laisser un commentaire
Votre commentaire sera relu avant d'être publié.