Présentation de TrueFoundry MCP Gateway : résoudre le problème d'intégration N×M pour les agents d'IA

Si vous créez des agents d'IA qui doivent interagir avec des outils et des API externes, vous êtes probablement confronté au même mur que nous : le problème d'intégration N×M. À mesure que le nombre d'agents (N) et d'outils (M) augmente, chaque agent finit par implémenter sa propre connexion, authentification et gestion des erreurs pour chaque outil. Cela crée une matrice N×M d'intégrations point à point qui devient difficile à gérer, à sécuriser et à respecter. Chaque agent se connectant directement à chaque outil crée un réseau enchevêtré de connexions point à point.

Aujourd'hui, nous sommes ravis de vous annoncer le Passerelle MCP TrueFoundry - une plateforme prête à l'emploi qui centralise l'accès aux outils de développement de l'IA à l'aide du Model Context Protocol (MCP). Au lieu de gérer des centaines de configurations d'outils individuelles au sein de vos équipes de développement, vous pouvez fournir un accès sécurisé et régi à des outils d'IA sélectionnés via une plateforme unique.

Le problème : les connexions entre l'agent direct et l'outil ne sont pas évolutives

Lorsque les agents se connectent directement aux outils, chaque agent devient son propre hub d'intégration miniature. Cela fonctionne bien pour un agent qui parle à un seul outil, mais cela s'effondre rapidement à mesure que votre application se développe.

Prolifération des accréditations et risques de sécurité

Dans un modèle de connexion directe, chaque agent stocke et gère les informations d'identification pour chaque outil auquel il accède. Cela crée une surface d'attaque massive. Vous avez des clés d'API, des jetons OAuth et des chaînes de connexion à la base de données dispersés dans plusieurs bases de code d'agent, fichiers de configuration et variables d'environnement. Cette prolifération des informations d'identification rend la rotation sécurisée quasiment impossible et augmente considérablement le risque de fuite. Si un agent est compromis, il pourrait exposer les informations d'identification de dizaines de services internes et externes critiques.

Observabilité des trous noirs

Sans point central de contrôle du trafic, il est impossible d'obtenir une vue unifiée des interactions agent-outil. Un outil spécifique est-il lent ? Est-ce qu'un agent passe trop d'appels ? Quelle action de l'utilisateur a déclenché une cascade de cinq appels d'outils différents ? Pour répondre à ces questions, vous devez assembler les journaux de N agents différents, ce qui est souvent peu pratique. Vous vous retrouvez avec un trou noir d'observabilité où le débogage est réactif et le réglage des performances est basé sur des conjectures, et non sur des données.

Gestion des erreurs et nouvelles tentatives incohérentes

Chaque outil externe possède ses propres modes de défaillance, limites de débit et conditions d'erreur transitoires. Dans un modèle décentralisé, chaque développeur d'agent doit implémenter une gestion des erreurs robuste, telle que l'arrêt exponentiel, les nouvelles tentatives pour les opérations idempotentes et les disjoncteurs. Cela se traduit par des implémentations incohérentes et souvent incomplètes. Un agent peut retenter un appel de manière agressive, en lançant accidentellement une attaque par déni de service contre un outil défaillant, tandis qu'un autre peut échouer silencieusement et faire dérailler un processus métier critique.

Frais de maintenance élevés

Chaque intégration de nouveaux outils représente un effort de développement important, répété par de nombreux agents. Les développeurs perdent du temps à écrire du code standard pour l'authentification, la signature des demandes et l'analyse des réponses au lieu de se concentrer sur la logique de base des agents. Lorsque l'API d'un outil change, vous devez identifier et mettre à jour chaque agent qui l'utilise individuellement. Ces frais de maintenance élevés ralentissent la vitesse de développement et compliquent l'extension des capacités d'un agent.

La solution : MCP Gateway

