Oui, vous pouvez rendre votre produit utilisable par Claude, ChatGPT, Cursor ou VS Code sans écrire un connecteur pour chaque client. Un serveur MCP expose vos données et vos actions dans un format que ces agents savent déjà appeler. La spécification MCP en vigueur est la révision 2026-07-28, et le SDK TypeScript officiel est publié en version 2.4.0 sur npm au 6 novembre 2026. Le premier serveur local tient dans un fichier avec deux outils ; le passage en production ajoute le transport HTTP, l'authentification et la publication.

Le protocole utilise JSON-RPC 2.0. Un hôte — Claude, ChatGPT, Cursor, VS Code — lance un client qui se connecte à votre serveur. Le serveur expose trois familles d'objets : les outils, que le modèle peut appeler ; les ressources, que le client peut lire et attacher au contexte ; les prompts, que l'utilisateur déclenche explicitement. Votre serveur ne décide pas quand un outil est appelé. Il décrit ce qu'il sait faire, et le modèle choisit.

Ce que MCP change pour votre produit#

Une API REST classique demande au modèle de connaître vos routes, vos paramètres et vos codes d'erreur. MCP déplace cette connaissance dans le serveur : chaque outil porte un nom, une description, un schéma d'entrée et, si vous le fournissez, un schéma de sortie. Le client affiche l'appel, demande l'accord de l'utilisateur et transmet le résultat au modèle.

L'intérêt n'est pas de remplacer votre API. C'est de fournir une couche de découverte et de sécurité entre le modèle et votre produit. Un agent qui cherche une note n'a pas besoin de savoir si votre backend utilise PostgreSQL, Stripe ou un index plein texte. Il appelle search_notes avec une requête, et votre serveur traduit.

MCP est aussi devenu un point de passage commun. Claude, ChatGPT, Cursor et VS Code acceptent des serveurs MCP distants en Streamable HTTP. Un serveur local en stdio reste utile pour les outils qui lisent des fichiers ou une base locale. Cette dualité explique pourquoi le SDK TypeScript publie deux surfaces : @modelcontextprotocol/server pour le serveur et @modelcontextprotocol/client pour le client, avec des paquets séparés depuis la version 2.

Définir le périmètre : deux outils, pas vingt#

La tentation est de tout exposer. Un serveur qui propose vingt outils génériques fatigue le modèle, allonge le prompt et multiplie les mauvais choix. Commencez par le parcours qui justifie l'intégration : trouver un objet, puis lire sa fiche. Dans cet article, le produit exemple est un service de notes avec search_notes et get_note.

Quelques règles rendent ces outils utilisables par un agent. Le nom décrit l'action et le domaine : search_notes, pas search. La description dit quand l'utiliser, pas seulement ce qu'elle fait. Chaque champ du schéma porte un .describe() : le SDK convertit cette description en JSON Schema, et c'est la seule documentation que le modèle reçoit pour l'argument. Les résultats sont bornés : vingt notes au maximum, un extrait de 160 caractères, et une URL canonique pour que le client puisse citer la source.

Les annotations aident le client à décider quoi montrer. readOnlyHint: true signale un outil qui ne modifie rien. destructiveHint: true demande une confirmation avant une suppression. idempotentHint: true indique qu'un appel répété produit le même résultat. Ces annotations sont des indications, pas des contrôles d'accès : un client peut les ignorer, et votre serveur doit appliquer ses propres règles.

Pour une écriture, ajoutez une confirmation explicite et un identifiant d'idempotence. Un outil create_note qui reçoit deux fois la même requête ne doit pas créer deux notes. Le modèle peut se tromper, réessayer ou être interrompu ; votre serveur doit rester prévisible.

Préparer le projet TypeScript#

Le SDK 2.4.0 déclare Node.js 20 ou plus récent dans ses engines. Créez un projet vide, installez le serveur et Zod, puis ajoutez TypeScript :

