MCP (Model Context Protocol) : Guide Complet pour les Développeurs

Qu'est-ce que le Model Context Protocol (MCP) ?

Le Model Context Protocol (MCP) est un protocole ouvert développé par Anthropic et publié en novembre 2024. Il définit une façon standardisée pour les applications d'IA de communiquer avec des sources de données externes, des outils et des services. En termes simples, MCP est à l'IA ce que le protocole HTTP est au web : un standard universel qui permet à différents systèmes de dialoguer efficacement.

Avant MCP, chaque intégration LLM était une solution sur mesure. Vous vouliez que Claude accède à votre base de données ? Il fallait écrire du code spécifique. Vous vouliez l'intégrer à votre CRM ? Encore du code spécifique. MCP résout ce problème en proposant une couche d'abstraction commune.

Pourquoi MCP Révolutionne le Développement IA

Le Problème qu'il Résout

Imaginons que vous construisiez un assistant IA pour votre entreprise. Vous avez besoin qu'il :

Lise et écrive dans votre base de données PostgreSQL
Accède à votre système de fichiers interne
Interroge votre API de gestion de projet (Jira, Linear)
Envoie des emails via Sendgrid
Consulte la documentation interne sur Notion

Sans MCP, vous écrivez une intégration personnalisée pour chacun de ces systèmes. Avec MCP, vous installez (ou créez) des serveurs MCP standardisés, et votre LLM peut interagir avec tous ces systèmes via un protocole unique.

Les Avantages Clés

Pour les développeurs d'applications :

Intégration simplifiée avec n'importe quel outil compatible MCP
Réutilisation des serveurs MCP existants (open source)
Débogage standardisé et logging unifié

Pour les créateurs d'outils :

Exposez vos outils une fois, compatibles avec tous les clients MCP
Standard ouvert — pas de dépendance à un fournisseur unique

Pour les entreprises :

Contrôle granulaire sur les permissions et accès
Isolation des contextes pour la sécurité
Architecture modulaire et maintenable

Architecture de MCP

MCP repose sur une architecture client-serveur avec trois composants principaux.

┌─────────────────────────────────────────────────────┐
│                   Application Hôte                   │
│  (Claude Desktop, Cursor, votre app personnalisée)   │
│                                                      │
│  ┌────────────────┐    ┌────────────────┐           │
│  │  Client MCP 1  │    │  Client MCP 2  │           │
│  └───────┬────────┘    └───────┬────────┘           │
└──────────┼─────────────────────┼────────────────────┘
           │ Protocole MCP       │ Protocole MCP
           │ (JSON-RPC 2.0)      │ (JSON-RPC 2.0)
           ▼                     ▼
┌──────────────────┐   ┌──────────────────────────────┐
│  Serveur MCP A   │   │       Serveur MCP B           │
│  (Base de        │   │  (Système de fichiers,        │
│   données)       │   │   API externe, etc.)          │
└──────────────────┘   └──────────────────────────────┘

Les Trois Primitives de MCP

MCP définit trois types de capacités qu'un serveur peut exposer :

1. Resources (Ressources) Les ressources sont des données que le serveur met à disposition du LLM. Elles sont similaires à des fichiers ou des endpoints GET — elles fournissent du contexte en lecture.

// Exemple de ressource MCP : expose le contenu d'une base de données
{
  uri: "database://customers/recent",
  name: "Clients récents",
  description: "Liste des 50 derniers clients inscrits",
  mimeType: "application/json"
}

2. Tools (Outils) Les outils permettent au LLM d'effectuer des actions. Ce sont des fonctions que le modèle peut appeler, similaires à des endpoints POST.

// Exemple d'outil MCP : envoi d'email
{
  name: "send_email",
  description: "Envoie un email à un destinataire",
  inputSchema: {
    type: "object",
    properties: {
      to: { type: "string", description: "Adresse email du destinataire" },
      subject: { type: "string", description: "Sujet de l'email" },
      body: { type: "string", description: "Corps de l'email en HTML ou texte" }
    },
    required: ["to", "subject", "body"]
  }
}

