Qu'est-ce que MCP ? Explication du Model Context Protocol

🔌 Qu'est-ce que MCP ?

The Model Context Protocol (MCP) est une norme ouverte publiée par Anthropic en décembre 2024 qui définit une interface universelle pour connecter les modèles d'IA à des outils externes, des sources de données et des services. Avant MCP, chaque intégration d'IA était une implémentation personnalisée et unique. MCP standardise la façon dont les clients AI communiquent avec des capacités externes — ainsi une intégration fonctionne avec n'importe quel système d'IA compatible.

MCP est un protocole client-serveur : Clients MCP sont des systèmes d'IA (comme Claude, Cursor, VS Code avec Copilot) qui veulent utiliser des capacités externes. Serveurs MCP sont des services qui exposent ces capacités (GitHub, une base de données, un système de fichiers, un navigateur web) via une API standardisée que tout client MCP peut consommer.

🔋 La métaphore USB-C

Avant USB-C, chaque appareil avait son propre connecteur propriétaire — un chargeur de téléphone ne fonctionnait pas avec un ordinateur portable, un câble d'affichage ne fonctionnait pas avec des périphériques de stockage. USB-C a résolu cela avec une seule norme universelle : un port, un câble, des appareils infinis.

Les intégrations d'IA avant MCP étaient le même chaos. Connecter Claude à GitHub nécessitait du code personnalisé. Connecter GPT-4 à la même API GitHub nécessitait un code personnalisé différent. Ajouter un nouvel outil signifiait reconstruire les intégrations depuis zéro pour chaque plateforme d'IA.

MCP est l'USB-C pour l'IA. Une norme :

• Construisez un serveur MCP une fois — n'importe quel client MCP peut l'utiliser
• Adoptez un nouveau modèle d'IA — vos serveurs MCP existants fonctionnent immédiatement
• L'écosystème des serveurs MCP grandit indépendamment du développement des modèles d'IA

⚙️ Comment MCP fonctionne

MCP utilise un protocole JSON-RPC 2.0 sur une couche de transport (stdio pour les serveurs locaux, HTTP/SSE pour les serveurs distants). La communication suit un cycle de vie d'initialisation, découverte des capacités, et gestion des requêtes.

Trois primitives principales

Le flux de communication

1. Initialiser : Le client se connecte au serveur, échange la version du protocole et les capacités
2. Découvrir : Le client demande la liste des outils, ressources et invites disponibles
3. Invoquer : Le modèle d'IA décide d'appeler un outil ; le client envoie la requête au serveur
4. Retourner : Le serveur exécute l'action et renvoie des résultats structurés au client
5. Continuer : Le modèle d'IA intègre les résultats et poursuit son raisonnement

Options de transport

🔄 MCP vs Function Calling

Function calling (utilisation d'outils) est une fonctionnalité intégrée à des API d'IA spécifiques — OpenAI, Anthropic, Google — qui vous permet de définir des fonctions personnalisées que le modèle peut invoquer. MCP est une couche par-dessus ou à côté de function calling qui standardise comment ces fonctions sont découvertes et connectées.

En pratique, les serveurs MCP utilisent souvent function calling en interne — MCP fournit la couche de découverte et de connexion, tandis que function calling gère l'invocation effective LLM→outil.

🏢 Qui prend en charge MCP

L'adoption de MCP a augmenté rapidement depuis son lancement en décembre 2024. En avril 2026, l'écosystème inclut :

Clients AI avec support MCP

• Claude (Anthropic) — support natif MCP dans Claude.ai et Claude Code
• Cursor — serveurs MCP pour assistance code-aware
• VS Code (GitHub Copilot) — intégration MCP en mode agent
• Windsurf (Codeium) — support de serveur MCP
• Continue.dev — assistant IDE open-source avec MCP

Serveurs MCP populaires

• Filesystem — lecture/écriture de fichiers locaux (officiel Anthropic)
• GitHub — dépôts, PRs, issues, recherche de code
• PostgreSQL / SQLite — interrogation de base de données et exploration du schéma
• Brave Search / Exa — recherche web sans clés API
• Puppeteer / Playwright — automatisation de navigateur
• Slack / Linear / Notion — intégrations d'outils de productivité

🚀 Premiers pas avec MCP

Option 1 : Utiliser des serveurs MCP existants (5 minutes)

La façon la plus rapide d'expérimenter MCP est d'utiliser Claude Desktop avec des serveurs préconstruits. Éditez votre configuration Claude Desktop à ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/Documents"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..." }
    }
  }
}

Option 2 : Construire un serveur MCP (30 minutes)

Des SDK officiels sont disponibles pour TypeScript, Python et Kotlin :

// TypeScript MCP server example
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({ name: "my-server", version: "1.0.0" });

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: {
      type: "object",
      properties: { city: { type: "string" } },
      required: ["city"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (request) => {
  const { city } = request.params.arguments;
  // ... fetch weather data
  return { content: [{ type: "text", text: `Weather in ${city}: sunny, 22°C` }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

🔐 Considérations de sécurité MCP

Le pouvoir de MCP — donner aux modèles d'IA l'accès à des outils, fichiers et services — introduit aussi des risques de sécurité que les développeurs doivent anticiper.

Pour approfondir les vulnérabilités de sécurité IA — y compris comment l'injection d'invite peut être utilisée via les résultats d'outils MCP — consultez notre guide : Prompt Injection Explained.