MCP servers : tutoriel développeur 2026 (Model Context Protocol)

Lecture : 14 minutes · Niveau : développeur intermédiaire · Mise à jour : avril 2026

Le Model Context Protocol (MCP) est devenu en moins de 18 mois le standard de facto pour connecter les LLMs à des outils externes. Introduit par Anthropic en novembre 2024, MCP est désormais supporté par Claude Code, Cursor, GitHub Copilot Agent, Continue, Cody, et des centaines d’autres clients en 2026. La spec officielle (modelcontextprotocol.io, version courante référencée 2025-11-25) définit une couche d’intégration unique : on écrit un serveur MCP une fois, il est utilisable depuis tous les clients compatibles. Ce tutoriel pratique couvre la création de serveurs MCP en Python et TypeScript, la configuration côté Claude Code et Cursor, et trois cas d’usage concrets pour développeur freelance ou PME ouest-africaine.

Pour le contexte stratégique global, voir le pillar AI coding développeur. Pour Claude Code, voir Claude Code tutoriel.

Sommaire

Comprendre MCP en 5 minutes
Architecture MCP : client, serveur, primitives
Installer et utiliser des serveurs MCP existants
Créer un serveur MCP en Python
Créer un serveur MCP en TypeScript
Connexion à Claude Code et Cursor
Cas d’usage pratiques
Sécurité et bonnes pratiques
Pièges fréquents
FAQ

1. Comprendre MCP en 5 minutes

Le problème. Avant MCP, chaque LLM/agent réinventait son intégration aux outils externes. Brancher Claude à PostgreSQL différait de brancher GPT-4 à PostgreSQL, qui différait de brancher Gemini à PostgreSQL. Multiplié par N outils × M LLMs = chaos.

La solution MCP. Standard ouvert qui définit un protocole de communication LLM ↔ outils. Trois acteurs :
– Client MCP : l’application IA (Claude Code, Cursor, etc.).
– Serveur MCP : la couche qui expose un outil/donnée.
– Protocole : JSON-RPC 2.0 sur stdio ou HTTP/SSE.

Trois primitives.
– Tools : actions exécutables (ex. query_database, send_email, create_jira_ticket).
– Resources : données accessibles (ex. fichiers, schémas DB, docs).
– Prompts : templates paramétrables.

Adoption 2026.
– Tous outils sérieux (Claude Code, Cursor, Copilot Agent, Continue, Cody, Aider, Zed) supportent MCP.
– Milliers de serveurs disponibles (officiels + communauté).
– SDKs : Python, TypeScript, C#, Java, Rust, Go.

2. Architecture MCP : client, serveur, primitives

Flow type.
1. Le client (Claude Code) démarre un ou plusieurs serveurs MCP au lancement.
2. Chaque serveur déclare ses tools/resources/prompts.
3. L’agent voit les capacités disponibles et les utilise quand pertinent.
4. À chaque appel : JSON-RPC entre client et serveur.

Transport.
– stdio : serveur exécuté localement, communication par stdin/stdout. Le plus simple.
– HTTP/SSE : serveur distant, communication par HTTP avec Server-Sent Events. Pour serveurs partagés ou cloud.

Configuration côté Claude Code. Fichier .mcp.json à la racine du projet ou ~/.claude/mcp.json global :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    }
  }
}

Configuration côté Cursor. Settings → MCP → ajouter serveur similaire au format Claude Code (Cursor compatible MCP standard).

3. Installer et utiliser des serveurs MCP existants

Serveurs communautaires populaires.
– mcp-server-notion : Notion.
– mcp-server-linear : Linear tickets.
– mcp-server-jira : JIRA.
– mcp-server-stripe : paiements Stripe.
– mcp-server-supabase : Supabase DB + auth.
– mcp-server-vercel : déploiements Vercel.
– mcp-server-cloudflare : DNS, R2, Workers.

Installer et tester un serveur.

# Filesystem (officiel)
# Pas d'installation, npx l'invoque à la volée
# Config dans .mcp.json suffit

