Le Model Context Protocol (MCP) est une norme ouverte qui permet à des modèles comme Claude d’Anthropic et à des outils pour développeurs comme Claude Code d’appeler des outils externes, des sources de données et des prompts de manière sûre et standardisée.
Ce guide vous expliquera comment créer votre propre serveur MCP à partir de zéro, afin de permettre à Claude Code d’accéder à des fonctionnalités personnalisées et d’étendre largement ses capacités au-delà de ses fonctions intégrées.
Qu’est-ce que le Model Context Protocol (MCP) ?
MCP (Model Context Protocol) est une spécification ouverte conçue pour standardiser la façon dont les clients de modèles de langage (comme Claude, Claude Code ou d’autres interfaces LLM) se connectent à des serveurs d’outils et des sources de données. Considérez MCP comme un « port USB‑C pour les LLM » : il définit un schéma de transport/JSON‑RPC et une manière commune pour les serveurs de publier trois types de capacités :
- Ressources — des données de type fichier ou document que le client peut lire (p. ex., une ligne de base de données, un fichier texte, une charge utile JSON).
- Outils — des fonctions appelables que le modèle peut demander à l’hôte d’exécuter (avec l’approbation de l’utilisateur).
- Prompts — des modèles de prompt ou des workflows réutilisables que le modèle/le client peut invoquer.
MCP prend en charge plusieurs transports (stdio, HTTP, SSE) et fournit un schéma, des SDK et des serveurs d’exemple pour éviter d’avoir à inventer vous‑même le format d’échange. Le protocole est maintenu publiquement (spécification + SDK) et dispose de tutoriels et d’une galerie de serveurs d’exemple pour accélérer l’adoption.
Comment MCP est-il architecturé ?
L’architecture de MCP est volontairement simple et modulaire : les éléments de base sont les serveurs MCP, les clients MCP et les transports qui véhiculent des messages encadrés en JSON‑RPC entre eux. Voici les principaux composants avec lesquels vous interagirez lors de la création d’un serveur pour Claude Code (ou d’autres clients MCP).
Serveur, client et protocole
- Serveur MCP — Un service qui publie des outils, des ressources et des prompts. Les outils peuvent produire des effets de bord ou récupérer des données ; les ressources exposent du contenu en lecture seule ; les prompts sont des modèles de prompt réutilisables que le client peut demander au modèle d’échantillonner.
- Client MCP (hôte) — Généralement intégré à l’hôte LLM (p. ex., Claude Code, extension VS Code, client navigateur). Il découvre les serveurs disponibles, présente les descriptions d’outils au modèle et achemine les appels initiés par le modèle vers les serveurs.
- Protocole — Les messages sont encodés en JSON‑RPC ; la spécification définit les événements de cycle de vie, la découverte d’outils, l’invocation, les complétions/échantillonnages, ainsi que la façon dont les résultats structurés sont renvoyés au client et au modèle.
Schéma de communication (ce qui se passe lorsqu’un outil est utilisé)
- Le client envoie le message de l’utilisateur au modèle.
- Le modèle analyse le contexte et décide d’appeler un outil exposé par MCP (ou plusieurs).
- Le client transmet l’appel d’outil au serveur MCP via le transport choisi.
- Le serveur exécute l’outil et renvoie les résultats.
- Le modèle reçoit la sortie de l’outil et compose la réponse finale pour l’utilisateur.
Primitives d’implémentation
- Les messages JSON‑RPC suivent le schéma MCP.
- Les définitions d’outils sont publiées dans les réponses de découverte du serveur pour que les clients puissent les présenter dans l’interface.
- Les ressources sont référencées par la syntaxe
@source:pathpar les clients (p. ex.,@postgres:...), ce qui permet aux modèles de faire référence à du contenu externe sans intégrer de grandes quantités de données dans le prompt.
Pourquoi intégrer Claude Code avec des serveurs MCP ?
Claude Code est l’offre d’Anthropic axée sur les workflows liés au code et aux développeurs (intégration éditeur/IDE, compréhension de code, etc.). Exposer vos outils internes (recherche de sources, exécution de CI, système de tickets, registres privés) via des serveurs MCP permet à Claude Code de les appeler comme des outils de premier ordre au sein des conversations de codage et des flux d’agents.
Intégrer Claude Code avec des serveurs MCP déverrouille des capacités pratiques et pertinentes en production pour un agent de codage :
1. Permettre au modèle d’agir sur des systèmes réels
Claude Code peut demander à un serveur MCP d’interroger des trackers d’incidents, d’exécuter des requêtes de base de données, de lire de longs documents ou de créer des PR GitHub — permettant une automatisation de bout en bout depuis la session de codage. Cela est explicitement pris en charge par la documentation de Claude Code (exemples : interroger Postgres, Sentry, ou créer des PR).
2. Décharger les gros volumes de données et la logique spécialisée
Au lieu d’intégrer chaque source de données dans le prompt (ce qui consomme des tokens), vous publiez des données et des outils via MCP. Le modèle appelle l’outil, obtient une réponse structurée et raisonne avec — cela réduit l’utilisation de tokens et laisse les serveurs gérer les tâches lourdes (requêtes BD, lectures de fichiers longues, authentification).
3. Sécurité et gouvernance
MCP centralise le contrôle d’accès et l’audit au niveau du serveur, permettant aux organisations de mettre sur liste blanche les serveurs approuvés, de contrôler les outils disponibles et de limiter les sorties. Claude Code prend également en charge la configuration MCP d’entreprise et le consentement par périmètre.
4. Réutilisabilité et écosystème
Les serveurs MCP sont réutilisables entre clients et équipes. Créez une fois et de nombreux clients Claude/LLM peuvent utiliser les mêmes services (ou remplacer les implémentations).
Ce dont vous avez besoin avant de commencer
Prérequis minimum
- Une machine de développement avec Python 3.10+ (nous utiliserons Python dans l’exemple). Alternativement, Node / d’autres langages sont pris en charge par les SDK MCP.
uv(l’outil d’Astral) ou un lanceur équivalent pour exécuter des serveurs MCP via stdio (le tutoriel MCP utiliseuv). Étapes d’installation ci‑dessous.- Claude Code installé ou accès au client Claude (desktop ou CLI) pour enregistrer et tester votre serveur ; ou tout client compatible MCP. Claude Code prend en charge HTTP, SSE et des serveurs stdio locaux.
- Note de sécurité : n’ajoutez à Claude Code que des serveurs MCP de confiance dans des contextes d’équipe ou d’entreprise — MCP donne aux serveurs l’accès à des données sensibles, et des risques d’injection de prompt existent si un serveur renvoie du contenu malveillant.
Comment installer et vérifier la CLI Claude Code
Voici le Guide d’installation et d’utilisation de Claude Code.
1) Résumé rapide — méthodes d’installation recommandées
Utilisez l’installateur natif (recommandé) ou Homebrew sur macOS/Linux. NPM est disponible si vous avez besoin d’une installation basée sur Node. Windows dispose d’installateurs PowerShell / CMD. Source : documentation officielle de Claude Code et GitHub.
2) Prérequis
- macOS 10.15+, Ubuntu 20.04+/Debian 10+, ou Windows 10+ (WSL recommandé sur Windows).
- Node.js 18+ uniquement requis pour la méthode d’installation via NPM.
3) Commandes d’installation (choisissez-en une)
Natif (recommandé — sans dépendance à Node), macOS / Linux / WSL :
curl -fsSL https://claude.ai/install.sh | bash
# optional: install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest
# or install a specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
Windows PowerShell :
irm https://claude.ai/install.ps1 | iex
# or for latest: & (::Create((irm https://claude.ai/install.ps1))) latest
(Ce sont les scripts d’installation natifs officiels).
NPM (si vous souhaitez une installation globale basée sur Node) :
# requires Node.js 18+
npm install -g @anthropic-ai/claude-code
N’utilisez pas sudo npm install -g — évitez les installations globales avec sudo (problèmes de permissions/sécurité). En cas d’erreurs de permission, utilisez nvm ou corrigez votre préfixe global npm plutôt que d’utiliser sudo.
4) Vérifier que le binaire a été installé (vérifications de base)
Exécutez ceci localement juste après l’installation :
# is the command on PATH?
which claude
# version (or -v)
claude --version
# or
claude -v
# help (sanity check)
claude --help
Résultat attendu : which affiche un chemin (p. ex., /usr/local/bin/claude ou ~/.nvm/.../bin/claude) et claude --version imprime une chaîne de type semver. La documentation et le README indiquent tous deux claude comme point d’entrée principal de la CLI.
5) Vérifier l’état de l’installation et la configuration (contrôles recommandés)
a) claude doctor, Exécutez :
claude doctor
Ce diagnostic intégré vérifie votre type d’installation, les problèmes courants (comme les problèmes de permissions npm), les dépendances telles que ripgrep, et propose des correctifs. La documentation recommande explicitement d’exécuter claude doctor après l’installation.
b) Exécuter un smoke test (non interactif)
Depuis le répertoire de votre projet :
cd /path/to/your/project
claude -p "Explain this project in 3 sentences"
Cela utilise le mode print (-p) pour envoyer un prompt unique puis quitter ; utile pour la CI ou des vérifications fonctionnelles rapides.
c) Vérification de l’authentification (assurez‑vous que la CLI peut joindre Anthropic)
Claude Code prend en charge plusieurs flux d’authentification (OAuth via la console, clé API, intégrations fournisseurs). Contrôles courants :
- Si vous utilisez une clé API (CI / sans tête / variable d’environnement locale) :
export ANTHROPIC_API_KEY="sk-..."
# then
claude auth status
claude auth whoami # or `claude auth whoami` / `claude whoami` depending on version
Vous pouvez utiliser la clé API de CometAPI pour utiliser Claude Code. L’utilisation de l’API de Claude via CometAPI vous fera bénéficier d’une remise de 20 %.
- Si vous avez utilisé OAuth via la console — exécutez :
claude auth status
claude auth whoami
Vous devriez voir des informations de compte/forfait ou une confirmation que vous êtes authentifié.
Préparation de l’environnement étape par étape
Ci‑dessous figurent des étapes concrètes pour préparer deux piles de développement courantes (TypeScript et Python), suivies de vérifications rapides pour s’assurer que tout fonctionne.
H3 — A. Configuration TypeScript / Node (chemin le plus rapide)
- Créez le projet et installez le SDK :
mkdir mcp-demo && cd mcp-demo
npm init -y
npm install @modelcontextprotocol/sdk express zod
npm install --save-dev typescript tsx @types/node @types/express
- Créez
server.ts. (Nous fournissons un exemple complet dans la section « Comment créer rapidement… ».) - Exécutez :
npx -y tsx server.ts
- Testez en local avec MCP Inspector ou ajoutez‑le à Claude Code :
npx @modelcontextprotocol/inspector
# or (for Claude Code)
claude mcp add --transport http my-server http://localhost:3000/mcp
(L’Inspector et les commandes Claude permettent de valider la découverte et d’invoquer des outils.)
Comment créer rapidement un serveur MCP pour Claude Code ?
liste de contrôle rapide
-
Démarrez votre serveur (HTTP « streamable » recommandé) :
node server.tsouuvicorn server:app. -
Depuis votre machine de développement, faites l’une des actions suivantes :
- Utilisez MCP Inspector pour valider (
npx @modelcontextprotocol/inspector) et confirmertools/listetresources/list; ou - Ajoutez le serveur à Claude Code :
claude mcp add --transport http <name> http://<host>:<port>/mcp(ou suivez les parcours de l’interface web si votre client prend en charge MCP distant).
Si vous prévoyez d’utiliser le connecteur Messages API d’Anthropic pour MCP distant (sans client séparé), lisez la documentation de Claude — un en‑tête en bêta peut être requis (vérifiez la documentation pour l’en‑tête exact et l’état de support actuel).
Vous trouverez ci‑dessous deux exemples de serveurs complets mais compacts que vous pouvez copier, exécuter et connecter à Claude Code (ou à MCP Inspector). L’exemple TypeScript utilise Express + le SDK TypeScript ; l’exemple Python montre un montage FastAPI.
Remarque : le code ci‑dessous suit les exemples publiés des SDK et est intentionnellement minimal pour la clarté. En production, ajoutez l’authentification, la journalisation, la limitation de débit et une validation d’entrée au‑delà des valeurs par défaut du SDK.
Exemple 1 : TypeScript + Express (HTTP « streamable »)
Créez server.ts (complet) :
// server.ts
import express from "express";
import * as z from "zod/v4";
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
const server = new McpServer({ name: "claude-code-demo", version: "0.1.0" });
// Register a simple tool: add two numbers
server.registerTool(
"add",
{
title: "Add",
description: "Add two numbers a and b",
inputSchema: { a: z.number(), b: z.number() },
outputSchema: { result: z.number() }
},
async ({ a, b }) => {
const output = { result: a + b };
return {
content: ,
structuredContent: output
};
}
);
// Register a resource: greet user (dynamic)
server.registerResource(
"greeting",
new ResourceTemplate("greeting://{name}", { list: undefined }),
{ title: "Greeting", description: "Return a greeting for the name" },
async (uri, params) => {
return {
contents:
};
}
);
// Express + Streamable HTTP transport
const app = express();
app.use(express.json());
app.post("/mcp", async (req, res) => {
const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
// Close transport when connection closes
res.on("close", () => transport.close());
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
});
const port = parseInt(process.env.PORT || "3000", 10);
app.listen(port, () => console.log(`MCP server listening: http://localhost:${port}/mcp`));
Exécutez :
npm install
npx -y tsx server.ts
Puis connectez‑vous dans Claude Code (exemple) :
# Add the remote server to your Claude Code MCP list (local dev)
claude mcp add --transport http my-demo http://localhost:3000/mcp
Cet exemple est adapté du guide de démarrage rapide du SDK TypeScript officiel et montre comment enregistrer des outils et des ressources, puis les exposer via HTTP « streamable ».
Exemple 2 : Python + FastAPI (FastMCP + HTTP « streamable »)
Créez server.py (complet) :
# server.py
from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP
app = FastAPI()
mcp = FastMCP("claude-python-demo", stateless_http=True)
# tool: simple sum
@mcp.tool()
def add(a: int, b: int) -> dict:
"""Add two integers"""
return {"result": a + b}
# resource: simple greeting resource template
@mcp.resource("greeting://{name}")
def greeting(name: str):
return {"contents": }
# mount the streamable-http MCP endpoint (FastMCP exposes an ASGI app)
app.mount("/mcp", mcp.streamable_http_app())
# optional endpoint to demonstrate other API routes
@app.get("/")
async def root():
return {"status": "OK"}
Exécutez :
uvicorn server:app --reload --port 8000
Connectez‑vous avec l’Inspector :
npx @modelcontextprotocol/inspector
# In Inspector select Streamable HTTP and enter http://localhost:8000/mcp
Les exemples du SDK Python et les utilitaires FastMCP facilitent l’enregistrement de fonctions décorées @mcp.tool() et @mcp.resource() que le LLM peut découvrir et appeler.
Comment Claude Code appelle-t-il concrètement vos outils ?
Lorsqu’un LLM décide d’utiliser un outil, le client envoie une invocation JSON‑RPC au serveur MCP. Le serveur exécute l’outil demandé (par exemple, interroge une base de données, lance des tests ou appelle une API externe) et renvoie un contenu structuré et un contenu présentable. Le client (Claude Code) peut ensuite inclure la sortie structurée dans le contexte du modèle pour que celui‑ci poursuit son raisonnement avec ces données fiables — pas seulement la sortie textuelle du serveur. Le SDK TypeScript prend en charge l’enregistrement d’inputSchema et outputSchema (zod) afin que les arguments et sorties soient validés et typés de manière machine.
Quels outils de test et de débogage utiliser ?
MCP Inspector
MCP Inspector est l’outil visuel officiel pour tester les serveurs MCP. Il vous permet de vous connecter à un serveur (stdio, SSE ou HTTP « streamable »), de lister les outils, de les invoquer manuellement et d’inspecter le cycle de vie des messages JSON‑RPC — inestimable pendant le développement. Lancez‑le via npx @modelcontextprotocol/inspector.
Tests locaux vs distants
- Local (stdio) — cycle d’itération rapide pour les applications desktop et le débogage hors ligne.
- HTTP « streamable » — testez avec l’Inspector ou connectez‑vous à Claude Code via la CLI
claude mcp addou le connecteur MCP dans Messages API pour des tests distants. Assurez‑vous de fournir les en‑têtes d’authentification requis par votre serveur.
Conclusion
MCP est le pont pratique entre les LLM modernes et les systèmes qui détiennent réellement les données et exécutent les actions. Pour les workflows de code, intégrer Claude Code avec un serveur MCP donne au modèle un accès structuré et traçable aux dépôts, à la CI, aux trackers d’incidents et aux outils personnalisés — conduisant à une automatisation plus précise et à des effets de bord plus sûrs. Avec des SDK officiels en TypeScript et Python, HTTP « streamable » pour l’hébergement distant, et des outils comme MCP Inspector, vous pouvez créer un serveur minimal en quelques minutes et itérer vers un déploiement en production.
Les développeurs peuvent accéder à l’API Claude Sonnet 4.5 et à l’API Claude Opus 4.1, etc., via CometAPI ; la dernière version du modèle est toujours mise à jour par rapport au site officiel. Pour commencer, explorez les capacités du modèle dans le Playground et consultez le guide de l’API pour des instructions détaillées. Avant d’y accéder, assurez‑vous d’être connecté à CometAPI et d’avoir obtenu la clé API. CometAPI propose un tarif bien inférieur au prix officiel pour vous aider à intégrer.
Prêt à démarrer ? → Inscrivez-vous à CometAPI dès aujourd’hui !
Si vous souhaitez plus d’astuces, de guides et d’actualités sur l’IA, suivez‑nous sur VK, X et Discord !