MCP (Model Context Protocol) : le standard Anthropic qui connecte les LLMs au monde réel

Publié le 25 mars 2026 — Par l'équipe DEV-AI · Lecture : 20 min

1. Pour les non-initiés : MCP, c'est quoi concrètement ?

Imaginez que vous avez un assistant IA ultra-compétent — Claude, GPT-4o, peu importe. Il sait raisonner, rédiger, analyser. Mais il est enfermé dans une boîte : il ne peut pas lire vos fichiers, interroger votre base de données, envoyer un message Slack ou vérifier vos emails. Pour chaque nouvelle capacité, votre développeur doit écrire une intégration sur mesure, spécifique à ce modèle, pour ce cas d'usage précis.

Le Model Context Protocol (MCP) casse ce mur. C'est un standard de communication — un langage commun — qui permet à n'importe quel LLM de parler à n'importe quelle source de données ou outil externe, sans réécrire les intégrations à chaque fois.

Lancé par Anthropic en novembre 2024, MCP est devenu open-source dès le départ et a été immédiatement adopté par la communauté. En mars 2026, l'écosystème compte plus de 500 serveurs MCP publics et des dizaines de milliers d'installations actives.

2. Le problème M×N que MCP résout

Avant MCP, le monde des intégrations LLM souffrait d'un problème combinatoire brutal : si vous avez M modèles (Claude, GPT, Gemini, Mistral…) et N outils (GitHub, Slack, Postgres, Google Drive, Jira…), vous aviez besoin de M×N intégrations différentes pour que tout fonctionne ensemble.

Concrètement : un développeur qui construit un serveur MCP pour interroger une base de données PostgreSQL le construit une fois. Ce serveur fonctionne ensuite avec Claude Desktop, Claude Code, Cursor, Windsurf, et tout autre client MCP — aujourd'hui et demain, quand de nouveaux clients émergeront.

3. Architecture MCP : hôte, client, serveur

L'architecture MCP repose sur trois rôles distincts qui collaborent via un protocole JSON-RPC 2.0 :

3.1 Le rôle de l'hôte

L'hôte est l'application que l'utilisateur final utilise directement. Il est responsable de :

• Démarrer, arrêter et surveiller les processus serveurs MCP
• Gérer les permissions accordées à chaque serveur
• Présenter les capabilities des serveurs au LLM via le contexte système
• Injecter les résultats des appels MCP dans la conversation

Claude Desktop est l'hôte de référence d'Anthropic. Claude Code (le CLI) est un second hôte officiel, orienté développeurs.

3.2 Le rôle du client

Le client MCP est une couche technique intégrée à l'hôte. Il maintient une connexion JSON-RPC avec chaque serveur MCP configuré, gère la négociation de capabilities lors du handshake initial, et traduit les demandes du LLM en appels MCP.

3.3 Le rôle du serveur

Le serveur MCP est le composant que vous développez pour exposer vos propres données et fonctions. C'est un programme indépendant — en Python, TypeScript, Go, Rust — qui :

• S'enregistre avec un nom et une version
• Déclare ses capabilities (tools, resources, prompts)
• Répond aux requêtes JSON-RPC du client
• Peut envoyer des notifications (ex : mise à jour d'une ressource)

3.4 Le handshake MCP

Lors de la connexion initiale, client et serveur échangent leurs capabilities via un processus d'initialisation en 3 étapes :

# 1. Client → Serveur : initialize
{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": { "roots": { "listChanged": true } },
    "clientInfo": { "name": "claude-desktop", "version": "1.4.0" }
  }
}

# 2. Serveur → Client : réponse avec ses capabilities
{
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "tools": { "listChanged": true },
      "resources": { "subscribe": true, "listChanged": true },
      "prompts": { "listChanged": false }
    },
    "serverInfo": { "name": "mon-serveur-mcp", "version": "1.0.0" }
  }
}

# 3. Client → Serveur : initialized (confirmation)
{ "method": "notifications/initialized" }

4. Les 3 primitives fondamentales : Resources, Tools, Prompts

MCP définit trois types de capabilities qu'un serveur peut exposer. Comprendre la distinction entre ces trois primitives est essentiel pour bien architecturer vos serveurs.

4.1 Resources — données en lecture

Les Resources représentent des données que le LLM peut consulter. Elles sont identifiées par une URI et peuvent être statiques ou dynamiques. Le LLM peut demander leur liste (resources/list) et lire leur contenu (resources/read).

