Exécution de code avec MCP : une nouvelle approche de l'efficacité des agents d'IA

Le document Anthropic présente une méthode permettant aux agents d'IA d'interagir avec les serveurs MCP (Model Context Protocol) en écrivant du code exécutable plutôt qu'en appelant directement les outils. L'agent traite les outils comme des fichiers sur un ordinateur, trouve les éléments nécessaires et les utilise directement dans son code, évitant ainsi le passage des données intermédiaires par la mémoire du modèle. Nous avons testé cette approche afin de déterminer si elle permet de réduire le coût des jetons tout en conservant le même taux de réussite.

Exécution de code avec MCP vs MCP standard

Nous avons comparé deux approches pour la construction d'agents d'IA interagissant avec des outils externes via le MCP :

• MCP standard : Approche traditionnelle où toutes les définitions d'outils sont chargées dans la fenêtre de contexte du modèle
• Exécution de code MCP : Approche novatrice où le modèle écrit du code qui appelle des outils, en conservant les données intermédiaires hors contexte

Principales conclusions

Économies de jetons d'entrée : l'exécution du code utilise 78,5 % de jetons d'entrée en moins (165 000 contre 771 000) :

• Chargement régulier d'environ 15 400 jetons de définitions d'outils par appel
• L'exécution du code ne nécessite qu'environ 3 300 jetons par appel.

Jetons de sortie plus nombreux : L’approche d’exécution de code utilise 2,2 fois plus de jetons de sortie car le modèle écrit du code et des explications.

Économies nettes de jetons : réduction totale de 77,4 % (175 000 contre 775 000)

Incidences en termes de coûts :

• Les jetons d'entrée sont généralement moins chers que les jetons de sortie.
• Mais les économies réalisées sur les intrants, à hauteur de 78 %, compensent largement le doublement de la production.
• Réduction des coûts estimée à environ 70 % grâce à l'exécution du code

Les deux ont atteint un taux de réussite de 100 % sur ces requêtes avec GPT-4.1.

L'approche d'exécution de code est inspirée par le billet de Anthropic sur l'utilisation de l'exécution de code avec MCP pour réduire l'utilisation de la fenêtre de contexte tout en maintenant la capacité de l'agent. ¹

Méthodologie d'exécution du code avec comparaison MCP

Tâches

Nous exécutons chaque tâche 50 fois pour chaque approche :

• Rendez-vous sur https://aimultiple.com/open-source-embedding-models et indiquez-moi les 5 modèles les plus performants (c'est-à-dire les modèles avec une précision de 100 % dans les 5 meilleurs résultats).
• Rendez-vous sur https://aimultiple.com/open-source-embedding-models et dites-moi quel modèle présente la latence la plus élevée.

Configuration de comparaison

Nous avons utilisé le serveur MCP de Bright Data avec le mode pro activé, car il avait la plus grande précision dans notre test de référence MCP du navigateur.

Nous avons utilisé GPT-4.1 comme LLM en raison de sa grande fenêtre de contexte.

Configuration de l'environnement : Nous avons effacé les données en cache et établi une nouvelle connexion au serveur MCP à chaque exécution. Chaque requête est exécutée comme un sous-processus distinct.

Comparaison architecturale

Architecture MCP régulière

Dans l'approche MCP classique, l'agent suit un flux simple : la requête de l'utilisateur est transmise à un agent LangGraph ReAct, qui a accès aux 63 définitions d'outils dans sa fenêtre de contexte. L'agent sélectionne et appelle les outils via la session client MCP, et les résultats sont renvoyés dans la fenêtre de contexte pour déterminer l'action suivante de l'agent.

Architecture MCP d'exécution de code

L'approche d'exécution de code ajoute une couche intermédiaire : la requête utilisateur est transmise à un agent d'exécution de code doté d'un contexte réduit (noms des outils uniquement, sans schémas complets). Cet agent génère du code Python qui appelle les outils. Ce code s'exécute dans un environnement d'exécution de code isolé, qui communique avec la session client MCP. Seuls les résultats finaux ou les résumés sont renvoyés au contexte de l'agent, et non les données intermédiaires brutes.

