Votre Agent IA est Inutile Sans Ça

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

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

Mais ensuite, quelqu’un lui demande de vérifier un 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 chaque plateforme IA finit par rencontrer. Votre agent a besoin de mains. Il a besoin d’yeux sur vos systèmes métier réels. Sans eux, vous ne faites tourner qu’un chatbot coûteux.

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 taux, prier pour qu’ils ne changent pas leurs endpoints le mois prochain. Puis recommencer pour le service suivant. Et le suivant.

Le Model Context Protocol change entièrement cette équation.

Ce que MCP Résout Vraiment

Pensez à l’USB avant l’USB-C. Vous aviez le Mini-USB, le Micro-USB, les connecteurs propriétaires Apple, et un tiroir plein de câbles qui ne fonctionnaient qu’avec des appareils spécifiques. L’USB-C n’a pas juste ajouté un nouveau connecteur — il a établi un standard signifiant que n’importe quel câble pouvait 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 personnalisé 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 n’importe quel agent compatible MCP peut lui parler immédiatement.

Le protocole gère la couche de communication. Vous définissez simplement ce que font vos outils et les données dont ils ont besoin.

Configurer Plusieurs Intégrations

Mastra possède un support natif pour MCP via son MCPClient. Vous pouvez connecter à la fois des outils locaux (exécutés comme processus enfants) et des services distants (exécutés sur leur propre infrastructure).

Voici une configuration de production réaliste connectant Google Maps pour le routage, un service météo, et une recherche Wikipedia locale :

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

export const mcpClient = new MCPClient({
  servers: {
    // Local tool (Stdio)
    wikipedia: {
      command: 'npx',
      args: ['-y', 'wikipedia-mcp'],
    },
    // Maps & Navigation (Remote/HTTP)
    googleMaps: {
      url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.GOOGLE_MAPS_API_KEY}`,
        },
      },
    },
    // Weather Service Integration
    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, orchestre le lancement des processus pour les outils locaux, et maintient les connexions HTTP pour les serveurs distants. Vous ne touchez ni aux sockets ni au 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(), // <--- This is the magic line
});

Quand un utilisateur demande : “Quel est le meilleur itinéraire entre San Francisco et Lake Tahoe, et dois-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 de routage 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éo actuelles le long du trajet.

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

Authentification par Utilisateur

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

Si vous placez une seule clé API Google Maps dans vos variables d’environnement et appelez ça terminé, tous les utilisateurs partagent le même quota et les mêmes limites de taux. Plus important encore, si vous utilisez des services qui stockent les préférences utilisateur (comme les emplacements sauvegardés ou les itinéraires favoris), tout le monde verrait les mêmes données. Ça fonctionne bien pour les démos. C’est un risque en production.

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

async function handleUserRequest(userPrompt: string, userCredentials: UserCreds) {
  // Create a client for THIS specific user
  const userMcp = new MCPClient({
    servers: {
      googleMaps: {
        url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
        requestInit: {
          headers: {
            // User's specific API key or token
            Authorization: `Bearer ${userCredentials.mapsApiKey}`,
            'X-User-ID': userCredentials.userId,
          },
        },
      },
    },
  });

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

  // Inject tools at runtime
  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 et préférences API. Les emplacements sauvegardés de l’utilisateur A restent privés, l’historique d’itinéraires de l’utilisateur B est séparé. C’est ainsi que fonctionnent en pratique les agents SaaS multi-locataires.

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 prend en compte à la fois le trafic en temps réel et les conditions météo le long du trajet.

Vous pouvez encapsuler les 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 }) => {
    // Get the raw tools
    const tools = await mcpClient.getTools();

    // 1. Get base route from Google Maps
    const routeData = await tools.googleMaps_getDirections.execute({
      context: {
        origin: context.origin,
        destination: context.destination
      }
    });

    // 2. Check weather along the route
    const weatherData = await tools.weather_getForecast.execute({
      context: { coordinates: routeData.waypoints }
    });

    // 3. Return enhanced route with weather warnings
    return {
      ...routeData,
      weatherAlerts: weatherData.alerts,
      recommendation: weatherData.severe ? 'Consider delaying trip' : 'Safe to travel'
    };
  },
});

Cela vous donne un contrôle précis sur la façon dont les outils interagissent entre eux, 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 avec lequel votre agent IA doit communiquer n’a jamais été viable. Ça scale mal, ça casse souvent, et ça lie votre plateforme à des implémentations spécifiques.

MCP ne résout pas tous les problèmes d’intégration — l’authentification reste complexe, les limites de taux comptent toujours, et tous les services n’ont pas encore de serveur MCP. Mais il établit une fondation qui rend la construction de plateformes d’agents significativement moins douloureuse.

Si vous concevez 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