Une resource peut être text (Markdown, JSON, code) ou blob (images, PDF, binaires). Le LLM ne peut que lire les resources — les modifications passent par les Tools.

4.2 Tools — actions exécutables

Les Tools sont des fonctions que le LLM peut appeler pour effectuer des actions sur le monde. Contrairement aux Resources (lecture), les Tools peuvent modifier des états, créer des fichiers, envoyer des messages, exécuter du code.

Chaque Tool est défini par :

• Un nom unique dans le serveur
• Une description en langage naturel (cruciale pour que le LLM sache quand l'utiliser)
• Un inputSchema en JSON Schema définissant les paramètres attendus
• Un handler — la fonction Python/TypeScript qui s'exécute

# Définition JSON d'un Tool MCP
{
  "name": "create_github_issue",
  "description": "Crée une nouvelle issue GitHub dans le dépôt spécifié",
  "inputSchema": {
    "type": "object",
    "properties": {
      "owner": { "type": "string", "description": "Propriétaire du dépôt (ex: anthropics)" },
      "repo": { "type": "string", "description": "Nom du dépôt (ex: claude-code)" },
      "title": { "type": "string", "description": "Titre de l'issue" },
      "body": { "type": "string", "description": "Corps de l'issue en Markdown" },
      "labels": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["owner", "repo", "title"]
  }
}

4.3 Prompts — templates réutilisables

Les Prompts sont des templates de conversation prédéfinis qu'un serveur MCP peut exposer. Ils permettent d'encapsuler des patterns d'interaction complexes et de les réutiliser facilement. Un Prompt peut accepter des arguments dynamiques et retourner une séquence de messages structurés.

# Exemple : prompt "code_review" exposé par un serveur Git
{
  "name": "code_review",
  "description": "Effectue une revue de code approfondie sur un diff Git",
  "arguments": [
    { "name": "diff", "description": "Le diff Git à analyser", "required": true },
    { "name": "language", "description": "Langage de programmation (python, ts...)", "required": false }
  ]
}
# Retourne des messages structurés avec contexte + instructions de revue

5. Transport : stdio vs HTTP/SSE — lequel choisir ?

MCP supporte deux modes de transport qui correspondent à deux cas d'usage distincts.

5.1 Configuration stdio dans Claude Desktop

// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/alice/projets"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxx" }
    },
    "mon-serveur-custom": {
      "command": "python",
      "args": ["/chemin/vers/mon_serveur.py"]
    }
  }
}

6. Implémenter un serveur MCP en Python

Le SDK Python officiel (mcp) propose deux niveaux d'abstraction : FastMCP (haut niveau, idéal pour démarrer) et Server (bas niveau, contrôle total). Commençons par FastMCP.

6.1 Installation

# Installation via pip ou uv (recommandé)
pip install mcp

# Avec uv (bien plus rapide)
uv add mcp

# Pour les serveurs HTTP avec dépendances supplémentaires
pip install mcp[cli] httpx pydantic

6.2 Serveur complet avec FastMCP

from mcp.server.fastmcp import FastMCP
import httpx, json, os
from datetime import datetime

# Création du serveur
mcp = FastMCP("serveur-meteo", version="1.0.0")

# ─── TOOL : action exécutable ────────────────────────────────────────
@mcp.tool()
async def get_weather(city: str, unit: str = "celsius") -> dict:
    """Récupère la météo actuelle pour une ville donnée.

    Args:
        city: Nom de la ville (ex: "Paris", "Tokyo")
        unit: Unité de température - "celsius" ou "fahrenheit"
    """
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"https://api.open-meteo.com/v1/forecast",
            params={"latitude": 48.85, "longitude": 2.35,
                    "current_weather": True}
        )
        data = resp.json()
    temp = data["current_weather"]["temperature"]
    if unit == "fahrenheit":
        temp = temp * 9/5 + 32
    return {"city": city, "temperature": temp,
            "unit": unit, "timestamp": datetime.now().isoformat()}

# ─── RESOURCE : données en lecture ───────────────────────────────────
@mcp.resource("config://app-settings")
def get_app_settings() -> str:
    """Retourne la configuration courante de l'application."""
    return json.dumps({
        "version": "2.1.0",
        "env": os.getenv("APP_ENV", "production"),
        "features": ["mcp", "agents", "rag"]
    }, indent=2)