L'implémentation de l'exécution du code utilise la divulgation progressive. Seuls les noms des outils et des descriptions tronquées (60 caractères) sont inclus dans l'invite système. Lorsque le modèle a besoin d'utiliser un outil, il génère du code Python qui appelle la fonction asynchrone `call_tool()` fournie dans l'environnement d'exécution.

Limites de notre approche

1. Diversité des requêtes : Seuls 2 types de requêtes ont été testés ; les résultats peuvent varier pour d’autres types de tâches.
2. Modèle unique : testé uniquement avec GPT-4.1 ; d’autres modèles peuvent présenter des résultats différents.
3. Qualité du code : Le succès de l’exécution du code dépend de la capacité du modèle à générer du code ; cela peut entraîner une baisse des taux de réussite dans les tâches plus complexes.

Pourquoi les MCP traditionnels gaspillent des ressources

Problème 1 : Les définitions d’outils consomment un contexte excessif

Chaque outil nécessite des instructions dans la mémoire du modèle. Un exemple simple :

 gdrive.getDocument
 Récupère un fichier depuis le lecteur Google
 Besoins : identifiant du document
 Retourne : le contenu du fichier

Exemple : Un agent connecté à 50 serveurs, chacun équipé de 20 outils, représente 1 000 définitions d’outils. À raison d’environ 150 jetons par définition, cela correspond à 150 000 jetons consommés avant même que l’agent ne traite votre première requête.

Problème 2 : Les données sont traitées plusieurs fois

Tâche : « Récupérez mes notes de réunion depuis Google Drive et ajoutez-les à Salesforce. »

Ce qui se produit:

1. L'agent reçoit le document (50 000 jetons)
2. Le modèle le lit
3. L'agent l'envoie à Salesforce (50 000 jetons supplémentaires)

Le modèle gère plus de 100 000 jetons pour déplacer des données d'un endroit à un autre – un peu comme si quelqu'un lisait un livre entier à voix haute juste pour le remettre à quelqu'un d'autre.

Quand utiliser l'exécution de code avec MCP ?

L'exécution de code avec MCP remédie à deux inefficacités fondamentales des implémentations MCP traditionnelles :

1. Les définitions d'outils n'encombrent plus la fenêtre de contexte.
2. Les données intermédiaires cessent de circuler inutilement dans le modèle.

Cette approche fonctionne le mieux lorsque :

• Vous avez de nombreux outils MCP connectés
• Vos flux de travail impliquent un traitement de données en plusieurs étapes
• Les documents volumineux ou les ensembles de données sont déplacés entre les outils.
• Les limites de la fenêtre de contexte affectent vos agents

Les exigences en matière d'infrastructure font que cette solution n'est pas systématiquement meilleure pour tous les cas d'utilisation. Les déploiements à petite échelle avec peu d'outils peuvent ne pas justifier la complexité opérationnelle.

Pour les organisations qui utilisent déjà des agents dotés de catalogues d'outils MCP étendus, le potentiel de réduction des jetons de plus de 98 % et les économies de coûts correspondantes rendent cette approche digne d'être étudiée.

Liens de référence

1.

Code execution with MCP: building more efficient AI agents \ Anthropic

Sena Sezer

Analyste du secteur

Suivre

Sena est analyste sectorielle chez AIMultiple. Elle a obtenu sa licence à l'Université de Bogazici.

Voir le profil complet

Recherche effectuée par

Şevval Alper

Chercheur en IA

Suivre

Şevval est analyste chez AIMultiple, spécialisé dans les outils de codage IA, les agents IA et les technologies quantiques.

Voir le profil complet

Soyez le premier à commenter

Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires.

Nom

Adresse email

Commentaire

0/450

Publier un commentaire