Le MCP est un protocole ouvert qui normalise la façon dont les applications fournissent un contexte aux LLM. Considérez le MCP comme un port USB-C pour les applications d'IA : il fournit un moyen standardisé de connecter des modèles d'IA à différentes sources de données et outils.

Les serveurs MCP sont des programmes qui exposent les données et les fonctionnalités aux LLM via le protocole MCP. Par exemple :

• Un serveur MCP Slack peut exposer des outils tels que « Envoyer un message à une chaîne » ou « Rechercher des messages »
• Un serveur MCP GitHub peut exposer des outils tels que « Obtenir la liste des référentiels » ou « Créer une pull request »

Une passerelle MCP est un proxy inverse spécialisé qui se trouve entre vos agents IA (les clients) et vos outils (les serveurs MCP). Dans la pratique, il fonctionne comme un centre centralisé Hub MCP, consolidant la découverte, l'authentification, le routage et l'observabilité des outils en un point de contrôle unique pour toutes les interactions agent-outil. Au lieu que les agents se connectent directement à des dizaines de terminaux d'outils différents, ils se connectent tous à un point de terminaison de passerelle unique et unifié. La passerelle achemine ensuite les demandes de manière sécurisée vers les outils en amont appropriés. Cette architecture permet de résoudre des problèmes critiques pour les développeurs qui créent des systèmes agentiques :

Sécurité et gouvernance centralisées : La passerelle devient un point d'étranglement unique pour toutes les interactions agent-outil. Vous pouvez appliquer l'authentification, l'autorisation (comme le contrôle d'accès basé sur les rôles) et créer des journaux d'audit détaillés en un seul endroit.

Observabilité unifiée : Une passerelle MCP centralise la journalisation, les métriques et le suivi. Vous pouvez surveiller la latence, suivre les taux d'erreur et suivre une tâche d'agent complexe sur plusieurs appels d'outils à partir d'un seul tableau de bord.

Efficacité opérationnelle : Une passerelle simplifie la gestion des outils. Il gère un registre central des outils disponibles, afin que les agents puissent les découvrir de manière dynamique. Il gère les informations d'identification pour tous les outils en amont, en les injectant de manière sécurisée dans les demandes selon les besoins.

Gestion des coûts : Les agents d'IA peuvent être coûteux, car ils passent de nombreux appels vers des LLM et des API d'outils payants. Une passerelle vous permet de gérer ces coûts grâce à la mise en cache, à la limitation du débit et à des contrôles budgétaires.

Key Metrics for Evaluating Gateway

Criteria	What should you evaluate ?	Priority	TrueFoundry
Latency	Adds <10ms p95 overhead for time-to-first-token?	Must Have	✅ Supported
Data Residency	Keeps logs within your region (EU/US)?	Depends on use case	✅ Supported
Latency-Based Routing	Automatically reroutes based on real-time latency/failures?	Must Have	✅ Supported
Key Rotation & Revocation	Rotate or revoke keys without downtime?	Must Have	✅ Supported
Key Rotation & Revocation	Rotate or revoke keys without downtime?	Must Have	✅ Supported
Key Rotation & Revocation	Rotate or revoke keys without downtime?	Must Have	✅ Supported
Key Rotation & Revocation	Rotate or revoke keys without downtime?	Must Have	✅ Supported
Key Rotation & Revocation	Rotate or revoke keys without downtime?	Must Have	✅ Supported

MCP Gateway Evaluation Checklist

A practical guide used by platform & infra teams

Passerelle TrueFoundry MCP : architecture et fonctionnalités

La passerelle TrueFoundry AI Gateway est une plateforme prête à l'emploi qui centralise l'accès aux outils de développement d'IA à l'aide de MCP. Il fournit une Registre MCP, une authentification centralisée et un client MCP intégré qui orchestre la boucle d'agence entre les serveurs LLM et MCP.

Présentation de l'architecture

