Guide

Le registre MCP, ou où un agent trouve ses outils

Le registre MCP officiel est un catalogue de descriptions de serveurs : noms inversés vérifiés, publication, sous-registres et ce qu'il ne garantit pas.

L'équipe CodeWorlds13 min de lecture ·

Pratique Vibe coding avec Claude Code dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Le protocole qui décrit comment des outils et des sources de données se rattachent aux modèles de langage s'est assez répandu pour créer un problème secondaire : comment savoir quels serveurs existent et lequel est le bon.

Le registre officiel y répond. C'est un catalogue de descriptions de serveurs, maintenu par l'équipe qui est derrière le protocole lui-même, disponible publiquement et via une interface programmatique. Il a été lancé à l'automne 2025 et compte désormais plus de vingt mille entrées.

Avant d'aller plus loin, une distinction, car sans elle tout le texte induirait en erreur. Le registre stocke des descriptions plutôt que du code, et n'effectue aucune revue de sécurité. Je développe cela dans sa propre section, car c'est la chose la plus importante à comprendre.

Noms inversés et vérification

Le mécanisme de nommage est la partie la mieux pensée ici et il résout un problème qui, dans les catalogues de paquets, est une source d'abus sérieux.

Le nom d'un serveur prend la forme d'un domaine inversé qui désigne la personne ou l'organisation qui publie. Avant de publier quoi que ce soit sous un nom donné, tu dois prouver que tu y as droit.

La preuve se présente différemment selon le type de nom. Un nom qui pointe vers un compte sur un service d'hébergement de dépôts exige de se connecter avec ce compte. Un nom qui pointe vers un domaine exige d'ajouter une entrée dans la configuration de ce domaine, ce que seul son administrateur peut faire.

L'effet est concret. Personne ne publiera un serveur sous un nom évoquant une entreprise connue sans contrôler son domaine. Cela coupe la voie la plus simple vers l'usurpation, familière dans les catalogues de paquets où un nom prêtant à confusion avec une bibliothèque populaire est une attaque efficace.

Comprends cependant la portée de cette garantie. La vérification dit que l'éditeur contrôle un nom donné, et ne dit rien de ce que fait le serveur. Ce sont deux choses différentes, et les confondre est l'erreur la plus courante quand on utilise des catalogues de ce genre.

Publier ton propre serveur

Le processus est plus court que ne le suggère le nombre de concepts et se réduit à quatre étapes.

Tu commences par un fichier de description, qui indique un nom correspondant à ton domaine ou compte vérifié, une description, la façon de le lancer et les réglages requis.

JSON
{
  "name": "com.mycompany/orders-server",
  "description": "Access to the orders system: status and history lookups.",
  "version": "1.0.0",
  "packages": [
    {
      "registryType": "npm",
      "identifier": "@mycompany/mcp-orders",
      "version": "1.0.0",
      "transport": {
        "type": "stdio"
      }
    }
  ]
}

La deuxième étape est un marqueur qui confirme que le paquet du catalogue de paquets t'appartient. Sans lui, quelqu'un pourrait faire pointer sa description vers ton paquet et capter ainsi la confiance attachée à ton nom.

La troisième est la connexion avec l'outil en ligne de commande, où la méthode de connexion dépend du type de nom. La quatrième est la publication elle-même et la vérification du résultat via l'interface du registre.

Bash
mcp-publisher login dns --domain mycompany.com --private-key "$PRIVATE_KEY"
mcp-publisher publish

Deux choses méritent réflexion avant de publier. La première est la description : elle parvient aux clients, et un modèle ou une personne décide à partir d'elle s'il faut recourir à ce serveur. Une phrase qui dit clairement ce qu'il sert et ce qu'il ne fait pas vaut plus qu'une liste de fonctionnalités.

La seconde est le versionnage. Le registre stocke des versions, donc changer le comportement d'un serveur sans augmenter la version signifie que les utilisateurs obtiennent autre chose que ce qu'ils ont vérifié.

Ce que le registre ne fournit pas

C'est la section la plus importante de tout le texte et la chose que les documents sur le protocole énoncent moins souvent qu'ils ne le devraient.

Le registre stocke les descriptions des serveurs, pas leur code. En installant un serveur, tu le récupères depuis le catalogue de paquets ou l'image de conteneur nommés dans la description, et le registre dit seulement où il se trouve.

Il n'y a aucune revue de sécurité ici. Personne ne lit le code avant qu'une entrée n'entre dans le catalogue, donc une inscription ne signifie pas qu'un serveur est sûr, bien écrit ou qu'il fait ce que sa description promet.

La conséquence est plus grave qu'avec une bibliothèque ordinaire. Un serveur de cette classe reçoit l'accès à des outils, à des données et souvent à des clés, et le modèle l'invoque de lui-même, sans ta confirmation à chaque opération. Un serveur malveillant, ou simplement défectueux, a donc une large portée.