# Test en mode standalone
npx -y @modelcontextprotocol/server-filesystem /tmp
# Doit afficher la liste des tools disponibles

Vérifier la connexion dans Claude Code.

> Quels outils MCP sont disponibles dans cette session ?

Claude Code répond en listant tools, resources, prompts par serveur.

4. Créer un serveur MCP en Python

Cas pratique : serveur MCP pour interroger une API REST custom.

Imaginons une PME ouest-africaine ayant une API interne (CRM, ERP, suivi commandes) qu’elle veut exposer à Claude Code pour automatiser des workflows.

Étape 1 : prérequis.

pip install mcp httpx

Étape 2 : structure projet.

mon-mcp-crm/
├── pyproject.toml
└── server.py

Étape 3 : code server.py.

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

API_BASE = "https://api.maboutique.sn/v1"
API_KEY = "VOTRE_CLE_API"  # via env var en prod

server = Server("crm-server")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_customer",
            description="Récupère les infos d'un client par ID ou email",
            inputSchema={
                "type": "object",
                "properties": {
                    "identifier": {"type": "string", "description": "ID ou email"}
                },
                "required": ["identifier"]
            }
        ),
        Tool(
            name="list_recent_orders",
            description="Liste les N dernières commandes",
            inputSchema={
                "type": "object",
                "properties": {
                    "limit": {"type": "integer", "default": 10}
                }
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    headers = {"Authorization": f"Bearer {API_KEY}"}
    async with httpx.AsyncClient() as client:
        if name == "get_customer":
            resp = await client.get(
                f"{API_BASE}/customers",
                params={"q": arguments["identifier"]},
                headers=headers
            )
            return [TextContent(type="text", text=resp.text)]
        elif name == "list_recent_orders":
            limit = arguments.get("limit", 10)
            resp = await client.get(
                f"{API_BASE}/orders",
                params={"limit": limit, "sort": "-created_at"},
                headers=headers
            )
            return [TextContent(type="text", text=resp.text)]
        else:
            return [TextContent(type="text", text=f"Unknown tool: {name}")]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

Étape 4 : configurer dans Claude Code (.mcp.json).

{
  "mcpServers": {
    "crm": {
      "command": "python",
      "args": ["/chemin/vers/mon-mcp-crm/server.py"],
      "env": {
        "API_KEY": "ma-cle-secrete"
      }
    }
  }
}

Étape 5 : tester.

claude
> Montre-moi les 5 dernières commandes

Claude Code appelle list_recent_orders avec limit=5, reçoit la réponse, la formate.

Étape 6 : améliorer.
– Ajouter update_customer, create_order, etc.
– Utiliser variables d’environnement au lieu de hardcoder l’API key.
– Ajouter logging pour audit.
– Gérer erreurs HTTP proprement.

5. Créer un serveur MCP en TypeScript

Cas pratique : serveur qui interroge une base PostgreSQL avec requêtes custom autorisées.

Étape 1 : prérequis.

mkdir mon-mcp-db && cd mon-mcp-db
npm init -y
npm install @modelcontextprotocol/sdk pg
npm install -D typescript @types/pg @types/node

Étape 2 : code server.ts.

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 { Client } from "pg";

const DB_URL = process.env.DATABASE_URL!;

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

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "count_table",
      description: "Compte les lignes d'une table autorisée",
      inputSchema: {
        type: "object",
        properties: {
          table: { type: "string", enum: ["customers", "orders", "products"] }
        },
        required: ["table"]
      }
    },
    {
      name: "find_customer",
      description: "Cherche un client par email",
      inputSchema: {
        type: "object",
        properties: { email: { type: "string" } },
        required: ["email"]
      }
    }
  ]
}));

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  const client = new Client({ connectionString: DB_URL });
  await client.connect();
  try {
    if (req.params.name === "count_table") {
      const table = (req.params.arguments as any).table;
      const res = await client.query(`SELECT COUNT(*) FROM ${table}`);
      return { content: [{ type: "text", text: JSON.stringify(res.rows[0]) }] };
    }
    if (req.params.name === "find_customer") {
      const email = (req.params.arguments as any).email;
      const res = await client.query(
        "SELECT * FROM customers WHERE email = $1",
        [email]
      );
      return { content: [{ type: "text", text: JSON.stringify(res.rows) }] };
    }
    return { content: [{ type: "text", text: "Unknown tool" }] };
  } finally {
    await client.end();
  }
});

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