Les agents s'authentifient une seule fois auprès de la passerelle MCP, qui achemine leurs requêtes MCP vers les serveurs MCP enregistrés (Slack, GitHub, outils internes), le plan de contrôle gérant les jetons, les flux OAuth et les politiques d'accès.

Principales fonctionnalités de MCP Gateway

1. Registre MCP centralisé

Vous pouvez ajouter des serveurs MCP publics ainsi que vos serveurs MCP auto-hébergés qui sont enregistrés dans le plan de contrôle TrueFoundry. Le plan de contrôle gère le registre centralisé de tous les serveurs MCP et de leurs mécanismes d'authentification. Il gère les flux OAuth2 spécifiques à l'utilisateur, stocke et actualise en toute sécurité les jetons d'accès et garantit que les utilisateurs ne peuvent accéder qu'aux ressources pour lesquelles ils sont autorisés.

Cela résout le problème de la prolifération des informations d'identification : au lieu que chaque développeur gère ses propres clés d'API et jetons OAuth pour chaque outil, la passerelle les gère de manière centralisée. Les utilisateurs s'authentifient une seule fois auprès de la passerelle, qui gère toutes les authentifications en aval.

2. Contrôle d'accès précis

Lors de l'enregistrement d'un serveur MCP, vous pouvez spécifier la liste des utilisateurs/équipes qui y ont accès. Cela permet un contrôle d'accès précis au niveau de l'entreprise. Cela se fait via les groupes de serveurs MCP, dans lesquels vous pouvez définir des gestionnaires qui peuvent gérer les serveurs MCP et en donner l'accès à d'autres.

Par exemple, vous pourriez avoir :

• Un groupe de serveurs MCP « d'ingénierie » avec accès à GitHub, JIRA et aux outils CI/CD internes
• Un groupe de serveurs MCP « commerciaux » avec accès à Salesforce, HubSpot et aux outils de messagerie
• Un groupe de serveurs MCP « Finance » avec accès à des outils de comptabilité et de traitement des paiements

Chaque groupe ne voit que les outils qu'il est autorisé à utiliser, ce qui réduit la surface d'attaque et empêche toute utilisation abusive accidentelle.

3. Authentification unifiée

Tout utilisateur peut générer un jeton d'accès personnel (PAT) unique à l'aide duquel il peut accéder à tous les modèles et serveurs MCP auxquels il a accès. Vous pouvez également générer un jeton de compte virtuel (TVA) pour permettre à une application d'accéder à un ensemble spécifique de serveurs MCP.

La passerelle prend en charge plusieurs méthodes d'authentification :

• Clés d'API TrueFoundry : pour les utilisateurs possédant un compte TrueFoundry
• Jetons IDP : pour l'intégration avec votre fournisseur d'identité existant (Okta, Azure AD, etc.). *Cela permet à vos jetons de client final d'être également validés par la passerelle Truefoundry MCP.

La passerelle gère la complexité des flux OAuth2, notamment :

• Lancer des flux d'autorisation OAuth2
• Stockage et gestion sécurisée des jetons d'accès
• Actualisation automatique des jetons expirés
• Mappage des jetons utilisateur avec des jetons OAuth pour différents serveurs MCP

4. Serveurs MCP virtuels

L'une des fonctionnalités les plus puissantes est la possibilité de créer des serveurs MCP virtuels. Ils vous permettent de combiner des outils provenant de plusieurs serveurs MCP en un seul serveur MCP organisé auquel votre application peut se connecter.

Supposons, par exemple, que vous ayez intégré des serveurs MCP pour GitHub et Slack. Une équipe de votre entreprise travaille sur un agent qui nécessite l'accès à ces deux serveurs MCP, mais vous ne voulez pas exposer des outils dangereux tels que delete_project, delete_pr, etc.

Un serveur MCP virtuel vous permet de créer un nouveau serveur MCP en utilisant un sous-ensemble d'outils sécurisés des serveurs MCP GitHub et Slack. Ce nouveau serveur MCP virtuel est accessible comme n'importe quel autre serveur MCP distant et ne nécessite aucun déploiement. Il est entièrement géré par la passerelle.