bash
mkdir notes-mcp
cd notes-mcp
npm init -y
npm install @modelcontextprotocol/server zod
npm install -D typescript @types/node
mkdir src

Activez les modules ES et les scripts de compilation dans package.json :

json
{
  "name": "notes-mcp",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "node dist/stdio.js"
  }
}

Créez un tsconfig.json minimal. La cible ES2022 suffit pour Node.js 20, et module: Node16 garde les imports explicites :

json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "types": ["node"],
    "skipLibCheck": true
  },
  "include": ["src"]
}

Séparez la fabrication du serveur de son transport. src/create-server.ts exporte une fonction qui construit un serveur neuf ; src/stdio.ts l'utilise pour le transport local. Cette séparation permet de réutiliser exactement les mêmes outils derrière HTTP, sans dupliquer le code.

Écrire les outils avec Zod#

Le fichier ci-dessous définit deux outils, une ressource et un prompt. Le stockage en mémoire est volontairement simple : remplacez le tableau notes par vos appels API ou votre base. Le point important est la forme du serveur, pas la source de données.

ts
import { McpServer } from "@modelcontextprotocol/server";
import * as z from "zod/v4";

type Note = { id: string; title: string; body: string; url: string };

const notes: Note[] = [
  {
    id: "n_1042",
    title: "Relancer un déploiement Coolify",
    body: "Ouvrez le projet, puis Deploy. Le healthcheck attend 30 secondes.",
    url: "https://app.example.com/notes/n_1042"
  }
];

export function createServer() {
  const server = new McpServer({ name: "notes", version: "1.0.0" });

  server.registerTool(
    "search_notes",
    {
      title: "Rechercher dans les notes",
      description:
        "Cherche des notes par mots-clés et renvoie au plus 20 résultats avec leur URL.",
      inputSchema: z.object({
        query: z.string().min(2).describe("Mots-clés à chercher dans le titre et le corps"),
        limit: z.number().int().min(1).max(20).default(10)
      }),
      outputSchema: z.object({
        results: z.array(
          z.object({
            id: z.string(),
            title: z.string(),
            url: z.string(),
            snippet: z.string()
          })
        )
      }),
      annotations: { readOnlyHint: true, idempotentHint: true }
    },
    async ({ query, limit }) => {
      const needle = query.toLowerCase();
      const results = notes
        .filter((note) => `${note.title} ${note.body}`.toLowerCase().includes(needle))
        .slice(0, limit)
        .map((note) => ({
          id: note.id,
          title: note.title,
          url: note.url,
          snippet: note.body.slice(0, 160)
        }));

      const output = { results };
      return {
        content: [{ type: "text", text: JSON.stringify(output) }],
        structuredContent: output
      };
    }
  );

  server.registerTool(
    "get_note",
    {
      title: "Lire une note",
      description: "Renvoie le contenu complet d'une note à partir de son identifiant.",
      inputSchema: z.object({
        id: z.string().describe("Identifiant renvoyé par search_notes")
      }),
      outputSchema: z.object({
        id: z.string(),
        title: z.string(),
        text: z.string(),
        url: z.string()
      }),
      annotations: { readOnlyHint: true }
    },
    async ({ id }) => {
      const note = notes.find((candidate) => candidate.id === id);
      if (!note) {
        return {
          content: [{ type: "text", text: `Aucune note avec l'identifiant ${id}.` }],
          isError: true
        };
      }

      const output = { id: note.id, title: note.title, text: note.body, url: note.url };
      return {
        content: [{ type: "text", text: JSON.stringify(output) }],
        structuredContent: output
      };
    }
  );

  server.registerResource(
    "guide",
    "notes://guide",
    {
      title: "Guide des notes",
      description: "Conventions de titre, de balises et de liens internes.",
      mimeType: "text/markdown"
    },
    async (uri) => ({
      contents: [
        {
          uri: uri.href,
          mimeType: "text/markdown",
          text: "# Guide\n\nUn titre par note, des balises courtes, une URL canonique."
        }
      ]
    })
  );

  server.registerPrompt(
    "summarize-note",
    {
      title: "Résumer une note",
      description: "Prépare un résumé en trois points d'une note.",
      argsSchema: z.object({
        id: z.string().describe("Identifiant de la note")
      })
    },
    ({ id }) => ({
      messages: [
        {
          role: "user" as const,
          content: {
            type: "text" as const,
            text: `Résume la note ${id} en trois points, puis cite son URL.`
          }
        }
      ]
    })
  );

  return server;
}