3. Prompts (Invites) Les prompts sont des modèles de conversation prédéfinis que l'application hôte peut proposer à l'utilisateur.

// Exemple de prompt MCP : analyse de code
{
  name: "code_review",
  description: "Effectue une revue de code complète",
  arguments: [
    {
      name: "language",
      description: "Langage de programmation",
      required: true
    }
  ]
}

Installation et Configuration

Prérequis

# Node.js 18+ requis
node --version

# Installer le SDK MCP TypeScript
npm install @modelcontextprotocol/sdk

Créer un Serveur MCP Simple

Voici un exemple complet d'un serveur MCP qui expose des outils de manipulation de fichiers JSON :

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import * as fs from "fs/promises";
import * as path from "path";

// Création du serveur MCP
const server = new Server(
  {
    name: "json-tools-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Déclaration des outils disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "read_json_file",
        description: "Lit et parse un fichier JSON depuis le système de fichiers",
        inputSchema: {
          type: "object",
          properties: {
            filePath: {
              type: "string",
              description: "Chemin absolu vers le fichier JSON",
            },
          },
          required: ["filePath"],
        },
      },
      {
        name: "write_json_file",
        description: "Écrit des données JSON dans un fichier",
        inputSchema: {
          type: "object",
          properties: {
            filePath: {
              type: "string",
              description: "Chemin où écrire le fichier JSON",
            },
            data: {
              type: "object",
              description: "Données à sérialiser en JSON",
            },
          },
          required: ["filePath", "data"],
        },
      },
      {
        name: "validate_json",
        description: "Valide une chaîne JSON et retourne les erreurs éventuelles",
        inputSchema: {
          type: "object",
          properties: {
            jsonString: {
              type: "string",
              description: "La chaîne JSON à valider",
            },
          },
          required: ["jsonString"],
        },
      },
    ],
  };
});

// Implémentation des outils
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  switch (name) {
    case "read_json_file": {
      const filePath = args?.filePath as string;
      const content = await fs.readFile(filePath, "utf-8");
      const parsed = JSON.parse(content);
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(parsed, null, 2),
          },
        ],
      };
    }

    case "write_json_file": {
      const filePath = args?.filePath as string;
      const data = args?.data;
      await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
      return {
        content: [
          {
            type: "text",
            text: `Fichier écrit avec succès : ${filePath}`,
          },
        ],
      };
    }

    case "validate_json": {
      const jsonString = args?.jsonString as string;
      try {
        JSON.parse(jsonString);
        return {
          content: [{ type: "text", text: "JSON valide ✓" }],
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `JSON invalide : ${(error as Error).message}`,
            },
          ],
          isError: true,
        };
      }
    }

    default:
      throw new Error(`Outil inconnu : ${name}`);
  }
});

// Démarrage du serveur
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Serveur MCP JSON Tools démarré");

Pour tester votre JSON, vous pouvez également utiliser notre formateur JSON en ligne avant de l'intégrer dans vos serveurs MCP.

Configurer Claude Desktop avec MCP

Une fois votre serveur créé, configurez Claude Desktop pour l'utiliser :

// ~/.config/Claude/claude_desktop_config.json (macOS)
// %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
  "mcpServers": {
    "json-tools": {
      "command": "node",
      "args": ["/chemin/vers/votre/serveur/build/index.js"],
      "env": {
        "NODE_ENV": "production"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/vous/Documents",
        "/Users/vous/Bureau"
      ]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost/mydb"
      }
    }
  }
}

Créer un Client MCP