Étape 3 : compiler.

npx tsc

Étape 4 : configurer dans Claude Code.

{
  "mcpServers": {
    "db": {
      "command": "node",
      "args": ["/chemin/vers/mon-mcp-db/dist/server.js"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/mydb"
      }
    }
  }
}

Pourquoi un serveur custom plutôt que le serveur postgres officiel ? Contrôle granulaire : on définit quelles tables et requêtes sont autorisées, pas SQL injection possible, pas de leak schéma complet.

6. Connexion à Claude Code et Cursor

Claude Code.
– .mcp.json projet ou ~/.claude/mcp.json global.
– Validation au démarrage : Claude Code log les serveurs chargés.
– Commande /mcp pour status temps réel.
– Hot reload : redémarrer Claude Code après modification config.

Cursor.
– Settings → MCP → Add Server.
– Format JSON identique à Claude Code.
– Le panel Composer voit les outils MCP et les utilise dans ses tâches.

GitHub Copilot Agent.
– Support MCP en 2026 via configuration spécifique workspace.
– Documentation Microsoft / GitHub à consulter pour version courante.

Multi-clients. Un même serveur MCP fonctionne pour tous les clients : pas besoin d’écrire des intégrations spécifiques par outil. C’est la valeur principale du standard.

7. Cas d’usage pratiques

Cas 1 — PME e-commerce ouest-africaine.
– Serveur MCP custom : API CRM, base produits, base commandes.
– Workflow Claude Code : « Liste les 10 produits les plus vendus ce mois », « Identifie clients VIP inactifs depuis 30 jours », « Génère rapport mensuel ventes ».
– ROI : automation rapports + analyses ad-hoc sans dev custom à chaque demande.

Cas 2 — Freelance multi-projets.
– Serveurs MCP officiels : github, filesystem, postgres, slack.
– Workflow : « Crée issue GitHub pour bug X », « Notifie sur Slack quand build OK », « Liste branches stale sur tous les repos clients ».
– ROI : moins de switch context, automation tâches admin.

Cas 3 — Agence dev / PME tech.
– Serveur MCP custom : interrogation base DevOps interne (CI status, déploiements, métriques).
– Workflow : « État de tous les déploiements production aujourd’hui », « Quelles applis ont eu erreurs >5xx dans la dernière heure ».
– ROI : DevOps assist, troubleshooting accéléré.

Cas 4 — Recherche / analyse.
– Serveurs MCP : brave-search + filesystem + memory.
– Workflow : recherche web ciblée → extraction → synthèse → archivage local.
– ROI : compétitive intelligence, veille tech.

Cas 5 — Documentation auto.
– Serveurs MCP : github (issues, PR) + custom (wiki interne).
– Workflow : « Génère le changelog de la version 2.3 à partir des PR mergées », « Crée page Notion pour spec feature X ».
– ROI : doc à jour sans effort manuel.

8. Sécurité et bonnes pratiques

Audit du code. Tout serveur MCP a accès aux ressources qu’il définit. Avant d’autoriser un serveur communautaire :
– Lire le code source (s’il est ouvert).
– Vérifier les permissions demandées.
– Tester en environnement isolé.

Permissions minimales. Chaque serveur ne doit avoir que les permissions strictement nécessaires. Exemple : un serveur de lecture DB ne doit pas avoir accès en écriture.

Variables d’environnement. Secrets (API keys, DB credentials) toujours via env vars, jamais en dur. .env + .gitignore pour ne pas committer.

Rate limiting. Serveurs MCP exposant des APIs externes doivent gérer rate limits (sinon usage Claude peut saturer l’API).