# ─── RESOURCE dynamique (pattern URI) ────────────────────────────────
@mcp.resource("logs://{date}/errors")
def get_error_logs(date: str) -> str:
    """Retourne les logs d'erreurs pour une date donnée (YYYY-MM-DD)."""
    log_path = f"/var/log/app/{date}/errors.log"
    if not os.path.exists(log_path):
        return f"Aucun log pour le {date}"
    with open(log_path) as f:
        return f.read()

# ─── PROMPT : template réutilisable ──────────────────────────────────
@mcp.prompt()
def analyse_logs(date: str, niveau: str = "ERROR") -> str:
    """Template pour analyser les logs d'une journée."""
    return (f"Analyse les logs du {date} de niveau {niveau}. "
            "Identifie les patterns récurrents, les pics d'erreurs, "
            "et propose des corrections prioritaires.")

# ─── Lancement ────────────────────────────────────────────────────────
if __name__ == "__main__":
    mcp.run()  # stdio par défaut — compatible Claude Desktop

6.3 Serveur MCP bas niveau avec Server

Pour un contrôle total (gestion fine des erreurs, middleware, lifecycle hooks), utilisez la classe Server directement :

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent, CallToolResult
import asyncio

server = Server("mon-serveur-avance")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="execute_query",
            description="Exécute une requête SQL en lecture seule",
            inputSchema={
                "type": "object",
                "properties": {
                    "sql": {"type": "string", "description": "Requête SELECT"},
                    "limit": {"type": "integer", "default": 100}
                },
                "required": ["sql"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> CallToolResult:
    if name == "execute_query":
        sql = arguments["sql"].strip().upper()
        # Validation de sécurité : SELECT uniquement
        if not sql.startswith("SELECT"):
            return CallToolResult(
                content=[TextContent(text="Erreur : seules les requêtes SELECT sont autorisées")],
                isError=True
            )
        # ... exécution de la requête ...
        return CallToolResult(content=[TextContent(text="[résultat JSON]")])
    raise ValueError(f"Tool inconnu : {name}")

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

asyncio.run(main())

7. Implémenter un serveur MCP en TypeScript

Le SDK TypeScript est le SDK de référence (Anthropic l'utilise en premier). Il est idéal pour les intégrations Node.js, les serveurs avec accès à des APIs web, ou les équipes frontend.

7.1 Setup du projet

# Initialisation du projet
mkdir mon-serveur-mcp && cd mon-serveur-mcp
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

# tsconfig.json minimal
{
  "compilerOptions": {
    "target": "ES2022", "module": "Node16",
    "moduleResolution": "Node16", "outDir": "./dist",
    "strict": true
  }
}

7.2 Serveur complet en TypeScript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema, ListToolsRequestSchema,
  ListResourcesRequestSchema, ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// Schéma de validation Zod pour les arguments
const SearchSchema = z.object({
  query: z.string().describe("Terme à rechercher"),
  maxResults: z.number().int().min(1).max(50).default(10),
});

const server = new Server(
  { name: "serveur-recherche", version: "1.0.0" },
  { capabilities: { tools: {}, resources: {} } }
);

// ─── LIST TOOLS ────────────────────────────────────────────────────────
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "search_docs",
    description: "Recherche dans la documentation interne",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Terme à rechercher" },
        maxResults: { type: "number", default: 10 }
      },
      required: ["query"]
    }
  }]
}));

// ─── CALL TOOL ─────────────────────────────────────────────────────────
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name !== "search_docs") {
    throw new Error(`Tool inconnu : ${request.params.name}`);
  }
  const { query, maxResults } = SearchSchema.parse(request.params.arguments);
  // Simulation de recherche
  const results = [{ title: `Résultat pour "${query}"`, url: "https://docs.exemple.fr" }];
  return {
    content: [{ type: "text", text: JSON.stringify(results.slice(0, maxResults), null, 2) }]
  };
});

// ─── LIST RESOURCES ────────────────────────────────────────────────────
server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [
    { uri: "docs://changelog", name: "Changelog", mimeType: "text/markdown" },
    { uri: "docs://api-reference", name: "Référence API", mimeType: "text/markdown" }
  ]
}));

// ─── Démarrage ─────────────────────────────────────────────────────────
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Serveur MCP démarré");  // stderr seulement (stdout réservé MCP)

8. Les 20 serveurs MCP incontournables en 2026

L'écosystème MCP s'est développé à une vitesse remarquable. Voici les serveurs les plus utilisés, regroupés par catégorie :

8.1 Serveurs officiels Anthropic / MCP

8.2 Serveurs communautaires populaires

8.3 Serveurs spécialisés IA

