Votre Agent IA est Inutile Sans Ça

Pourquoi MCP est l'USB-C de l'Intelligence Artificielle.

Vous avez construit un agent IA. Peut-être est-il même performant. Les prompts sont précis, le modèle est rapide, et les réponses semblent naturelles.

Mais ensuite quelqu’un lui demande de vérifier un enregistrement client dans Salesforce. Ou de récupérer les derniers tickets Jira. Ou de chercher dans votre documentation interne.

Et votre magnifique agent ne peut tout simplement pas.

C’est le problème d’intégration que toute plateforme IA finit par rencontrer. Votre agent a besoin de mains. Il a besoin d’un accès à vos véritables systèmes métier. Sans cela, vous n’avez qu’un chatbot onéreux.

La solution traditionnelle ? Écrire un wrapper API personnalisé pour chaque service que vous voulez connecter. Lire leur documentation, gérer leur authentification, composer avec leurs limites de débit, prier pour qu’ils ne changent pas leurs endpoints le mois prochain. Puis recommencer pour le service suivant. Et encore un autre.

Le Model Context Protocol change complètement cette équation.

Ce que MCP Résout Concrètement

Pensez à l’USB avant l’USB-C. Vous aviez du Mini-USB, du Micro-USB, des connecteurs Apple propriétaires, et un tiroir rempli de câbles qui ne fonctionnaient qu’avec certains appareils. L’USB-C n’a pas simplement ajouté un nouveau connecteur — il a établi une norme faisant qu’un seul câble peut fonctionner avec n’importe quel appareil.

MCP fait la même chose pour les intégrations d’outils IA.

Au lieu d’écrire du code sur mesure pour connecter votre agent à Salesforce, HubSpot, GitHub, ou tout autre service, vous implémentez le protocole une fois (ou téléchargez un serveur pré-construit), et tout agent compatible MCP peut lui parler immédiatement.

Le protocole gère la couche de communication. Vous définissez simplement ce que vos outils font et quelles données ils nécessitent.

Configuration de Multiples Intégrations

Mastra dispose d’un support natif de MCP via son MCPClient. Vous pouvez connecter à la fois des outils locaux (s’exécutant comme processus enfants) et des services distants (tournant sur leur propre infrastructure).

Voici une configuration de production réaliste reliant Google Maps pour l’itinéraire, un service météo, et la recherche Wikipedia locale :

import { MCPClient } from '@mastra/mcp';

