1 
2Le **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.
3 
4Depuis 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.
5 
6## Pourquoi MCP Existe
7 
8Avant 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.
9 
10Cela 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.
11 
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23 
24MCP 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 :
25 
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36 
37## Concepts Fondamentaux
38 
39MCP repose sur trois primitives fondamentales :
40 
41### 1. Outils (Tools)
42Les 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.
43 
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59 
60### 2. Ressources (Resources)
61Les 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.
62 
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70 
71### 3. Prompts
72Les 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.
73 
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83 
84## Architecture
85 
86MCP suit une architecture client-serveur :
87 
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93 
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100 
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103 
104- **Hôte** : L'application AI (Claude Desktop, Cursor, votre application personnalisée)
105- **Client** : Maintient une connexion 1:1 avec un serveur MCP
106- **Serveur** : Expose les outils, ressources et prompts au client
107- **Transport** : La communication se fait via JSON-RPC 2.0 sur stdio (local) ou Server-Sent Events (distant)
108 
109## Construire un Serveur MCP
110 
111Construisons un serveur MCP pratique qui interagit avec une liste de tâches stockée dans un fichier JSON.
112 
113### Installation
114 
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120 
121### Implémentation du Serveur
122 
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129 
130const TODO_FILE = "./todos.json";
131 
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136 
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140 
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145 
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159 
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173 
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188 
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201 
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206 
207### Configuration
208 
209Pour utiliser ce serveur avec Claude Desktop, ajoutez-le à votre configuration :
210 
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221 
222## Construire un Client MCP
223 
224Vous pouvez également construire un client personnalisé qui se connecte à n'importe quel serveur MCP :
225 
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229 
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234 
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237 
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241 
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249 
250## Serveurs MCP Populaires
251 
252L'écosystème MCP a connu une croissance rapide. Voici quelques-uns des serveurs les plus populaires :
253 
254| Serveur | Description | Cas d'utilisation |
255|---------|-------------|-------------------|
256| **GitHub** | Créer des issues, PRs, gérer des repos | Flux de travail de développement |
257| **Slack** | Envoyer des messages, gérer des canaux | Communication d'équipe |
258| **PostgreSQL** | Interroger et gérer des bases de données | Accès aux données |
259| **Filesystem** | Lire, écrire et rechercher des fichiers | Développement local |
260| **Puppeteer** | Automatisation du navigateur et scraping | Tests web |
261| **Sentry** | Surveillance des erreurs et débogage | Support en production |
262| **Supabase** | Base de données, auth, stockage | Opérations backend |
263 
264## MCP vs A2A (Agent-to-Agent)
265 
266Alors 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 :
267 
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274 
275- **MCP** : Comment un agent AI utilise les outils (intégration verticale)
276- **A2A** : Comment les agents AI collaborent entre eux (intégration horizontale)
277 
278## Bonnes Pratiques
279 
2801. **Gardez les serveurs focalisés** : Un serveur par domaine (serveur GitHub, serveur Slack, etc.). Ne construisez pas de serveurs monolithiques.
2812. **Validez les entrées avec Zod** : Validez toujours les entrées des outils avec des schémas appropriés.
2823. **Gérez les erreurs avec élégance** : Retournez des messages d'erreur significatifs, pas des stack traces.
2834. **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.
2845. **Ajoutez des descriptions appropriées** : De bonnes descriptions d'outils et de paramètres aident l'AI à comprendre quand et comment utiliser chaque outil.
2856. **Testez avec l'MCP Inspector** : Utilisez `npx @modelcontextprotocol/inspector` pour tester votre serveur de manière interactive.
286 
287## Pour Commencer
288 
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292 
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296 
297## Conclusion
298 
299MCP 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.
300 
301**Prochaines étapes :**
302- Explorez la [Spécification MCP](https://spec.modelcontextprotocol.io/)
303- Parcourez les [serveurs MCP existants](https://github.com/modelcontextprotocol/servers) pour vous inspirer
304- Construisez votre premier serveur avec le SDK TypeScript ou Python
305- Testez-le avec Claude Desktop ou l'MCP Inspector
306