Logging. Logger les appels (qui, quoi, quand) pour audit. Permet de détecter abus ou fuites.

Sandbox. Serveurs lourds (browser automation, code execution) à exécuter dans containers isolés.

Mise à jour. Suivre les release des serveurs officiels et communautaires. Updates fréquents en 2026.

Sécurité MCP en production.
– HTTPS pour transports HTTP/SSE.
– Authentification mutuelle si serveur partagé.
– Limitation IP / VPN si serveur interne.

9. Pièges fréquents

Trop de serveurs activés. Chaque serveur consomme du contexte (descriptions tools). 10+ serveurs = surcharge inutile. Activer ceux nécessaires par projet.

Serveurs avec descriptions floues. L’agent doit comprendre quand utiliser quel tool. Descriptions précises = meilleur usage.

Pas de gestion d’erreurs. Serveur qui crash = session bloquée. Try/catch systématique, retours d’erreur structurés.

Hardcoder secrets. API keys dans .mcp.json versionné = leak garanti. Toujours env vars.

Confusion stdio vs HTTP. stdio = local, simple, recommandé débutant. HTTP/SSE = remote, plus complexe, pour serveurs partagés.

Ignorer rate limits APIs externes. Si serveur appelle GitHub API à chaque tool call, on saturera vite. Implémenter caching et rate limiting côté serveur.

Pas de tests serveurs custom. Tests unitaires sur tools, mocks des APIs externes. Sinon régressions silencieuses.

Versions SDK obsolètes. Spec MCP évolue. Mettre à jour SDK MCP (Python, TypeScript) trimestriellement.

FAQ

Faut-il MCP pour utiliser Claude Code ou Cursor ?

Non, pas obligatoire. Mais MCP démultiplie l’utilité de l’agent en lui donnant accès à votre stack (DB, GitHub, APIs). Démarrer avec 2-3 serveurs (filesystem, github, base de données) suffit à constater la valeur.

Quelle différence entre MCP et plugin ?

Plugin = bundle qui peut inclure slash commands, sub-agents, hooks ET serveurs MCP. MCP = couche d’intégration outils externes. MCP peut exister sans plugin (config .mcp.json directe), un plugin peut exister sans MCP (juste commands et hooks).

Mon serveur MCP custom peut-il être partagé entre projets ?

Oui : déploiement local (npx, npm install -g) ou config globale ~/.claude/mcp.json. Ou hébergement HTTP/SSE pour usage cloud par plusieurs clients.

MCP fonctionne-t-il avec d’autres LLMs que Claude ?

Oui. MCP est ouvert. Implémentations existent pour OpenAI, Gemini, Llama, etc. Les clients principaux (Claude Code, Cursor, Copilot, Continue) supportent MCP.

Combien coûte un serveur MCP custom à développer ?

2-8 heures de dev pour un serveur simple (3-5 tools, intégration API REST). 1-3 jours pour un serveur complexe (DB, auth, transactions). Coût marginal vu le ROI agent.

Y a-t-il des risques sécurité majeurs avec MCP ?

Comme tout outil donnant accès à vos systèmes, oui : SQL injection si serveur DB mal écrit, leak credentials si secrets hardcodés, exécution arbitraire si serveur eval. Suivre bonnes pratiques sécurité standard.

MCP supporte-t-il le streaming ?

Oui, via Server-Sent Events (SSE) en transport HTTP. Permet retour progressif (utile pour requêtes longues, génération de rapports). stdio ne supporte que requête-réponse simple.

Existe-t-il un marketplace MCP officiel ?

En 2026, plusieurs registries communautaires (awesome-mcp-servers sur GitHub, modelcontextprotocol.io listings). Anthropic travaille sur un marketplace officiel intégré à Claude Code et Claude Desktop.

Articles liés (cluster AI coding)

Voir aussi : TypeScript JavaScript moderne guide, Python pour PME guide complet, Node.js backend guide complet.

Article mis à jour le 26 avril 2026. Pour signaler une erreur ou suggérer une amélioration, écrivez-nous.