Trois habitudes limitent ce risque et méritent d'être adoptées dès le départ. La première est de vérifier la source : qui publie, si le code est public et si le dépôt a l'air maintenu. La deuxième est de limiter les permissions : un serveur qui a besoin d'accéder à un système ne devrait pas recevoir une clé couvrant tous les systèmes. La troisième est d'approuver les opérations qui modifient un état plutôt que de laisser le modèle les effectuer seul.

Souviens-toi séparément du contenu qui revient d'un serveur. La description d'un outil et le résultat d'un appel entrent dans le contexte du modèle, donc un serveur peut influencer ce que le modèle fait ensuite. C'est un vecteur qu'une bibliothèque ordinaire n'a pas.

Cela mérite d'être développé, car la différence est fondamentale. Une bibliothèque ordinaire exécute le code que tu lui as demandé et rien de plus. Un serveur de cette classe renvoie du texte qui entre directement dans le raisonnement du modèle, et le modèle traite ce texte comme de l'information plutôt que comme des données à ignorer. Le résultat d'un appel qui contient une phrase formulée comme une instruction peut donc influencer les étapes suivantes, y compris l'appel d'un autre outil.

Cela vaut aussi pour des serveurs écrits de bonne foi, s'ils récupèrent du contenu de l'extérieur. Un serveur qui lit des tickets de clients ou des pages web transmet au modèle un contenu que personne ne contrôle, donc traiter tout ce qui revient d'un outil comme des données plutôt que comme des instructions est une règle à adopter quel que soit le degré de confiance que tu accordes au serveur lui-même.

Sous-registres et catalogues d'entreprise

Le registre a été conçu comme une couche de base sur laquelle d'autres peuvent construire, et cet agencement mérite d'être connu pour les déploiements en entreprise.

Un sous-registre tire ses données du registre principal et ajoute ses propres règles. Il peut écarter les entrées qui ne répondent pas à des critères choisis, exécuter une analyse des paquets ou n'admettre que les serveurs approuvés par une équipe de sécurité.

Pour une organisation, c'est la bonne voie. Plutôt que de laisser n'importe qui rattacher n'importe quel serveur d'un catalogue public, tu maintiens ta propre liste d'entrées admises, et les utilisateurs ne voient que celle-ci.

Les catalogues tenus par des éditeurs d'outils et de plateformes jouent un rôle similaire. Ils sont souvent plus pratiques à utiliser et plus étroits, car ils contiennent des entrées vérifiées ou construites par cet éditeur.

Comprends la relation entre eux. Le registre principal est la source de données, et les autres catalogues sont des surcouches avec des règles différentes. Cela signifie qu'une même entrée peut avoir un aspect différent dans chacun, et l'absence d'une entrée dans un catalogue d'entreprise ne signifie pas qu'elle n'existe pas.

Comment choisir un serveur dans le catalogue

Puisque le catalogue contient des dizaines de milliers d'entrées et qu'aucune n'a passé de revue, le choix demande une méthode à toi. Cinq choses à vérifier en quelques minutes.

La première est l'éditeur. Le nom pointe vers un domaine ou un compte vérifié, donc tu vois immédiatement si le serveur vient du créateur du service lui-même ou d'un tiers. Cela ne tranche pas la qualité, mais un serveur pour un système de tickets publié par le créateur de ce système est une autre proposition que le même serveur venant d'un compte inconnu. Venir du créateur n'implique pas pour autant des capacités plus larges : le serveur Google Drive officiel est une préversion développeur précoce qui lit des fichiers et en crée de nouveaux, mais ne met pas à jour un document existant, ne déplace pas un fichier et ne change pas les permissions.

La deuxième est la disponibilité du code. L'écrasante majorité des entrées ont un dépôt public, et y jeter un œil est rentable, ne serait-ce que pour voir combien de fichiers il contient et quand quelque chose y a changé pour la dernière fois.

La troisième est l'étendue des permissions que le serveur demande. La description liste les réglages requis, donc un serveur qui demande une clé avec un accès complet au compte pour lire une liste de tâches est un signal d'alarme quel que soit l'éditeur.

La quatrième est la liste des outils qu'il expose. Un serveur qui offre trois opérations de lecture est facile à évaluer, tandis qu'un serveur avec quarante opérations, dont la suppression et l'envoi, mérite beaucoup plus d'attention avant d'être rattaché. Le nombre seul ne tranche pas, car certains serveurs te permettent de le réduire : le serveur GitHub contient des dizaines d'outils mais active cinq jeux d'outils par défaut et permet d'aller plus bas avec une variable d'environnement. Vérifie donc non seulement combien d'outils un serveur possède, mais combien il en active sans qu'on le lui demande.

La cinquième est l'actualité. Le protocole a changé ces deux dernières années, donc un serveur inchangé depuis un an peut fonctionner correctement ou ne pas prendre en charge des choses que tu attends désormais.

Pour les serveurs qui touchent des données d'entreprise, ajoute une sixième étape : l'exécuter en isolation et vérifier où il envoie réellement du trafic. C'est dix minutes de travail qui répondent à une question à laquelle la description ne répond pas du tout.