Trois détails comptent dans ce fichier. Le schéma Zod est la seule source de vérité : le SDK en dérive le JSON Schema annoncé, valide les arguments avant l'appel et type le paramètre du handler. Un argument hors schéma revient au modèle comme un résultat isError: true, avec un message qu'il peut lire et corriger. Enfin, structuredContent double le texte JSON : les clients récents peuvent valider la structure, les plus anciens lisent le texte.

Le transport local tient en quelques lignes :

ts
import { serveStdio } from "@modelcontextprotocol/server/stdio";
import { createServer } from "./create-server.js";

serveStdio(createServer, {
  onerror: (error) => console.error("notes-mcp:", error)
});

serveStdio choisit l'ère du protocole à l'ouverture, puis épingle une instance fabriquée par createServer pour la durée de la connexion. Il sert les clients 2026-07-28 et, par défaut, les clients 2025 qui ouvrent encore avec initialize ; l'option { legacy: "reject" } refuse ces derniers. Une sonde server/discover peut créer une instance supplémentaire, jetée si le client retombe sur initialize : createServer doit donc renvoyer un serveur neuf à chaque appel, sans état partagé.

Ajouter une ressource et un prompt#

Les ressources sont contrôlées par l'application, pas par le modèle. notes://guide donne au client un document stable qu'il peut lire et joindre à la conversation. Un client comme VS Code expose ces ressources dans un menu de contexte ; Claude et Cursor les listent aussi. Utilisez-les pour les conventions, les schémas de données ou les catalogues qui changent peu.

Les prompts sont déclenchés par l'utilisateur, souvent sous forme de commande ou de menu. summarize-note prépare un message avec l'identifiant fourni. Le client peut afficher les arguments, l'utilisateur les remplit, puis le modèle reçoit le message. Un prompt n'exécute rien : il cadre la demande.

Ces deux surfaces ne sont pas obligatoires. Un serveur qui n'expose que des outils fonctionne. Mais une ressource évite de répéter les mêmes explications dans chaque description d'outil, et un prompt donne un point d'entrée visible à l'utilisateur qui ne sait pas quel outil appeler.

Tester avec l'Inspector avant de brancher un agent#

L'Inspector officiel se lance avec npx. La commande CLI se connecte, exécute une seule requête, affiche le résultat et quitte. C'est le moyen le plus rapide de vérifier un serveur avant de l'ajouter à un hôte.

bash
npm run build
npx @modelcontextprotocol/inspector --cli node dist/stdio.js \
  --protocol-era modern --method tools/list

L'Inspector utilise par défaut l'ère legacy, qui ne teste que la poignée de main 2025. Passez --protocol-era modern pour vérifier le comportement 2026-07-28, puis relancez sans l'option pour vérifier la compatibilité avec les anciens clients. Les deux exécutions doivent lister search_notes et get_note.

Appelez un outil avec ses arguments :

bash
npx @modelcontextprotocol/inspector --cli node dist/stdio.js \
  --method tools/call --tool-name search_notes \
  --tool-arg query=coolify --tool-arg limit=3

Pour un pipeline, demandez du JSON et filtrez avec jq :

bash
npx @modelcontextprotocol/inspector --cli node dist/stdio.js \
  --method tools/list --format json | jq '.result.tools[].name'

