Créer un serveur MCP sur mesure en 2026 : le guide complet
Le guide pas à pas pour créer un serveur MCP sur mesure conforme à la spec 2026-07-28 : outils conçus d'abord, cœur sans état avec handles, Mcp-Method et Mcp-Name, demandes multi-allers-retours, OAuth et les tests qui le prouvent.
La plupart des tutos pour créer un serveur MCP ont été écrits pour la révision 2025-11-25. Ils ouvrent une session, passent par le handshake initialize, gardent l'état en mémoire, et s'arrêtent là. Sur la spec 2026-07-28, ce code répond encore aux anciens clients, mais ce n'est plus à ça que doit ressembler un nouveau serveur.
Ce guide s'adresse à une équipe qui veut un serveur MCP sur mesure pour son propre produit, conforme à la spec actuelle dès le premier jour. Il suit l'ordre que j'applique en pratique : concevoir les outils, puis le cœur sans état, puis le transport, puis l'autorisation, puis les tests. Le code arrive tard, exprès.
Ce qu'est vraiment un serveur MCP sur mesure
Un serveur MCP expose ton produit à un client IA (Claude, ChatGPT, Cursor, Le Chat et d'autres) sous forme d'outils, de ressources et de prompts. C'est le modèle côté client qui décide quand appeler un outil, avec quels arguments, et quoi faire du résultat.
« Sur mesure » veut dire que le serveur est pensé à partir de ce que tes utilisateurs demandent à un assistant, pas généré depuis ton API REST. Un wrapper généré expose chaque endpoint comme un outil. Un serveur conçu expose quelques tâches entre lesquelles le modèle choisit sans deviner. Cette différence décide si l'assistant utilise ton produit correctement ou s'y perd. C'est détaillé dans wrapper REST ou serveur MCP conçu pour l'agent.
Étape 1. Concevoir les outils avant d'écrire du code
Pars des phrases que tes utilisateurs vont taper, pas de ton schéma de base. Pour un logiciel de facturation de PME, par exemple : « liste les factures en retard de plus d'un mois » ou « relance les clients concernés ». Pour chaque phrase, note quels outils le modèle doit appeler, dans quel ordre, et ce que chacun renvoie.
Trois règles tiennent en production :
- Un outil, une tâche. Un outil nommé d'après une tâche (
creer_facture,lister_factures_en_retard) vaut mieux qu'un outilquerygénérique avec un paramètre de mode. - Les descriptions sont écrites pour le modèle. Dis quand utiliser l'outil, quand ne pas l'utiliser, et ce que veulent dire les arguments en termes métier. Voir rédiger les descriptions d'outils MCP.
- Garde une surface réduite. Chaque outil en plus est une option de plus que le modèle peut choisir par erreur. Combien c'est trop : combien d'outils exposer dans un serveur MCP.
Distingue clairement les outils d'écriture des outils de lecture. C'est sur cette séparation que tu brancheras ensuite les droits, les confirmations et les limites de débit.
La révision 2026-07-28 assouplit inputSchema et outputSchema, qui acceptent tous les mots-clés JSON Schema 2020-12, et structuredContent peut contenir n'importe quelle valeur JSON. Sers-t'en pour décrire précisément les arguments plutôt que d'accepter du texte libre à parser toi-même.
Étape 2. Construire un cœur sans état
Les sessions au niveau du protocole disparaissent en 2026-07-28. Plus d'en-tête Mcp-Session-Id, plus de handshake initialize. Chaque requête porte sa version de protocole et les capacités du client dans _meta, sous io.modelcontextprotocol/protocolVersion et io.modelcontextprotocol/clientCapabilities.
Pour un nouveau serveur, c'est une bonne nouvelle : tu n'as jamais à désapprendre l'état de session. Chaque handler reçoit tout ce dont il a besoin dans la requête, reconstruit le contexte utilisateur depuis le jeton, fait son travail, et répond.
Quand un parcours s'étale vraiment sur plusieurs appels (un devis construit étape par étape, un export paginé), la réponse de la spec est le handle. Ton serveur émet un identifiant opaque, le renvoie depuis un outil, et l'accepte comme argument ordinaire à l'appel suivant. L'état derrière vit dans ton stockage, pas dans un process. Le pattern est expliqué pas à pas dans serveur MCP sans session : remplacer Mcp-Session-Id par des handles.
Implémente aussi server/discover. La spec le rend obligatoire : c'est par là qu'un client apprend quelles versions de protocole, quelles capacités et quelle identité ton serveur annonce.
Étape 3. Gérer correctement le transport
Pour un serveur distant, utilise Streamable HTTP. L'ancien transport HTTP+SSE est classé déprécié.
Sur chaque POST, la spec 2026-07-28 exige deux en-têtes, Mcp-Method et Mcp-Name, qui reprennent la méthode JSON-RPC et le nom appelé. Ils permettent à une gateway de router, limiter et journaliser par outil sans ouvrir le corps.
Côté serveur, une obligation : comparer les en-têtes au corps et rejeter toute incohérence. Un en-tête est une déclaration, pas une preuve. Si ta politique lui fait confiance aveuglément, une requête peut annoncer un outil de lecture inoffensif et appeler un outil d'écriture. Détails dans Mcp-Method et Mcp-Name : router le trafic MCP sans lire le corps.
Trois autres points de transport issus du changelog :
- Les résultats de
tools/listet des autres endpoints de liste doivent porterttlMsetcacheScope. Choisis un TTL qui colle à la fréquence réelle de changement de tes outils. - Renvoie les outils dans un ordre déterministe, comme la spec le recommande pour aider le cache côté client.
- La reprise de flux SSE est supprimée. Si un flux de réponse casse, le client renvoie la requête avec un nouvel identifiant : rends tes outils d'écriture sûrs à rejouer.
Étape 4. Demander une information manquante à la manière 2026-07-28
Un serveur qui a besoin d'une information en cours d'appel (une confirmation, un champ manquant) n'envoie plus sa propre requête au client. Avec le pattern Multi Round-Trip Requests, l'outil renvoie un InputRequiredResult avec resultType: "input_required" et la liste de ce qu'il lui faut. Le client rejoue la requête d'origine avec inputResponses.
Chaque résultat porte désormais un resultType, "complete" pour les résultats ordinaires. Prévois-le dès le premier handler.
N'ajoute ni Roots, ni Sampling, ni Logging à un nouveau serveur. Les trois sont dépréciés : passe les chemins par paramètres d'outil ou par configuration, appelle directement ton fournisseur de modèle, et journalise sur stderr ou avec OpenTelemetry. Les traitements longs passent par l'extension io.modelcontextprotocol/tasks, voir MCP Tasks pour les traitements longs.
Étape 5. Prévoir l'autorisation dès le départ
Si ton serveur touche des données utilisateur, il lui faut OAuth, et l'ajouter après coup est le changement le plus coûteux qui soit. La révision 2026-07-28 a durci plusieurs points :
- Les serveurs d'autorisation devraient envoyer le paramètre
iss(RFC 9207), et les clients doivent le vérifier avant d'échanger le code. - Les identifiants client sont liés au serveur d'autorisation qui les a émis.
- Le Dynamic Client Registration est déprécié au profit des Client ID Metadata Documents, et reste disponible pour la compatibilité.
Côté serveur, le travail concret : publier des métadonnées de ressource protégée correctes, valider le jeton et son audience à chaque requête, et vérifier les droits par outil, en commençant par les outils d'écriture. La chaîne complète est dans OAuth pour serveur MCP en 2026.
Étape 6. Tester comme le ferait un client
Les tests unitaires ne suffisent pas. Avant de dire que le serveur est fini :
- Lance-le dans le MCP Inspector et appelle chaque outil à la main.
- Fais tourner deux instances derrière un load balancer simple, sans sessions collantes, et joue un scénario en plusieurs étapes en coupant l'une d'elles. S'il tient, le cœur est vraiment sans état.
- Envoie des requêtes dont le
Mcp-Namene correspond pas au corps, et vérifie qu'elles sont rejetées et journalisées. - Utilise les codes d'erreur de la spec actuelle : ressource introuvable, c'est
-32602, plus-32002. - Puis essaie-le dans un vrai client avec les vraies phrases de l'étape 1, et regarde quels outils le modèle a choisis.
Avant la mise en ligne, passe en revue les failles qu'on retrouve sur les serveurs MCP en production.
Quand le faire faire
Un bon développeur de ton équipe peut le construire. Le temps part dans ce que personne dans l'équipe n'a encore rencontré : la conception d'outils pour un modèle sans écran, la chaîne OAuth, et la conformité à une révision encore récente.
Le faire en interne a du sens si le serveur devient un actif central que tu fais évoluer tous les mois. Le faire faire a du sens si ce temps vaut plus sur ton produit, ou si tu préfères ne pas apprendre le protocole à tes frais. Ce qui fait varier le coût dans les deux cas est détaillé dans combien coûte vraiment un serveur MCP.
FAQ
Je peux partir du SDK officiel ?
Oui, et c'est conseillé. Les SDK gèrent la plomberie du protocole. Ce qu'ils ne font pas à ta place : la conception des outils, la gestion de l'état et l'autorisation, là où se trouve l'essentiel du travail.
Un serveur conçu pour 2026-07-28 marche-t-il avec les anciens clients ?
La spec permet aux clients de revenir à l'ancien handshake face à un serveur plus ancien, et certains SDK servent les deux révisions sur un même endpoint. Vérifie ce que ton SDK supporte avant de le promettre.
Faut-il exposer toute mon API ?
Non. Expose les tâches que tes utilisateurs demandent. Un jeu d'outils plus petit et bien décrit est plus facile à utiliser correctement pour le modèle.
Local (stdio) ou distant (HTTP) ?
Le local convient à un outil de développeur qui tourne sur une machine. Dès que le serveur sert tes clients avec leurs propres comptes, il est distant, en Streamable HTTP, avec OAuth.
Tu veux qu'il soit bien fait du premier coup
Je conçois et construis des serveurs MCP de production sur la spec 2026-07-28 : outils pensés pour un agent, cœur sans état, OAuth, déploiement et observabilité. Les offres et leurs prix publiés sont sur la page serveurs MCP. Le premier avis écrit est gratuit.
Un projet en tête ? Parle-moi de ton serveur MCP →
Lectures liées
- Migrer un serveur MCP vers la spec 2026-07-28
- OAuth pour serveur MCP en 2026
- Combien coûte vraiment un serveur MCP
Sources officielles
Un serveur MCP à faire auditer ?
Cinq minutes pour le décrire. Je réponds sous 24 heures ouvrées avec un premier diagnostic écrit et gratuit.
Faire auditer mon serveur MCP