9. Intégration dans Claude Desktop, Claude Code, Cursor, Windsurf

9.1 Claude Desktop

Claude Desktop est l'hôte MCP grand public d'Anthropic. La configuration se fait via un fichier JSON unique :

# macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
# Windows : %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/Users/alice/Documents", "/Users/alice/projets"],
      "env": {}
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost/mydb"
      }
    }
  }
}

Après modification du fichier, redémarrez Claude Desktop. Les outils MCP apparaissent automatiquement dans l'interface avec une icône dédiée. L'utilisateur peut voir et contrôler quels serveurs sont actifs depuis les paramètres.

9.2 Claude Code (CLI)

Claude Code supporte MCP nativement et propose en plus une commande de gestion des serveurs :

# Ajouter un serveur MCP à Claude Code
claude mcp add filesystem npx @modelcontextprotocol/server-filesystem /chemin

# Ajouter un serveur Python custom
claude mcp add mon-serveur python /chemin/vers/serveur.py

# Lister les serveurs configurés
claude mcp list

# Supprimer un serveur
claude mcp remove mon-serveur

# Vérifier le statut d'un serveur
claude mcp get filesystem

9.3 Cursor et Windsurf

Les éditeurs de code Cursor et Windsurf ont adopté MCP en 2025 pour permettre aux LLMs de leurs agents de code d'accéder aux outils de développement :

// Cursor : ~/.cursor/mcp.json
// Windsurf : ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxx" }
    }
  }
}
// La syntaxe est identique à Claude Desktop — portabilité totale

10. MCP vs function calling classique — quand choisir quoi

MCP et le function calling natif des APIs LLM ne sont pas en compétition directe — ils répondent à des besoins différents. Comprendre leurs différences permet de choisir la bonne approche.

11. Sécurité MCP : surface d'attaque et bonnes pratiques

MCP expose de nouveaux vecteurs d'attaque qui méritent une attention particulière. Un serveur MCP mal sécurisé peut donner à un attaquant (via injection de prompt) un accès à vos systèmes internes.

11.1 Les principaux risques

11.2 Bonnes pratiques de sécurité

# ✓ Principe du moindre privilège : restreignez les chemins filesystem
# Mauvais :
args: ["@modelcontextprotocol/server-filesystem", "/"]  # Accès root total !

# Bon :
args: ["@modelcontextprotocol/server-filesystem", "/home/user/projets/mon-projet"]

# ✓ Validation systématique des inputs dans vos serveurs custom
import re

def validate_sql(query: str) -> str:
    # Uniquement SELECT, pas de sous-requêtes dangereuses
    query = query.strip()
    if not re.match(r'^SELECT\s', query, re.IGNORECASE):
        raise ValueError("Seules les requêtes SELECT sont autorisées")
    if re.search(r'(DROP|DELETE|INSERT|UPDATE|EXEC|xp_)', query, re.IGNORECASE):
        raise ValueError("Requête non autorisée détectée")
    return query

# ✓ Authentification OAuth 2.1 pour les serveurs HTTP (spec MCP 2025-03)
from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def verify_mcp_token(token: str = Depends(oauth2_scheme)):
    if not await validate_token(token):
        raise HTTPException(status_code=401, detail="Token MCP invalide")
    return token

11.3 Checklist sécurité MCP

• Ne donnez jamais un accès filesystem à la racine — limitez aux répertoires nécessaires
• Créez un utilisateur système dédié avec permissions minimales pour vos serveurs MCP
• Auditez les packages npm/pip MCP avant installation — vérifiez les commits récents
• En entreprise, n'utilisez que des serveurs MCP internes ou des forks auditables
• Activez le logging de toutes les invocations de tools (auditabilité RGPD)
• Définissez un rate limit par session pour éviter les boucles infinies coûteuses
• Pour les serveurs HTTP/SSE : TLS obligatoire, OAuth 2.1 recommandé

12. MCP + A2A : l'infrastructure des agents en 2026

En 2026, deux protocoles ouverts structurent l'écosystème agent : MCP (Anthropic) et A2A — Agent-to-Agent Protocol (Google). Ils sont complémentaires, pas concurrents.

Un agent Claude peut donc utiliser MCP pour accéder à une base de données PostgreSQL, et simultanément utiliser A2A pour déléguer une sous-tâche à un agent spécialisé hébergé chez un partenaire — le tout sans qu'aucun des deux agents connaisse l'implémentation interne de l'autre.

FAQ — Questions fréquentes