Si vous intégrez MCP dans votre propre application (plutôt que d'utiliser Claude Desktop), voici comment créer un client :

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Connexion à un serveur MCP via stdio
const transport = new StdioClientTransport({
  command: "node",
  args: ["./build/server.js"],
});

const client = new Client(
  { name: "mon-application", version: "1.0.0" },
  { capabilities: {} }
);

await client.connect(transport);

// Lister les outils disponibles
const tools = await client.listTools();
console.log("Outils disponibles :", tools.tools.map(t => t.name));

// Appeler un outil
const result = await client.callTool({
  name: "validate_json",
  arguments: {
    jsonString: '{"nom": "Claude", "version": 4}',
  },
});

console.log("Résultat :", result.content);

Serveurs MCP Open Source Disponibles

La communauté a développé de nombreux serveurs MCP prêts à l'emploi :

Serveur	Description	Installation
`@modelcontextprotocol/server-filesystem`	Accès au système de fichiers	`npx -y @mcp/server-filesystem`
`@modelcontextprotocol/server-postgres`	Requêtes PostgreSQL	`npx -y @mcp/server-postgres`
`@modelcontextprotocol/server-github`	API GitHub	`npx -y @mcp/server-github`
`@modelcontextprotocol/server-slack`	Messages Slack	`npx -y @mcp/server-slack`
`@modelcontextprotocol/server-puppeteer`	Automatisation navigateur	`npx -y @mcp/server-puppeteer`
`@modelcontextprotocol/server-brave-search`	Recherche web	`npx -y @mcp/server-brave-search`

Cas d'Usage Avancés

1. Agent de Code Review Automatisé

Combinez un serveur MCP accédant à votre système de fichiers, votre API GitHub et votre base de données de règles de style pour créer un agent de revue de code :

// Workflow d'un agent de code review
// 1. Lecture du PR via l'outil GitHub MCP
const prFiles = await client.callTool({
  name: "get_pull_request_files",
  arguments: { prNumber: 1234, repo: "mon-org/mon-repo" }
});

// 2. Analyse du code avec le LLM en contexte
// (Le serveur MCP fournit le contexte au LLM)

// 3. Post du commentaire de review via l'outil GitHub
await client.callTool({
  name: "post_review_comment",
  arguments: {
    prNumber: 1234,
    body: "Code review générée par IA...",
    event: "COMMENT"
  }
});

2. Assistant de Base de Données en Langage Naturel

// L'utilisateur demande : "Combien de clients ont commandé ce mois-ci ?"
// Le LLM génère et exécute la requête SQL via MCP

const result = await client.callTool({
  name: "execute_query",
  arguments: {
    sql: "SELECT COUNT(*) FROM orders WHERE created_at >= DATE_TRUNC('month', NOW())",
    database: "production"
  }
});

Pour valider vos requêtes et leurs résultats JSON, utilisez notre formateur JSON. Pour travailler avec les patterns de données, notre testeur de regex peut vous aider.

3. Orchestrateur de Pipelines CI/CD

// Serveur MCP qui expose les opérations CI/CD
const deployResult = await client.callTool({
  name: "deploy_to_staging",
  arguments: {
    branch: "feature/nouvelle-fonctionnalite",
    environment: "staging",
    runTests: true
  }
});

Sécurité et Bonnes Pratiques

Contrôle des Permissions

MCP permet un contrôle granulaire sur ce que chaque serveur peut faire :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-filesystem",
        // Limitez explicitement les répertoires accessibles
        "/home/user/projets",
        "/home/user/documents"
        // Ne jamais exposer : /, /etc, /home/user/.ssh
      ]
    }
  }
}

Validation des Entrées

Toujours valider les arguments reçus dans vos outils MCP :

case "execute_query": {
  const sql = args?.sql as string;

  // Validation : rejeter les requêtes destructives
  const dangerousPatterns = /\b(DROP|TRUNCATE|DELETE FROM|UPDATE)\b/i;
  if (dangerousPatterns.test(sql)) {
    return {
      content: [{ type: "text", text: "Opérations destructives non autorisées" }],
      isError: true,
    };
  }

  // Utiliser des requêtes paramétrées
  const result = await db.query(sql);
  return { content: [{ type: "text", text: JSON.stringify(result) }] };
}

Audit et Logging