Un tools/call qui renvoie isError: true sort avec le code 5. Un serveur injoignable sort avec le code 4, et un serveur qui exige une authentification avec le code 3. Ces codes permettent de distinguer un test rouge d'un outil qui a échoué proprement.

Passer du stdio au Streamable HTTP#

Le stdio convient à un serveur lancé par le client sur la même machine. Pour un produit utilisé par plusieurs personnes, il faut une URL publique et le transport Streamable HTTP. Le tableau ci-dessous résume les quatre différences qui comptent :

BesoinstdioStreamable HTTP
UtilisateursUn seul, sur la même machinePlusieurs, à distance
DéploiementCommande locale lancée par le clientWorker, VPS ou conteneur
AuthentificationVariables d'environnementOAuth 2.0 ou jeton bearer
ÉtatLe processus peut garder de la mémoireUne instance neuve par requête

Le SDK v2 fournit createMcpHandler, qui transforme une fabrique de serveur en handler HTTP standard. Avec Hono, createMcpHonoApp ajoute l'analyse du corps JSON et la validation des en-têtes Host et Origin :

ts
import { createMcpHonoApp } from "@modelcontextprotocol/hono";
import { createMcpHandler } from "@modelcontextprotocol/server";
import type { Context } from "hono";
import { createServer } from "./create-server.js";

const handler = createMcpHandler(createServer);

const app = createMcpHonoApp({
  host: "0.0.0.0",
  allowedHosts: ["mcp.example.com", "127.0.0.1", "localhost"]
});

app.all("/mcp", (c: Context) =>
  handler.fetch(c.req.raw, { parsedBody: c.get("parsedBody") })
);

export default app;

createMcpHandler appelle la fabrique à chaque requête et ne garde rien entre deux appels. Un serveur v2 est donc sans état et se déploie horizontalement sans session collante. Si vous avez besoin d'un panier, d'un travail long ou d'un identifiant de conversation, stockez-le dans votre base et faites-le transiter comme argument d'outil. Ne le gardez pas dans une variable de module : la requête suivante peut tomber sur une autre instance.

Sur Cloudflare Workers, le export default app suffit. Ajoutez Wrangler et un fichier de configuration :

bash
npm install hono @modelcontextprotocol/hono
npm install -D wrangler
jsonc
{
  "name": "notes-mcp",
  "main": "src/http.ts",
  "compatibility_date": "2026-11-01"
}
bash
npx wrangler dev
npx wrangler deploy

Testez l'endpoint avec une requête JSON-RPC. La réponse peut arriver en JSON ou en événement SSE, selon que le handler émet une notification pendant l'appel :

bash
curl -s -X POST http://127.0.0.1:8787/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

createMcpHonoApp valide les en-têtes Host et Origin pour éviter le DNS rebinding : une page malveillante peut faire résoudre son domaine vers 127.0.0.1 et atteindre un serveur local comme si elle était de même origine. En production, remplacez mcp.example.com par votre domaine réel et gardez localhost uniquement si vous testez en local. Si vous préférez ne jamais diffuser d'événements, createMcpHandler(createServer, { responseMode: "json" }) force une réponse JSON unique.

Pour un serveur Node classique, Hono s'exécute avec @hono/node-server. Pour un VPS, un conteneur Docker fait aussi l'affaire. Le tutoriel de déploiement Next.js avec Coolify montre la mécanique d'un service Node derrière un proxy et un certificat ; elle s'applique à un serveur MCP.

Authentifier les appels#

Un serveur MCP public est un serveur de ressources OAuth. Il ne délivre pas de jetons : il vérifie ceux qu'un fournisseur d'identité a émis pour lui. Le SDK fournit requireBearerAuth pour cette porte. Vous écrivez une seule fonction, verifyAccessToken, qui prend le jeton brut et renvoie un AuthInfo ou lève une erreur.

ts
import { requireBearerAuth } from "@modelcontextprotocol/server";
import type { AuthInfo } from "@modelcontextprotocol/server";

