MCP : Comment Claude se Connecte à Tous Vos Outils

Le Problème : L'Intégration Fragmentée

Avant MCP, chaque application IA devait implémenter ses propres connecteurs vers chaque source de données, chaque API, chaque outil. Un chatbot d'entreprise connecté à 5 bases de données nécessitait 5 intégrations sur mesure. Un agent IA accédant à Google Calendar, Notion et Slack demandait 3 implémentations distinctes, avec 3 formats d'échange différents, 3 mécanismes d'authentification, et 3 schémas de données.

Cette approche N × M (N applications × M outils) générait une explosion combinatoire de code d'intégration, impossible à maintenir et à faire évoluer. Chaque nouvelle application devait réinventer la roue pour chaque outil qu'elle voulait supporter.

MCP : Le Port USB-C de l'IA

Le Model Context Protocol (MCP) est un standard ouvert créé par Anthropic pour connecter les applications IA aux systèmes externes de manière standardisée. L'analogie officielle est celle du port USB-C : tout comme USB-C fournit une interface universelle pour connecter des périphériques électroniques, MCP fournit une interface universelle pour connecter des applications IA à des outils, des données et des workflows.

Avec MCP, le problème N × M devient N + M : chaque application implémente le protocole MCP une seule fois (côté client), et chaque outil/service l'implémente une seule fois (côté serveur). Toute combinaison client-serveur fonctionne immédiatement, sans code supplémentaire.

“MCP fait pour les applications IA ce que USB-C a fait pour les périphériques électroniques : une interface universelle qui élimine le besoin de connecteurs propriétaires.”

L'adoption est massive : les clients compatibles incluent Claude (claude.ai), ChatGPT, Visual Studio Code (Copilot), Cursor, Claude Code, et de nombreux autres. Côté serveur, des centaines d'implémentations existent : filesystem, bases de données, Sentry, GitHub, Slack, Google Calendar, Notion, Blender, et bien d'autres.

Architecture : Host, Client, Server

MCP suit une architecture client-serveur avec trois rôles distincts. Comprendre ces rôles est essentiel pour configurer et construire des intégrations MCP.

┌──────────────────────────────────────────────────┐
│              MCP HOST (Application IA)            │
│                                                   │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  │
│  │ MCP Client │  │ MCP Client │  │ MCP Client │  │
│  │     1      │  │     2      │  │     3      │  │
│  └─────┬──────┘  └─────┬──────┘  └─────┬──────┘  │
└────────┼───────────────┼───────────────┼──────────┘
         │               │               │
   ┌─────▼─────┐   ┌─────▼─────┐   ┌─────▼─────┐
   │MCP Server │   │MCP Server │   │MCP Server │
   │ Filesystem│   │ Database  │   │  Sentry   │
   │  (local)  │   │  (local)  │   │ (distant) │
   └───────────┘   └───────────┘   └───────────┘

• MCP Host : L'application IA qui coordonne et gère un ou plusieurs MCP Clients. Exemples : Claude Desktop, VS Code, Claude Code.
• MCP Client : Un composant interne au Host qui maintient une connexion dédiée avec un MCP Server. Le Host crée un Client par serveur connecté.
• MCP Server : Un programme qui fournit du contexte (données, outils, prompts) aux MCP Clients. Il peut s'exécuter localement (transport STDIO) ou à distance (transport Streamable HTTP).

Le protocole repose sur JSON-RPC 2.0 et commence par un handshake de négociation de capacités. Le client déclare ce qu'il supporte, le serveur répond avec ses capacités, et la session est établie. Ce mécanisme garantit la compatibilité entre versions et permet une découverte dynamique des fonctionnalités.

Les Trois Primitives MCP

MCP expose trois types de fonctionnalités — les primitives — qui couvrent l'ensemble des besoins d'interaction entre IA et systèmes externes. Chacune a un modèle de contrôle différent, ce qui détermine qui décide de son utilisation.

Tools — Les fonctions que l'IA peut appeler