Le registre et les clients

Le catalogue seul apporte peu tant que l'outil que tu utilises au quotidien ne sait pas travailler avec lui, donc cette couche mérite d'être comprise.

Certains clients interrogent directement le registre et te laissent ajouter un serveur depuis l'interface, sans écrire la configuration à la main. D'autres utilisent leurs propres catalogues, construits sur les mêmes données et complétés par des entrées vérifiées par l'éditeur.

Dans les deux cas, le résultat final est une entrée dans la configuration de ton outil, qui indique comment lancer le serveur et quels réglages lui passer. Le catalogue raccourcit le chemin vers cette entrée plutôt que de la remplacer.

Sache où se trouve cette entrée et ce qu'elle contient, car les clés et les chemins y atterrissent. En travail d'équipe, ce fichier est souvent partagé via un dépôt, donc les secrets devraient arriver par des variables d'environnement plutôt que d'être écrits directement.

Avec des outils comme Cursor et les assistants qui travaillent sur le code, la configuration est souvent à deux niveaux : un pour toute la machine et un pour le projet. Ce dernier est généralement le bon endroit pour les serveurs liés à un dépôt précis, car il disparaît avec lui et ne traîne pas en arrière-plan pendant que tu travailles sur autre chose.

Le registre face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
Le registre officielVérification des noms, couverture complète, interface programmatiqueAucune revue de sécuritéTrouver un serveur et publier le tien
Un sous-registre d'entrepriseTes propres règles d'admission, analyseQuelqu'un doit le maintenirUne organisation avec des exigences de sécurité
Un catalogue d'éditeurEntrées vérifiées, installation pratiqueCouverture plus étroite, lié à un outilTravailler dans l'écosystème de cet éditeur
Ton propre serveurContrôle total de ce qu'il faitTu l'écris et le maintiensAccès à un système interne

La dernière ligne est souvent oubliée et c'est généralement la bonne réponse pour les systèmes d'entreprise. Un serveur qui expose ta base de commandes doit de toute façon être écrit par toi, car personne d'autre n'en connaît la structure, et les outils pour cela sont traités dans les textes sur la boîte à outils du protocole et sur FastMCP.

Erreurs fréquentes

La première est de traiter une inscription au registre comme une confirmation de sécurité. Le registre stocke des descriptions et vérifie des noms ; il n'effectue aucune revue de code.

La deuxième est de rattacher un serveur avec une clé qui couvre plus de systèmes que nécessaire. Restreins les permissions à un seul but.

La troisième est de laisser le modèle effectuer seul des opérations qui modifient un état. Envoyer un message ou modifier des données devrait exiger une confirmation.

La quatrième est de publier sans le marqueur qui confirme la propriété du paquet. Sans lui, une description peut pointer vers le paquet de quelqu'un d'autre, et la confiance dans ton nom est utilisée par un tiers.

La cinquième est de changer le comportement d'un serveur sans augmenter la version. Les utilisateurs obtiennent alors autre chose que ce qu'ils ont vérifié en le rattachant.

La sixième est une description qui liste des fonctionnalités plutôt que de dire quand utiliser le serveur. Les modèles choisissent les outils à partir des descriptions, donc elle gouverne la précision avec laquelle ils sont appelés.

FAQ

Une inscription au registre signifie-t-elle qu'un serveur est sûr ?

Non. Le registre stocke les descriptions des serveurs et vérifie le droit à un nom ; il n'effectue aucune revue de code. La vérification dit que l'éditeur contrôle un domaine ou un compte donné, et rien de plus.

Comment fonctionne la vérification des noms ?

Un nom prend la forme d'un domaine inversé qui désigne l'éditeur. Un nom fondé sur un compte d'un service d'hébergement de dépôts exige de se connecter avec ce compte, et un nom fondé sur un domaine exige d'ajouter une entrée dans la configuration de ce domaine, ce que seul son administrateur peut faire.

Que faut-il pour publier un serveur ?

Préparer un fichier de description avec un nom, une description et la façon de le lancer ; ajouter un marqueur qui confirme la propriété du paquet ; se connecter avec l'outil en ligne de commande de la manière qui correspond au type de ton nom ; et publier. L'ensemble prend un quart d'heure avec un serveur terminé.

Qu'est-ce qu'un sous-registre ?

Un catalogue construit sur les données du registre principal, avec ses propres règles d'admission des entrées. Une organisation peut ainsi n'exposer que les serveurs approuvés par une équipe de sécurité plutôt que de permettre à n'importe lesquels d'être rattachés.

Vaut-il mieux écrire son propre serveur que d'en trouver un prêt ?

Pour accéder à un système interne, généralement oui, car personne d'autre n'en connaît la structure. Pour les intégrations courantes, un serveur prêt fait gagner du travail, à condition de vérifier la source et de limiter les permissions.

Le registre se trouve à son adresse officielle, et sa description sur le site du protocole.

À lire aussi