const resource = new URL("https://mcp.example.com/mcp");

async function verifyAccessToken(token: string): Promise<AuthInfo> {
  const payload = await verifyJwt(token);
  const audience = [payload.aud ?? []]
    .flat()
    .find((value) => URL.canParse(value) && new URL(value).origin === resource.origin);

  return {
    token,
    clientId: payload.sub,
    scopes: payload.scopes,
    expiresAt: payload.exp,
    resource: audience ? new URL(audience) : undefined
  };
}

const gate = requireBearerAuth({
  verifier: { verifyAccessToken },
  requiredScopes: ["notes:read"],
  expectedResource: resource,
  resourceMetadataUrl: new URL("/.well-known/oauth-protected-resource/mcp", resource)
});

Branchez la porte devant la route MCP. Un jeton absent, expiré ou malformé reçoit un 401 avec un défi WWW-Authenticate ; un jeton valide qui n'a pas le scope demandé reçoit un 403. Le client suit le défi, découvre les métadonnées OAuth et recommence avec un jeton. Le paramètre resourceMetadataUrl inscrit l'adresse du document de ressource protégée dans le défi ; servez ce document avec oauthMetadataResponse sur un hôte web standard, ou mcpAuthMetadataRouter avec Express.

ts
app.all("/mcp", async (c: Context) => {
  const auth = await gate(c.req.raw);
  if (auth instanceof Response) return auth;
  return handler.fetch(c.req.raw, {
    authInfo: auth,
    parsedBody: c.get("parsedBody")
  });
});

Trois règles évitent les incidents. Ne transmettez jamais à votre API un jeton reçu d'un client sans vérifier qu'il a été émis pour votre serveur : cette réutilisation directe, ou token passthrough, est interdite par la spécification. Liez chaque identifiant d'état à l'utilisateur authentifié, pas seulement à l'identifiant fourni par le client. Et gardez les scopes étroits : notes:read pour la lecture, notes:write pour l'écriture, avec une demande d'élévation au moment de l'action.

Côté Claude, le client accepte OAuth avec enregistrement dynamique et le callback https://claude.ai/api/mcp/auth_callback. Côté Cursor, prévoyez https://www.cursor.com/agents/mcp/oauth/callback et http://localhost:8787/callback. Côté ChatGPT, l'ajout d'un serveur MCP personnalisé se fait sur le web, depuis l'interface des plugins, avec l'URL et l'authentification choisie (OAuth, aucune, ou les deux) ; l'accès complet dépend de l'offre Business, Enterprise ou Edu. Claude et Cursor acceptent aussi un jeton statique en en-tête ; pour un produit multi-utilisateur, gardez OAuth.

Brancher Claude, ChatGPT et Cursor#

Pour un serveur local, Claude Code l'ajoute avec la commande qui lance le processus. Le chemin doit être absolu :

bash
claude mcp add notes -- node /absolute/path/to/notes-mcp/dist/stdio.js
claude mcp list

Claude Desktop lit un fichier claude_desktop_config.json avec la même forme :

json
{
  "mcpServers": {
    "notes": {
      "command": "node",
      "args": ["/absolute/path/to/notes-mcp/dist/stdio.js"]
    }
  }
}

Pour un serveur distant, l'ajout se fait par URL. Claude Code :

bash
claude mcp add --transport http notes https://mcp.example.com/mcp

Cursor lit mcp.json, dans ~/.cursor/mcp.json pour une configuration globale ou .cursor/mcp.json pour un projet :

json
{
  "mcpServers": {
    "notes": {
      "url": "https://mcp.example.com/mcp"
    }
  }
}

ChatGPT ajoute un serveur MCP personnalisé depuis l'interface des plugins, sur le web, avec l'URL et l'authentification. Le guide OpenAI précise les schémas attendus : pour que le serveur fonctionne aussi en recherche approfondie et dans la connaissance d'entreprise, exposez deux outils de lecture, search et fetch, avec un structuredContent qui contient id, title, url et le texte, et le même objet sérialisé en JSON dans content. Un url non vide rend le résultat citable ; sans URL, ChatGPT garde la sortie comme un résultat ordinaire.