Ceci est particulièrement utile pour :

• Création d'ensembles d'outils sécurisés et sélectionnés pour différentes équipes
• Combiner des outils provenant de sources multiples en groupes logiques
• Implémentation de l'accès au moindre privilège en exposant uniquement les outils nécessaires

5. Agent Playground

TrueFoundry AI Gateway offre un terrain de jeu où les utilisateurs peuvent expérimenter les instructions et les différents outils des serveurs MCP pour créer des agents. La passerelle est fournie avec des outils couramment utilisés tels que Websearch, WebScraping, l'extraction de documents et l'exécution de code.

La passerelle comprend un client MCP qui orchestre l'exécution des outils choisis par les fournisseurs LLM. La passerelle retransmet également la progression de la demande à l'interface utilisateur afin que l'utilisateur puisse voir les réponses LLM, les appels d'outils et les réponses des outils en temps réel.

Cela permet aux développeurs de :

• Testez différentes combinaisons d'outils
• Comportement de l'agent de débogage
• Comprenez comment les outils sont appelés
• Répéter rapidement sur les instructions des agents

6. Utiliser les serveurs MCP dans le code

La passerelle fournit des extraits de code indiquant comment vous pouvez commencer à utiliser les serveurs MCP dans votre code. Vous pouvez utiliser directement l'API MCP Gateway ou l'intégrer aux bibliothèques clientes MCP les plus courantes.

Voici un exemple d'utilisation de la passerelle depuis Python :

import asyncio
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

async def main():
    # Connect to the gateway using your Personal Access Token
    transport = StreamableHttpTransport(
        url="https://{controlPlaneURL}/mcp/{groupName}/{mcpServerName}/server",
        auth="Bearer your-tfy-token"
    )
    
    async with Client(transport=transport) as client:
        # List available tools
        tools = await client.list_tools()
        print(f"Available tools: {tools}")
        
        # Call a tool
        result = await client.call_tool(
            name="github_list_repositories",
            arguments={"org": "my-org"}
        )
        print(f"Result: {result}")

asyncio.run(main())

6. Authentification et autorisation à quatre niveaux

La passerelle met en œuvre un système complet d'authentification et d'autorisation à quatre niveaux :

Couche 1 : Authentification de la passerelle

Tout utilisateur/application a besoin d'un jeton pour communiquer avec la passerelle, qu'il s'agisse d'une clé API TrueFoundry ou de votre propre jeton IDP. TrueFoundry AI Gateway peut vérifier votre propre jeton IDP et extraire l'e-mail de l'utilisateur à partir du jeton en fonction des paramètres SSO.

Cela signifie que vous pouvez intégrer votre fournisseur d'identité existant (Okta, Azure AD, Google Workspace, etc.) sans que les utilisateurs aient à créer des comptes TrueFoundry distincts.

Niveau 2 : contrôle d'accès à la passerelle

Au niveau de la couche passerelle, vous pouvez définir quels utilisateurs ont accès à quels serveurs MCP. Cela permet un contrôle d'accès précis au niveau de l'entreprise. Cela se fait via les groupes de serveurs MCP, dans lesquels vous pouvez définir des gestionnaires qui peuvent gérer les serveurs MCP et en donner l'accès à d'autres.

Couche 3 : autorisation de service externe (authentification du serveur MCP)

Il s'agit de l'autorisation mise en œuvre par le serveur MCP pour accéder au service externe. TrueFoundry permet d'intégrer les serveurs MCP aux mécanismes d'authentification suivants :

• Aucune authentification : pour les API de démonstration ou les API publiques (non recommandé pour la production)
• Authentification statique basée sur les en-têtes : pour les serveurs MCP qui utilisent des clés API ou des jetons statiques (par exemple, Hugging Face)
• Authentification basée sur OAuth2 et DCR : pour les serveurs MCP qui prennent en charge OAuth2 (GitHub, Slack, Atlassian, etc.)