Les Tools sont des fonctions exécutables que le modèle de langage peut découvrir et invoquer automatiquement. Quand Claude détecte qu'il a besoin d'une information externe ou qu'il doit effectuer une action, il choisit l'outil approprié parmi ceux disponibles. Chaque outil est défini avec un nom, une description, et un schéma d'entrée JSON Schema. Les résultats peuvent contenir du texte, des images, de l'audio, ou des données structurées.

Resources — Les données de contexte

Les Resources permettent aux serveurs de partager des données fournissant du contexte : fichiers, schémas de bases de données, réponses API, documentation. Contrairement aux Tools, c'est l'application hôte qui décide quand et comment incorporer ces données. Les Resources supportent les templates d'URI paramétriques et les abonnements en temps réel pour être notifié des changements.

Prompts — Les workflows pré-configurés

Les Prompts fournissent des templates structurés pour les interactions : system prompts, exemples few-shot, instructions spécialisées. Typiquement exposés via des slash commands ou une palette de commandes, ils permettent de standardiser des workflows comme la revue de code ou l'analyse de sécurité.

Construire Votre Premier Serveur MCP

La construction d'un serveur MCP est étonnamment simple grâce aux SDK officiels Python et TypeScript. Voici comment créer un serveur météo complet en quelques minutes.

Exemple Python — Serveur météo avec FastMCP

1from mcp.server.fastmcp import FastMCP
2import httpx
3 
4# Initialisation du serveur MCP
5mcp = FastMCP("weather")
6 
7NWS_API_BASE = "https://api.weather.gov"
8 
9# Déclaration d'un outil — les type hints deviennent le schéma JSON
10@mcp.tool()
11async def get_alerts(state: str) -> str:
12    """Get weather alerts for a US state.
13 
14    Args:
15        state: Two-letter US state code (e.g. CA, NY)
16    """
17    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
18    async with httpx.AsyncClient() as client:
19        response = await client.get(url, timeout=30.0)
20        data = response.json()
21    if not data.get("features"):
22        return "No active alerts for this state."
23    alerts = [f["properties"]["headline"] for f in data["features"]]
24    return "\n".join(alerts)
25 
26@mcp.tool()
27async def get_forecast(latitude: float, longitude: float) -> str:
28    """Get weather forecast for a location.
29 
30    Args:
31        latitude: Latitude of the location
32        longitude: Longitude of the location
33    """
34    url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
35    async with httpx.AsyncClient() as client:
36        points = await client.get(url, timeout=30.0)
37        forecast_url = points.json()["properties"]["forecast"]
38        forecast = await client.get(forecast_url, timeout=30.0)
39    periods = forecast.json()["properties"]["periods"][:5]
40    return "\n".join(
41        f"{p['name']}: {p['temperature']}°{p['temperatureUnit']}"
42        for p in periods
43    )
44 
45# Lancement en transport STDIO
46if __name__ == "__main__":
47    mcp.run(transport="stdio")

Exemple TypeScript — Serveur météo avec Zod

1import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
3import { z } from "zod";
4 
5const server = new McpServer({
6  name: "weather",
7  version: "1.0.0",
8});
9 
10// Enregistrement d'un outil avec Zod pour le schéma
11server.registerTool(
12  "get_alerts",
13  {
14    description: "Get weather alerts for a state",
15    inputSchema: {
16      state: z.string().length(2).describe("Two-letter state code"),
17    },
18  },
19  async ({ state }) => {
20    const url = `https://api.weather.gov/alerts?area=${state}`;
21    const response = await fetch(url, {
22      headers: { "User-Agent": "weather-app/1.0" },
23    });
24    const data = await response.json();
25    const count = data.features?.length ?? 0;
26    return {
27      content: [{ type: "text", text: `Found ${count} alerts` }],
28    };
29  }
30);
31 
32// Lancement
33async function main() {
34  const transport = new StdioServerTransport();
35  await server.connect(transport);
36  console.error("Weather MCP Server running on stdio");
37}
38 
39main().catch(console.error);

Configurer MCP dans Claude Code et Claude Desktop

Une fois votre serveur MCP créé (ou un serveur communautaire installé), la connexion à Claude se fait en quelques secondes.

Dans Claude Code (terminal)

