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

Le Model Context Protocol (MCP) est un standard ouvert créé par Anthropic qui définit comment les modèles AI communiquent avec des outils externes, des sources de données et des services. Considérez-le comme l'"USB-C de l'AI" - un connecteur universel qui permet à n'importe quel agent AI de communiquer avec n'importe quel outil via une interface standardisée.

Depuis son lancement, MCP a dépassé les 97 millions de téléchargements mensuels du SDK et a été adopté par tous les principaux fournisseurs d'AI : Anthropic, OpenAI, Google, Microsoft et Amazon. Dans ce guide, nous explorerons tout ce que vous devez savoir pour construire avec MCP.

Pourquoi MCP Existe

Avant MCP, chaque application AI devait créer des intégrations personnalisées pour chaque outil qu'elle voulait utiliser. Vous voulez que votre AI lise des fichiers ? Écrivez du code personnalisé. Interroger une base de données ? Encore plus de code personnalisé. Publier sur Slack ? Encore une autre intégration.

Cela créait un problème N×M : N applications AI nécessitant chacune M intégrations personnalisées, entraînant des efforts dupliqués et des écosystèmes fragmentés.

MCP résout ce problème avec un protocole unique que n'importe quel client AI peut utiliser pour communiquer avec n'importe quel serveur MCP :

Concepts Fondamentaux

MCP repose sur trois primitives fondamentales :

1. Outils (Tools)

Les outils sont des fonctions que l'AI peut appeler. Ils représentent des actions comme "créer un fichier", "interroger une base de données" ou "envoyer un message". Chaque outil a un nom, une description et un JSON Schema pour ses paramètres.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. Ressources (Resources)

Les ressources sont des données que l'AI peut lire. Elles représentent des fichiers, des enregistrements de base de données, des réponses API ou toute autre source de données. Les ressources sont identifiées par des URIs.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. Prompts

Les prompts sont des modèles réutilisables qui aident à structurer les interactions. Ils peuvent inclure des paramètres dynamiques et sont utiles pour standardiser les flux de travail courants.

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

Architecture

MCP suit une architecture client-serveur :

• Hôte : L'application AI (Claude Desktop, Cursor, votre application personnalisée)
• Client : Maintient une connexion 1:1 avec un serveur MCP
• Serveur : Expose les outils, ressources et prompts au client
• Transport : La communication se fait via JSON-RPC 2.0 sur stdio (local) ou Server-Sent Events (distant)

Construire un Serveur MCP

Construisons un serveur MCP pratique qui interagit avec une liste de tâches stockée dans un fichier JSON.

Installation

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Implémentation du Serveur

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs";

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

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

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

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

Configuration

Pour utiliser ce serveur avec Claude Desktop, ajoutez-le à votre configuration :

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

Construire un Client MCP

Vous pouvez également construire un client personnalisé qui se connecte à n'importe quel serveur MCP :

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

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

Serveurs MCP Populaires

L'écosystème MCP a connu une croissance rapide. Voici quelques-uns des serveurs les plus populaires :

MCP vs A2A (Agent-to-Agent)

Alors que MCP gère la communication agent-outil, le protocole A2A (Agent-to-Agent) de Google gère la communication agent-agent. Ils sont complémentaires :

• MCP : Comment un agent AI utilise les outils (intégration verticale)
• A2A : Comment les agents AI collaborent entre eux (intégration horizontale)

Bonnes Pratiques

1. Gardez les serveurs focalisés : Un serveur par domaine (serveur GitHub, serveur Slack, etc.). Ne construisez pas de serveurs monolithiques.
2. Validez les entrées avec Zod : Validez toujours les entrées des outils avec des schémas appropriés.
3. Gérez les erreurs avec élégance : Retournez des messages d'erreur significatifs, pas des stack traces.
4. Utilisez les ressources pour les données en lecture seule : Si l'AI n'a besoin que de lire des données, exposez-les comme une ressource plutôt qu'un outil.
5. Ajoutez des descriptions appropriées : De bonnes descriptions d'outils et de paramètres aident l'AI à comprendre quand et comment utiliser chaque outil.
6. Testez avec l'MCP Inspector : Utilisez npx @modelcontextprotocol/inspector pour tester votre serveur de manière interactive.

Pour Commencer

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

Conclusion

MCP est devenu le standard de facto pour l'utilisation des outils AI en 2026. Que vous construisiez des agents AI personnalisés, étendiez Claude Code ou créiez des intégrations pour des plateformes existantes, comprendre MCP est essentiel. Le protocole est assez simple pour être appris en un après-midi mais suffisamment puissant pour construire des flux de travail AI de niveau production.

Prochaines étapes :

• Explorez la Spécification MCP
• Parcourez les serveurs MCP existants pour vous inspirer
• Construisez votre premier serveur avec le SDK TypeScript ou Python
• Testez-le avec Claude Desktop ou l'MCP Inspector