La passerelle gère la complexité des flux OAuth2 :

• Il stocke et gère les jetons OAuth pour différents serveurs MCP pour chaque utilisateur
• Il conserve une carte des jetons utilisateur et des jetons OAuth pour les différents serveurs MCP
• Il actualise automatiquement les jetons lorsqu'ils expirent
• Cela permet aux utilisateurs de parler à la passerelle avec un seul jeton sans avoir à gérer plusieurs jetons.

Couche 4 : en-têtes personnalisés

Vous pouvez transmettre n'importe quel en-tête personnalisé aux serveurs MCP à l'aide de la commande `en-têtes x-tfy-mcp`en-tête. Ceci est utile pour les jetons d'authentification, les métadonnées ou tout autre en-tête dont votre serveur MCP a besoin. Les en-têtes personnalisés remplacent toujours l'authentification par défaut configurée pour le serveur MCP.

Cas d'utilisation concrets

Cas d'utilisation 1 : équipes de développement d'entreprise

Une grande organisation d'ingénierie souhaite permettre à tous les développeurs d'accéder à GitHub, JIRA et Slack via des agents IA, mais avec des niveaux d'autorisation différents :

• Développeurs juniors : accès en lecture seule à GitHub (peut répertorier les dépôts, afficher les PR, mais ne peut pas fusionner)
• Développeurs seniors : accès complet à GitHub, accès en lecture seule à JIRA
• Responsables de l'ingénierie : accès complet à tous les outils

Avec TrueFoundry MCP Gateway :

1. Le service informatique crée des groupes de serveurs MCP pour chaque rôle
2. Chaque groupe est configuré avec des étendues OAuth appropriées
3. Les développeurs s'authentifient une fois auprès de la passerelle à l'aide de leur IDP d'entreprise
4. La passerelle gère tous les flux OAuth et la gestion des jetons.
5. Les développeurs utilisent un seul jeton d'accès personnel pour accéder à tous les outils autorisés

Cas d'utilisation 2 : plateforme SaaS à locataires multiples

Une plateforme SaaS souhaite permettre à ses clients de créer des agents d'IA qui interagissent avec leurs propres outils (par exemple, leur GitHub, leur Slack) :

1. Chaque client s'authentifie avec son propre jeton IDP
2. La passerelle associe les jetons des clients à leurs jetons OAuth pour leurs outils.
3. Les clients ne peuvent accéder qu'à leurs propres ressources (conformément aux champs d'application OAuth)
4. La plateforme offre une observabilité complète de l'utilisation des outils pour la facturation et le support.

Cas d'utilisation 3 : outils internes sécurisés

Une organisation souhaite exposer ses outils internes (bases de données, API) aux agents d'IA, mais avec des exigences de sécurité strictes :

1. Les serveurs MCP internes sont enregistrés avec une authentification basée sur les en-têtes
2. L'accès est limité à des équipes spécifiques via les groupes de serveurs MCP
3. Tous les appels à l'outil sont enregistrés et audités
4. Les serveurs MCP virtuels sont utilisés pour exposer uniquement des outils sûrs en lecture seule aux agents

Pour commencer

Pour démarrer avec TrueFoundry MCP Gateway, rien de plus simple :

1. Création d'un groupe de serveurs MCP : organisez vos serveurs MCP en groupes logiques
2. Ajouter des serveurs MCP : enregistrez des serveurs MCP publics ou auto-hébergés avec une authentification appropriée
3. Configurer le contrôle d'accès : définissez quels utilisateurs/équipes peuvent accéder à quels serveurs
4. Générer des jetons d'accès : les utilisateurs génèrent des jetons d'accès personnels pour se connecter à la passerelle
5. Commencez à créer : utilisez le terrain de jeu pour expérimenter ou intégrer directement dans votre code