Un exemple public de serveur distant : Logoforge expose le sien à https://logoforge.terravidhal.me/mcp et le branche avec claude mcp add --transport http logoforge https://logoforge.terravidhal.me/mcp. La documentation MCP de Logoforge donne les commandes pour les autres éditeurs.

Les limites des clients changent le design. Claude accepte environ 150 000 caractères par résultat d'outil sur le web et le bureau, avec un délai de 240 secondes par appel. Claude Code accepte 25 000 tokens, configurables avec MAX_MCP_OUTPUT_TOKENS. Un outil qui renvoie tout un dépôt ou tout un catalogue sera tronqué ou refusé : paginez, résumez et renvoyez une URL pour le détail.

Publier au registre MCP et dans les annuaires#

Le registre MCP est en avant-première au 6 novembre 2026. Il héberge des métadonnées, pas votre code. Pour un serveur npm, ajoutez mcpName dans package.json, publiez le paquet, puis créez un server.json avec mcp-publisher.

json
{
  "name": "@your-org/notes-mcp",
  "version": "1.0.0",
  "mcpName": "io.github.your-org/notes"
}
bash
npm publish --access public
mcp-publisher init

Éditez le server.json généré. Pour un serveur distant, la section remotes remplace packages :

json
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "io.github.your-org/notes",
  "title": "Notes",
  "description": "Search and read notes from your Notes workspace.",
  "version": "1.0.0",
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://mcp.example.com/mcp"
    }
  ]
}
bash
mcp-publisher login github
mcp-publisher publish

Le serveur distant doit être accessible publiquement à l'URL déclarée. Le registre vérifie que le paquet npm correspond aux métadonnées ; le champ mcpName doit être identique au name du server.json. Pour un domaine personnalisé, le registre accepte aussi une authentification DNS, ce qui évite de préfixer le nom par io.github.

Le registre ne remplace pas les annuaires des clients. Anthropic examine les connecteurs du répertoire Claude ; n'importe quel utilisateur d'un plan Claude payant peut soumettre, et un propriétaire d'espace le fait pour Team et Enterprise. OpenAI demande un serveur MCP distant pour un plugin ChatGPT. Cursor référence les serveurs dans son marketplace et dans cursor.directory. Publier au registre aide les clients qui cherchent par nom, mais l'inscription dans chaque annuaire reste une démarche séparée.

Les erreurs qui coûtent une journée#

  • Le serveur écrit sur stdout en stdio. Un console.log corrompt le flux JSON-RPC. Utilisez console.error ou un logger qui écrit sur stderr. En HTTP, stdout ne gêne pas.
  • Les résultats sont trop gros. Un catalogue complet dépasse la limite de Claude ou noie le contexte. Paginez, résumez et renvoyez une URL canonique.
  • Le client ne voit aucun outil. Vérifiez tools/list avec l'Inspector, puis le nom du serveur et le transport. Un serveur HTTP qui répond 404 sur le chemin /mcp n'est pas branché au bon endroit.
  • Le serveur local est injoignable depuis un autre processus. Le stdio est prévu pour être lancé par le client, pas pour écouter sur un port. Pour un test manuel, utilisez l'Inspector ou un client MCP.
  • Le certificat ou le domaine échoue. Le DNS doit pointer vers l'hôte, et les ports 80 et 443 doivent atteindre le proxy. Un AAAA cassé bloque la validation même si l'IPv4 fonctionne.
  • Le jeton est refusé. Vérifiez l'audience, l'expiration et les scopes. Un 401 sans métadonnées OAuth laisse le client sans piste : servez le document de ressource protégée.
  • Le schéma casse après une mise à jour. Un champ renommé ou un enum réduit change le contrat. Versionnez les outils et gardez les anciens noms le temps de la transition.
  • Le registre refuse la publication. Le mcpName et le name du server.json doivent correspondre, et le paquet npm doit être publié avant le serveur.

