Construis ton propre serveur MCP pour Claude Code

Problème : Les serveurs MCP publics ne parlent pas aux systèmes que tu utilises vraiment. Ton API interne, le Postgres de la boîte, un workflow personnalisé que personne d'autre ne touche. Pour que Claude Code les atteigne, tu dois écrire le serveur toi-même.

Gain immédiat : Cinq minutes de Node.js et Claude parle à n'importe quelle API REST :

// my-api-server.js - Connect Claude to your API
const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
 
const server = new Server({ name: "my-api-server", version: "1.0.0" });
 
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "fetch_user_data",
      description: "Get user information from our internal API",
      inputSchema: {
        type: "object",
        properties: {
          userId: { type: "string", description: "User ID to fetch" },
        },
        required: ["userId"],
      },
    },
  ],
}));
 
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
 
  if (name === "fetch_user_data") {
    const response = await fetch(
      `https://api.yourcompany.com/users/${args.userId}`,
      {
        headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
      },
    );
    return {
      content: [{ type: "text", text: JSON.stringify(await response.json()) }],
    };
  }
});
 
server.connect(process.stdio);

Sauvegarde le fichier en my-api-server.js. Lance node my-api-server.js pour le tester. C'est une intégration qui fonctionne.

Ce qu'est vraiment un serveur MCP

Un serveur MCP est un processus Node.js qui fournit à Claude Code une liste d'outils appelables. Il tourne seul, séparé de l'éditeur, et donne à Claude un accès câblé à tout ce que tu peux atteindre depuis Node : API, bases de données, services internes.

Chaque serveur livre quatre choses :

Définitions d'outils : les fonctions que Claude est autorisé à appeler
Gestionnaires d'outils : le code qui tourne quand Claude en appelle un
Gestion des erreurs : des messages utiles quand l'appel échoue
Authentification : un moyen sécurisé d'atteindre les systèmes derrière

Les patterns qui couvrent la plupart des cas

Parler à une API REST

Pointe Claude vers n'importe quel endpoint HTTP avec un petit connecteur :

// Generic API connector pattern
const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
 
const server = new Server({ name: "api-connector", version: "1.0.0" });
 
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "api_get",
      description: "GET request to any endpoint",
      inputSchema: {
        type: "object",
        properties: {
          endpoint: { type: "string", description: "API endpoint path" },
          params: { type: "object", description: "Query parameters" },
        },
        required: ["endpoint"],
      },
    },
  ],
}));
 
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
 
  if (name === "api_get") {
    const url = new URL(`${process.env.API_BASE_URL}${args.endpoint}`);
    if (args.params) {
      Object.entries(args.params).forEach(([key, value]) =>
        url.searchParams.append(key, value),
      );
    }
 
    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${process.env.API_TOKEN}` },
    });
 
    return {
      content: [
        { type: "text", text: JSON.stringify(await response.json(), null, 2) },
      ],
    };
  }
});
 
server.connect(process.stdio);

La même forme gère Stripe, Shopify, ton dashboard interne, tout ce qui parle HTTP.

Parler à une base de données

Remplace l'appel fetch par un client de base de données :

// Database connector for PostgreSQL, MySQL, SQLite
const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
const { Client } = require("pg");
 
const server = new Server({ name: "database-connector", version: "1.0.0" });
const client = new Client({ connectionString: process.env.DATABASE_URL });
 
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "query_database") {
    const result = await client.query(request.params.arguments.query);
    return {
      content: [{ type: "text", text: JSON.stringify(result.rows, null, 2) }],
    };
  }
});

Claude peut maintenant lancer du SQL et aider avec le travail de base de données.

Setup et tests

Lance le projet :

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

Ensuite pointe Claude Code sur le serveur depuis son fichier de config MCP. L'emplacement de ce fichier dépend de comment tu lances Claude :

Claude Code CLI : ~/.claude.json (niveau utilisateur) ou .mcp.json (niveau projet)
Claude Desktop : ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json (Windows)

{
  "mcpServers": {
    "my-custom-server": {
      "command": "node",
      "args": ["/path/to/your/server.js"],
      "env": { "API_TOKEN": "your-token" }
    }
  }
}

Redémarre Claude Code après avoir sauvegardé. Le nouveau serveur se charge au démarrage.

Quand ça casse

Serveur introuvable : le chemin de config ou le JSON est mauvais. Vérifie l'emplacement du fichier. Utilise un chemin absolu pour command.

Timeout d'outil : les appels qui durent longtemps bloquent l'outil. Enveloppe-les dans ton propre timeout pour qu'ils échouent proprement.

Authentification échouée : les variables d'environnement dans la config n'atteignent pas le serveur. Vérifie qu'elles sont bien orthographiées et présentes.

Ce qui vaut la peine d'être fait dès le départ

Chaque appel externe va dans un try-catch pour que les erreurs remontent comme du texte, pas des crashs
Les tokens vivent dans des variables d'environnement, jamais dans le source
Les API avec rate limit ont besoin de leur propre throttle pour que Claude ne brûle pas ton quota
La sortie console.log apparaît dans les logs de Claude, donc utilise-la librement pour le débogage

Prochaines étapes

Choisis une chose à câbler et construis à partir de là :

Commence par une API : celle que tu touches chaque jour
Copie le pattern REST : le connecteur ci-dessus est le template
Confirme qu'il s'est chargé : demande à Claude "Quels outils MCP sont disponibles ?" et ton nouvel outil devrait apparaître
Écris de bonnes descriptions d'outils : MCP Tool Search les utilise pour décider quand charger ton serveur
Lis la suite : le guide des bases MCP et la liste des serveurs MCP populaires couvrent quoi construire ensuite

Un serveur MCP personnalisé transforme Claude Code en client pour ta propre stack. Un serveur par semaine et la liste de ce que Claude peut atteindre s'allonge discrètement.

Construis ton propre serveur MCP pour Claude Code

On this page