1# Ajouter un serveur MCP à Claude Code
2claude mcp add weather -- uv run weather_server.py
3 
4# Ajouter un serveur npm
5claude mcp add playwright -- npx @playwright/mcp@latest
6 
7# Lister les serveurs configurés
8claude mcp list
9 
10# Vérifier les coûts par serveur
11# Depuis une session interactive :
12#   /mcp

Dans Claude Desktop

1{
2  "mcpServers": {
3    "weather": {
4      "command": "uv",
5      "args": ["--directory", "/path/to/weather", "run", "weather_server.py"]
6    },
7    "filesystem": {
8      "command": "npx",
9      "args": ["@modelcontextprotocol/server-filesystem", "/home/user/documents"]
10    },
11    "github": {
12      "command": "npx",
13      "args": ["@modelcontextprotocol/server-github"],
14      "env": {
15        "GITHUB_TOKEN": "ghp_your_token_here"
16      }
17    }
18  }
19}

Serveurs MCP Populaires : L'Écosystème

L'écosystème MCP compte aujourd'hui des centaines de serveurs communautaires et officiels. Voici les plus populaires et les plus utiles pour les développeurs et les entreprises.

Transports : Local vs Distant

MCP supporte deux mécanismes de transport principaux, chacun adapté à un contexte d'utilisation différent.

Le transport STDIO est le choix par défaut pour la plupart des développeurs : le client lance le serveur MCP comme sous-processus, communique via stdin/stdout, et tout reste local. Le transport Streamable HTTP est destiné aux déploiements en équipe ou en production, avec support de sessions, d'authentification OAuth, et de Server-Sent Events pour les notifications en temps réel.

Sécurité : Les Principes Fondamentaux

MCP intègre la sécurité à chaque niveau du protocole. Voici les principes à respecter :

• Human-in-the-loop : Toujours prévoir un humain capable de refuser les opérations sensibles. Les clients doivent présenter les requêtes pour approbation avant exécution.
• Validation des entrées : Serveurs et clients doivent valider toutes les entrées. Les serveurs doivent implémenter des contrôles d'accès et du rate limiting.
• Prévention d'exfiltration : Les clients doivent afficher les entrées avant l'appel serveur pour prévenir l'exfiltration de données sensibles via des outils manipulés.
• Roots et frontières : Les Roots définissent précisément les répertoires et fichiers auxquels un serveur peut accéder, empêchant le path traversal et l'accès non autorisé.
• Transport HTTP sécurisé : Les serveurs doivent valider le header Origin (anti DNS rebinding), se lier à localhost pour les serveurs locaux, et utiliser OAuth pour l'authentification distante.

Cas d'Usage Concrets

MCP ne se limite pas à la théorie. Voici des exemples concrets de ce que vous pouvez réaliser en combinant plusieurs serveurs MCP :

• Développement full-stack assisté : Claude Code + serveur Figma + serveur PostgreSQL. Claude lit les maquettes Figma, génère le code React correspondant, crée les migrations SQL, et pousse le tout sur GitHub.
• Support client intelligent : Claude + serveur Sentry + serveur Slack + serveur base de données. Quand un bug est signalé sur Slack, Claude interroge Sentry pour les stack traces, vérifie la base de données pour comprendre l'impact, et propose un correctif.
• Assistant administratif IA : Claude + serveur Google Calendar + serveur Drive + serveur Gmail. L'assistant planifie des réunions, prépare des documents de briefing à partir de fichiers Drive, et envoie les invitations par email.
• Pipeline de données automatisé : Claude + serveur SQL + serveur filesystem + serveur Notion. Extraction de données depuis PostgreSQL, génération de rapports formatés, et mise à jour automatique d'un tableau de bord Notion.

Questions Fréquentes

Connectez Claude à Votre Écosystème

MCP transforme Claude d'un modèle de langage isolé en un agent véritablement connecté à votre écosystème d'outils. Que vous souhaitiez connecter vos bases de données, vos outils de gestion de projet, ou créer des intégrations sur mesure, le Model Context Protocol vous donne la clé.

Notre formation MCP vous guide de la théorie à la pratique : comprendre l'architecture, configurer les serveurs populaires, construire vos propres serveurs Python et TypeScript, et déployer en production avec les bonnes pratiques de sécurité.