Ce que ça coûte et quand ça vaut la peine#

Un serveur MCP stateless se déploie très bien sur Cloudflare Workers. Le plan gratuit inclut 100 000 requêtes par jour et 10 millisecondes de CPU par invocation. Le plan payant commence à 5 $ par mois, avec 10 millions de requêtes incluses, 0,30 $ par million supplémentaire, 30 millions de millisecondes de CPU incluses et 0,02 $ par million supplémentaire. L'exemple officiel de Cloudflare — 15 millions de requêtes à 7 ms de CPU — revient à 8 $ par mois : 5 $ d'abonnement, 1,50 $ de requêtes et 1,50 $ de CPU. Prix relevés en novembre 2026.

Un VPS devient plus simple si votre serveur doit garder un processus long, lancer des travaux en arrière-plan ou parler à une base sur le même réseau. Le comparatif Vercel, Cloudflare et Coolify chiffre ces options, et notre sélection d'hébergeurs pour développeurs donne les offres avec SSH et Git.

Le coût réel reste le vôtre : écrire deux bons outils, tester les cas d'erreur, gérer l'authentification et surveiller les appels. Un serveur MCP mal décrit ne sera pas appelé ; un serveur qui renvoie trop de données coûtera cher en tokens. Un outil bien décrit et borné vaut mieux que dix outils génériques.

Questions fréquentes#

Questions fréquentes

Faut-il un serveur MCP si j'ai déjà une API REST ?

Pas forcément. Si un seul client doit appeler une seule route, une intégration directe peut suffire. MCP devient utile quand plusieurs agents doivent découvrir les mêmes actions, quand vous voulez des schémas et des annotations, ou quand vous voulez brancher Claude, ChatGPT, Cursor et VS Code sans réécrire quatre connecteurs.

Quel transport choisir : stdio ou Streamable HTTP ?

Le stdio est le plus simple pour un outil local qui lit des fichiers ou une base sur la machine de l'utilisateur. Le Streamable HTTP est le choix par défaut pour un produit accessible à plusieurs personnes : une URL, OAuth, et un déploiement sans état. Vous pouvez servir les deux avec la même fabrique de serveur.

Comment éviter qu'un agent fasse une action destructrice ?

Commencez par des outils en lecture seule et marquez-les avec readOnlyHint. Pour les écritures, demandez une confirmation, utilisez un identifiant d'idempotence et un scope dédié. Un outil qui supprime doit être explicitement destructiveHint: true, et le client doit pouvoir refuser l'appel.

Pourquoi mon serveur n'apparaît-il pas dans Claude ou ChatGPT ?

Vérifiez d'abord tools/list avec l'Inspector, puis l'URL exacte du endpoint, le transport et l'authentification. Un serveur HTTP doit répondre sur le chemin déclaré, avec les en-têtes Host et Origin acceptés. Les journaux du client et le défi WWW-Authenticate donnent souvent la cause.

Combien coûte un serveur MCP en production ?

Un Worker Cloudflare peut rester gratuit jusqu'à 100 000 requêtes par jour ; le plan payant commence à 5 $ par mois. Un petit VPS ajoute le coût du serveur et de votre temps. Le poste principal reste l'écriture et la maintenance des outils, pas l'hébergement.

Faut-il publier au registre MCP ?

Ce n'est pas obligatoire pour brancher un serveur dans Claude, ChatGPT ou Cursor. Le registre facilite la découverte par nom et l'installation par des clients compatibles, mais il est encore en avant-première. Les annuaires de Claude, ChatGPT et Cursor restent des démarches séparées.

Sources#

Pages officielles consultées le 6 novembre 2026. Prix relevés en novembre 2026.