La passerelle prend en charge à la fois l'authentification des utilisateurs (via les flux OAuth2) et l'authentification de machine à machine (via l'octroi des informations d'identification du client), ce qui la rend adaptée à la fois aux agents interactifs et aux flux de travail automatisés.

Tutoriel : Création d'un serveur MCP protégé par OAuth à partir de zéro et intégration à Truefoundry AI Gateway

Passons en revue à la création d'un serveur MCP complet avec authentification OAuth2 et à son intégration à TrueFoundry MCP Gateway. Nous allons créer un serveur MCP de calcul simple qui démontrera à la fois l'authentification des utilisateurs (via la passerelle) et l'authentification de machine à machine.

Reportez-vous à cette documentation pour le didacticiel complet - https://docs.truefoundry.com/docs/ai-gateway/mcp-server-oauth-okta

Le code complet de ce didacticiel est disponible dans notre [Référentiel GitHub]

Ce didacticiel présente les éléments suivants :

1. Création de serveurs MCP : utilisation de FastMCP pour créer des outils que les LLM peuvent appeler
2. Intégration d'OAuth2 : sécurisation des serveurs MCP avec OAuth2 à l'aide d'Okta
3. Authentification de machine à machine : activation de l'accès par programmation sans interaction de l'utilisateur
4. Intégration de passerelle : centralisation de l'accès au serveur MCP via TrueFoundry MCP Gateway
5. Authentification des utilisateurs : permettre aux utilisateurs finaux de s'authentifier via les flux OAuth gérés par la passerelle

La passerelle gère la complexité des flux OAuth, de la gestion des jetons et de l'actualisation, permettant aux utilisateurs d'accéder à tous leurs serveurs MCP autorisés avec un seul jeton d'accès personnel.

Pourquoi c'est important

À mesure que les agents d'IA passent des prototypes à la production, l'architecture d'intégration devient essentielle. Le problème d'intégration N×M n'est pas qu'une question théorique, c'est un véritable obstacle à la création de systèmes agentiques fiables, sécurisés et évolutifs.

Une passerelle MCP n'est plus un composant de niche. Il s'agit d'une infrastructure essentielle pour toute équipe qui crée des agents d'IA de niveau production. Il fournit le plan de contrôle essentiel pour gérer la sécurité, l'observabilité et la complexité opérationnelle des interactions agent-outil à grande échelle.

En centralisant l'accès aux outils via une passerelle, vous ne vous contentez pas de résoudre les problèmes actuels, vous posez également les bases évolutives de demain. Au fur et à mesure que votre écosystème d'agents se développe, la passerelle évolue avec lui, fournissant une sécurité, une observabilité et des modèles opérationnels cohérents pour toutes vos interactions agent-outil.

La passerelle TrueFoundry MCP permet de résoudre les problèmes d'intégration fondamentaux auxquels sont confrontés tous les agents d'IA chargés de la création d'équipes. En fournissant une plateforme centralisée, sécurisée et observable pour les interactions agent-outil, elle permet aux équipes de :

• Agissez plus vite : les développeurs se concentrent sur la logique des agents, et non sur les règles d'intégration
• Restez en sécurité : gestion centralisée des informations d'identification et contrôle d'accès précis
• Maintenez la visibilité : observabilité unifiée de toutes les interactions agent-outil
• Évoluez en toute confiance : une architecture qui évolue en fonction de vos besoins

Si vous créez des agents d'IA et que vous êtes aux prises avec le problème d'intégration N×M, nous aimerions avoir de vos nouvelles. La passerelle TrueFoundry MCP est disponible dès maintenant, et nous sommes impatients de voir ce que vous allez créer avec elle.

Pour plus d'informations, consultez notre documentation ou contactez-nous pour discuter de votre cas d'utilisation spécifique.

Que pensez-vous de MCP Gateways ? Avez-vous été confronté à des défis d'intégration similaires ? Nous aimerions connaître vos expériences dans les commentaires.