export const mcpClient = new MCPClient({
  servers: {
    // Outil local (Stdio)
    wikipedia: {
      command: 'npx',
      args: ['-y', 'wikipedia-mcp'],
    },
    // Cartes et Navigation (Distant/HTTP)
    googleMaps: {
      url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.GOOGLE_MAPS_API_KEY}`,
        },
      },
    },
    // Intégration du service météo
    weather: {
      url: new URL('https://mcp.weatherapi.dev/v1'),
      requestInit: {
        headers: {
          'X-API-Key': process.env.WEATHER_API_KEY!,
        },
      },
    },
  },
});

Le client gère le cycle de vie des connexions, le lancement des processus pour les outils locaux, et maintient les connexions HTTP pour les serveurs distants. Vous ne touchez ni aux sockets ni à stdio directement.

Connecter les Outils aux Agents

Une fois votre client MCP configuré, donner ces outils à un agent est simple :

import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { mcpClient } from '../mcp';

export const navigationDirectionsAgent = new Agent({
  id: 'navigation-directions-agent',
  name: 'Navigation & Directions Assistant',
  instructions: `You are a helpful navigation assistant that provides route planning and travel advice.
    - Always confirm the start and destination locations
    - Use Google Maps tools to find optimal routes
    - Check weather conditions along the route
    - Provide estimated travel times and suggest alternatives if weather is poor
    - Include relevant details like traffic, road conditions, and points of interest
    - Keep responses clear and actionable`,
  model: openai('gpt-5'),
  tools: await mcpClient.getTools(), // <--- C'est la ligne magique
});

Lorsqu’un utilisateur demande : “Quelle est la meilleure route de San Francisco à Lake Tahoe, et devrais-je m’inquiéter de la météo ?”

L’agent lit les définitions d’outils disponibles, réalise qu’il a accès aux outils d’itinéraire Google Maps et de prévisions météo, les exécute avec les bons paramètres, et répond avec un itinéraire optimal ainsi que les conditions météorologiques actuelles sur le parcours.

Vous n’avez pas écrit une seule ligne de code pour l’API Google Maps ou l’intégration du service météo.

Authentification par Utilisateur

Il y a une erreur de sécurité facile à commettre ici : coder les identifiants en dur.

Si vous mettez une seule clé API Google Maps dans vos variables d’environnement et que vous passez votre chemin, tous les utilisateurs partagent le même quota et les mêmes limites de débit. Plus important encore, si vous utilisez des services qui stockent les préférences utilisateur (comme les adresses enregistrées ou les itinéraires favoris), tout le monde verrait les mêmes données. Cela fonctionne pour les démos. C’est un risque en production.

Mastra gère cela en vous permettant de créer des clients MCP dynamiquement avec des identifiants spécifiques à chaque utilisateur :

async function handleUserRequest(userPrompt: string, userCredentials: UserCreds) {
  // Créer un client pour CET utilisateur spécifique
  const userMcp = new MCPClient({
    servers: {
      googleMaps: {
        url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
        requestInit: {
          headers: {
            // Clé API ou jeton spécifique à l'utilisateur
            Authorization: `Bearer ${userCredentials.mapsApiKey}`,
            'X-User-ID': userCredentials.userId,
          },
        },
      },
    },
  });

  const agent = mastra.getAgent('navigationDirectionsAgent');

  // Injecter les outils à l'exécution
  const response = await agent.generate(userPrompt, {
    toolsets: await userMcp.getToolsets(),
  });

  return response;
}

Chaque utilisateur obtient son propre ensemble d’outils isolé avec ses propres quotas API et préférences. Les adresses enregistrées de l’Utilisateur A restent privées, l’historique des itinéraires de l’Utilisateur B est séparé. C’est ainsi que fonctionnent les agents SaaS multi-locataires en pratique.

Construire des Outils Composites

Parfois, vous devez combiner plusieurs outils MCP en une seule opération. Peut-être voulez-vous planifier un itinéraire qui tienne compte à la fois du trafic en temps réel et des conditions météorologiques sur le parcours.

Vous pouvez encapsuler des outils MCP dans des définitions d’outils personnalisées :

export const smartRouteTool = createTool({
  id: 'smart-route-planner',
  description: 'Plans optimal route considering traffic and weather conditions',
  execute: async ({ context, mastra }) => {
    // Récupérer les outils bruts
    const tools = await mcpClient.getTools();

    // 1. Obtenir l'itinéraire de base depuis Google Maps
    const routeData = await tools.googleMaps_getDirections.execute({
      context: {
        origin: context.origin,
        destination: context.destination
      }
    });

    // 2. Vérifier la météo le long de l'itinéraire
    const weatherData = await tools.weather_getForecast.execute({
      context: { coordinates: routeData.waypoints }
    });

    // 3. Retourner l'itinéraire enrichi avec alertes météo
    return {
      ...routeData,
      weatherAlerts: weatherData.alerts,
      recommendation: weatherData.severe ? 'Envisagez de reporter le voyage' : 'Voyage sans risque'
    };
  },
});

Cela vous donne un contrôle fin sur la façon dont les outils interagissent, tout en tirant parti du protocole MCP pour le gros du travail.

Où Cela Nous Mène

Écrire des clients API personnalisés pour chaque service auquel votre agent IA doit se connecter n’a jamais été durable. Cela passe mal à l’échelle, casse souvent, et lie votre plateforme à des implémentations spécifiques.

MCP ne résout pas tous les défis d’intégration — l’authentification reste complexe, la limitation de débit compte toujours, et tous les services n’ont pas encore de serveur MCP. Mais il établit une fondation qui rend la construction de plateformes agentiques considérablement moins douloureuse.

Si vous architecturez un système IA qui doit interagir avec des services externes, comprendre MCP vaut probablement votre temps.

Ressources

Lire la Série

Routage LLM
Sécurité et Garde-fous
MCP et Intégrations d’Outils (Cet article)
Workflows et Mémoire