// Middleware de logging pour tous les appels d'outils
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const startTime = Date.now();
  const { name, arguments: args } = request.params;

  // Log de l'appel
  console.error(JSON.stringify({
    event: "tool_call",
    tool: name,
    timestamp: new Date().toISOString(),
    // Ne pas logger les données sensibles !
    args: sanitizeArgs(args)
  }));

  try {
    const result = await handleTool(name, args);
    console.error(JSON.stringify({
      event: "tool_success",
      tool: name,
      duration: Date.now() - startTime
    }));
    return result;
  } catch (error) {
    console.error(JSON.stringify({
      event: "tool_error",
      tool: name,
      error: (error as Error).message,
      duration: Date.now() - startTime
    }));
    throw error;
  }
});

MCP vs Alternatives

MCP vs Function Calling (OpenAI)

Aspect	MCP	Function Calling OpenAI
Standard	Ouvert, multi-modèles	Propriétaire OpenAI
Transport	stdio, HTTP, WebSocket	Intégré à l'API
Réutilisabilité	Serveurs réutilisables	Fonctions par requête
Découverte dynamique	Oui	Non
Multi-LLM	Oui	Non (OpenAI seulement)
Communauté	Croissante rapidement	Mature, vaste

MCP vs LangChain Tools

LangChain offre une abstraction d'outils similaire mais plus couplée au framework. MCP est plus léger, plus portable et agnostique au LLM utilisé. Pour les nouveaux projets en 2026, MCP est généralement préférable.

L'Écosystème MCP en 2026

Depuis son lancement en novembre 2024, MCP a été adopté par :

Cursor IDE : Intégration native pour accéder aux ressources du projet
Zed : Support MCP pour les agents de code
Sourcegraph Cody : Utilise MCP pour les intégrations entreprise
Continue : Extension VS Code avec support MCP
Replit : Intégration dans leur environnement cloud

Des centaines de serveurs MCP open source sont disponibles sur GitHub, couvrant des outils allant de l'intégration Jira à la manipulation de fichiers Excel en passant par les APIs de météo.

Démarrer avec MCP en 10 Minutes

# 1. Créer un nouveau projet
mkdir mon-serveur-mcp && cd mon-serveur-mcp
npm init -y

# 2. Installer les dépendances
npm install @modelcontextprotocol/sdk
npm install -D typescript @types/node tsx

# 3. Créer tsconfig.json
echo '{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "strict": true
  }
}' > tsconfig.json

# 4. Ajouter les scripts dans package.json
# "build": "tsc",
# "start": "node build/index.js"

# 5. Créer src/index.ts avec votre serveur
# (voir exemples ci-dessus)

# 6. Compiler et tester
npm run build
npm start

Ressources et Liens Utiles

Documentation officielle MCP : modelcontextprotocol.io
SDK TypeScript : github.com/modelcontextprotocol/typescript-sdk
SDK Python : github.com/modelcontextprotocol/python-sdk
Registre des serveurs : github.com/modelcontextprotocol/servers

Outils pour le développement MCP :

Formateur JSON — Validez les payloads JSON de vos serveurs MCP
Testeur de Regex — Construisez des patterns pour valider les entrées
Générateur de Hash — Sécurisez vos tokens d'API
Décodeur JWT — Déboguez l'authentification de vos serveurs

Conclusion

Le Model Context Protocol représente une avancée majeure dans la standardisation des intégrations IA. En adoptant MCP aujourd'hui, vous positionnez vos applications pour bénéficier d'un écosystème d'outils en croissance exponentielle, tout en maintenant une architecture modulaire et maintenable.

La courbe d'apprentissage est accessible pour tout développeur familier avec les API REST et TypeScript. Le temps investi pour maîtriser MCP est rapidement rentabilisé par la réutilisabilité des serveurs et la simplification des intégrations futures.

L'IA devient plus puissante à chaque itération, mais c'est l'infrastructure qui l'entoure — dont MCP est un composant clé — qui détermine ce qu'elle peut réellement accomplir dans vos applications.