Serveurs, registres et listes autorisées du protocole MCP (Model Context Protocol)

Les agents deviennent plus utiles lorsqu’ils peuvent aller au-delà du référentiel et interagir avec d’autres outils, systèmes et services. Le protocole de contexte de modèle ou MCP permet de donner aux agents un moyen cohérent de découvrir et d’utiliser des fonctionnalités externes.

Dans GitHub environnements, MCP ne consiste pas seulement à se connecter à des outils. Il s’agit également de contrôler la façon dont ces outils sont introduits, configurés et régis. Cela inclut la configuration des serveurs MCP, l’utilisation d’un registre pour découvrir les serveurs disponibles et l’application des listes d’autorisation afin que seuls les serveurs approuvés puissent être utilisés.

Dans cette unité, vous allez apprendre :

• Qu’est-ce que MCP ?
• Fonctionnement des serveurs MCP
• Comment les registres facilitent la découverte du serveur
• Comment les listes d'autorisation contrôlent quels serveurs sont utilisables
• Comment MCP s’intègre dans les flux de travail agentiques et les outils d’agent sur GitHub

Qu’est-ce que MCP ?

Le protocole de contexte de modèle est un moyen standard pour les clients IA de se connecter aux outils et services via des serveurs MCP. Au lieu de créer une intégration ponctuelle pour chaque outil, un client compatible MCP peut se connecter à un serveur qui expose des outils dans un format structuré.

Cela donne aux agents un modèle cohérent pour :

• Découverte des outils disponibles
• Envoi de requêtes structurées
• Réception de résultats structurés
• Réutilisation du même modèle d’interaction entre différents systèmes

Qu’est-ce qu’un serveur MCP ?

Un serveur MCP est le composant qui expose des outils à un client IA.

Le serveur se trouve entre le client et le système sous-jacent. Il présente les outils disponibles dans un format que le client comprend, accepte les demandes, puis effectue l’action réelle sur le service connecté.

Selon la configuration, un serveur MCP peut :

• Exécuter localement sur une machine de développement
• Exécuter à distance en tant que service hébergé
• Se connecter aux ressources locales
• Pont vers des API et plateformes distantes

Le serveur MCP GitHub est un exemple. Il connecte des clients IA à des fonctionnalités GitHub telles que les dépôts, les problèmes et les pull requests.

Serveurs MCP locaux et distants

Les serveurs MCP peuvent être configurés localement ou à distance.

Un serveur MCP local s’exécute sur votre ordinateur. Cela est utile lorsque vous souhaitez contrôler plus étroitement la configuration, l’accès aux ressources locales ou une configuration personnalisée.

Un serveur MCP distant est hébergé ailleurs et accessible sur le réseau. Cela réduit le travail d’installation et facilite l’utilisation du même serveur dans les environnements.

Dans les IDE pris en charge, le serveur MCP GitHub peut être configuré à distance ou localement, avec l’option distante positionnée comme configuration recommandée pour la plupart des utilisateurs. GitHub Enterprise Server prend en charge la configuration du serveur MCP local, tandis que GitHub Enterprise Cloud avec résidence des données prend en charge les options locales et distantes.

Ajouter un serveur MCP distant en tant qu’outil à un agent (VS Code)

Les serveurs MCP sont ajoutés directement via l’interface Copilot Chat et deviennent des outils que l’agent peut utiliser.

Étapes:

1. Cliquez sur l’icône GitHub Copilot en haut de l’éditeur
2. Ouvrez Copilot Chat et basculez en mode Agent
3. Cliquez sur l’icône Outils dans le panneau de conversation
4. Cliquez sur Configurer les outils en haut à droite du panneau Copilot Chat.
5. Cliquez sur Ajouter un serveur MCP
6. Dans la boîte de dialogue d’installation :
   1. Sélectionnez HTTP comme type de serveur
   2. Entrez l’URL du serveur (par exemple, pour GitHub serveur MCP) :
   3. https://api.githubcopilot.com/mcp/
   4. Appuyez sur Entrée
   5. Un nom de serveur est généré automatiquement
   6. Choisissez l’étendue ; espace de travail actuel ou tous les espaces de travail
   7. Cliquez sur Authentifier et connectez-vous à GitHub
   8. Enregistrer la configuration

Le serveur MCP est désormais disponible en tant qu’outil à l’intérieur de l’agent, et l’agent peut appeler ses fonctionnalités pendant les tâches.

Ajouter un serveur MCP local en tant qu’outil à un agent

Un serveur MCP local s’exécute sur votre ordinateur et permet à votre agent d’interagir avec les outils, fichiers ou services personnalisés locaux. Le processus d’installation dans VS Code est identique à l’ajout d’un serveur MCP.

La seule différence est le serveur auquel vous vous connectez. Au lieu d’utiliser une URL hébergée comme le serveur MCP GitHub, vous fournissez un point de terminaison local, par exemple :

http://localhost:3000

Serveurs MCP locaux :

• Exécuter sur votre ordinateur
• Peut accéder aux ressources locales et aux flux de travail personnalisés
• En règle générale, ne nécessite pas d’authentification externe

Qu’est-ce qu’un registre MCP ?

Un registre MCP est un catalogue de serveurs MCP.

Au lieu de demander à chaque développeur de configurer manuellement chaque serveur, un registre fournit un emplacement central où les clients compatibles peuvent découvrir quels serveurs sont disponibles et comment les utiliser.

Cela simplifie la configuration de deux façons :

• Cela facilite la découverte de serveurs
• Il normalise la façon dont les serveurs sont décrits et distribués

Par défaut, les expériences IDE prises en charge peuvent utiliser le registre MCP GitHub, et les développeurs peuvent également basculer vers un registre personnalisé si nécessaire.

Comment les registres aident à la configuration

Les registres réduisent les frictions, car ils suppriment une grande partie du travail manuel impliqué dans l’ajout de serveurs.

Au lieu de modifier des fichiers de configuration manuellement pour chaque serveur, un développeur peut parcourir ou rechercher un registre, sélectionner un serveur, l’installer et le faire confiance pour une utilisation dans son environnement.

Cela rend les registres particulièrement utiles quand :

• Teams souhaitent une expérience de configuration plus simple
• Les organisations souhaitent un ensemble standard de serveurs approuvés
• Les développeurs ont besoin d’une liste organisée au lieu de la découverte non managée

GitHub prend également en charge les registres MCP personnalisés pour les organisations et les entreprises, tant que le registre suit la spécification et la structure de point de terminaison du registre MCP requises.

Configurer des registres MCP

Pour utiliser un registre MCP personnalisé dans GitHub, une organisation ou une entreprise doit créer ou héberger un registre auquel GitHub Copilot peut accéder.

Étapes:

1. Créez ou hébergez un registre MCP. Vous pouvez effectuer cette opération de trois manières :
   • Forkez et auto-hébergez le Registre MCP open source
   • Exécuter le registre open source localement à l’aide de Docker
   • Générer et publier votre propre implémentation de Registre personnalisé
2. Vérifiez que le Registre répond aux exigences GitHub. Le Registre doit :
   • Suivez la spécification du registre MCP v0.1
   • Exposez les points de terminaison HTTPS requis :
     • GET /v0.1/servers
     • GET /v0.1/serveurs/{nomServeur}/versions/derniere
     • GET /v0.1/servers/{serverName}/versions/{version}
   • Incluez les en-têtes CORS requis afin que les Copilot puissent y accéder :
     • Access-Control-Allow-Origin : *
     • Méthodes d’accès à la maîtrise de la permission : GET, OPTIONS
     • En-têtes d’accès au contrôle : Authorization, Content-Type
3. (Facultatif) Incluez les serveurs MCP locaux :
   • Si vous souhaitez que les développeurs utilisent des serveurs MCP locaux sous des stratégies restreintes, ces serveurs doivent être répertoriés dans le Registre
   • Les ID de serveur doivent correspondre exactement
4. (Alternative) Utiliser le Centre d’API Azure
   • Azure Centre d’API peut agir en tant que registre MCP géré
   • Activer l’accès anonyme afin que Copilot puisse extraire le Registre
   • Copier l’URL du point de terminaison du Centre d’API pour une utilisation ultérieure
5. Fournissez l’URL du Registre à votre organisation ou à votre entreprise
   • Cette URL sera utilisée dans les paramètres de stratégie Copilot
   • Il rend le registre disponible dans votre entreprise

Une fois configuré, le Registre devient la source de vérité pour les serveurs MCP disponibles, ce qui permet aux développeurs de découvrir et d’utiliser des outils approuvés de manière cohérente.

Qu’est-ce qu’une liste d’acceptation ?

Une liste d'autorisation est une politique qui contrôle quels serveurs MCP sont autorisés.

Cela est important, car MCP développe ce qu’un agent peut accéder. Sans garde-fous, un agent peut être connecté à des outils qui exposent des systèmes sensibles ou autorisent des actions dangereuses.

Une liste d'autorisation résout cela en limitant l'utilisation du serveur aux entrées approuvées. Dans la pratique, cela signifie qu’une organisation ou une entreprise peut décider si les développeurs peuvent :

• Utiliser systématiquement les serveurs MCP
• Utiliser n’importe quel serveur MCP
• Utiliser uniquement des serveurs MCP spécifiques définis dans un registre

GitHub prend en charge l’application des listes de permis MCP au niveau de l’organisation et de l’entreprise, liée au siège Copilot qui régit l’utilisateur.

Fonctionnement des serveurs MCP, des registres et des listes d’autorisation

Ces trois concepts résolvent différentes parties du même problème :

• Le serveur MCP expose les outils
• Le Registre rend les serveurs détectables et fiables
• Liste d'autorisation détermine les serveurs autorisés

Ensemble, ils créent un modèle à la fois flexible et contrôlé.

Un développeur ou une équipe peut découvrir des serveurs utiles par le biais d’un registre, tandis que l’organisation conserve toujours la gouvernance sur les serveurs autorisés en pratique.

Configurer des listes d’autorisation MCP

Les listes d'autorisation MCP contrôlent quels serveurs MCP les développeurs sont autorisés à utiliser. Cela est configuré au niveau de l’organisation ou de l’entreprise dans GitHub.

Étapes (entreprise) :

1. Accédez à votre entreprise sur GitHub
2. En haut de la page, cliquez sur Contrôles IA
3. Dans la barre latérale, cliquez sur MCP
4. Vérifiez que les serveurs MCP dans Copilot sont activés partout
5. Dans la section URL du Registre MCP :
   • Entrez l’URL de votre registre
   • Sélectionnez Enregistrer
   • Si vous utilisez Azure Centre d’API, entrez l’URL de base uniquement (n’incluez pas /v0.1/servers)
6. Dans Restreindre l’accès MCP aux serveurs de Registre, choisissez :
   • Autoriser toutes les → aucune restriction, n’importe quel serveur MCP peut être utilisé
   • Seuls les serveurs du registre sont autorisés.

Étapes (organisation) :

1. Dans GitHub, cliquez sur votre image de profil et sélectionnez Organisations
2. Sélectionner votre organisation
3. Cliquez sur Paramètres
4. Dans la barre latérale, cliquez sur Copilot, puis stratégies
5. Dans la section Fonctionnalités :
   • Vérifier que les serveurs MCP dans Copilot sont activés
6. (Facultatif) Dans l’URL du Registre MCP :
   • Entrez votre URL de Registre
   • Sélectionnez Enregistrer
   • Si vous utilisez Azure Centre d’API, entrez l’URL de base uniquement
7. Dans Restreindre l’accès MCP aux serveurs de Registre, choisissez :
   • Autoriser tout
   • Registre uniquement

Les listes d’autorisation garantissent que les agents utilisent uniquement les serveurs MCP approuvés, ce qui permet aux organisations de contrôler les outils auxquels vous pouvez accéder.

Flux de travail pratique GitHub

Un flux MCP réaliste centré sur GitHub ressemble à ceci :

1. Une organisation configure un registre MCP
2. L'organisation établit une stratégie de liste d'autorisation pour les serveurs approuvés.
3. Un développeur ouvre un IDE ou un client compatible MCP
4. Le client découvre les serveurs approuvés à partir du Registre
5. Le développeur active un serveur tel que le serveur GitHub MCP
6. L’agent utilise des outils de ce serveur pendant une tâche

Dans ce modèle, les agents obtiennent de nouvelles fonctionnalités sans renoncer à la sécurité et à la gouvernance.

Pourquoi cela importe pour l'exécution de l’agent

MCP donne aux agents l’accès à plus d’outils, mais plus d’outils signifient également plus de responsabilité.

Pour utiliser MCP en toute sécurité à grande échelle, vous avez besoin de plus que de connectivité. Tu as besoin de:

• Serveur qui expose correctement les outils
• Registre qui rend les serveurs approuvés détectables
• Une liste de permis qui limite ce qui peut être utilisé

Cette combinaison rend MCP pratique pour les équipes réelles. Il permet aux agents de s’étendre au-delà de GitHub tout en conservant la configuration gérable et l’accès contrôlé.

À retenir

MCP étend les fonctionnalités de l’agent en les connectant à des outils via des serveurs MCP. Les registres simplifient la façon dont ces serveurs sont découverts et configurés. Les listes d’autorisation fournissent les garde-fous qui déterminent les serveurs autorisés.

Ensemble, ces éléments rendent MCP évolutifs et régis.

Ensuite, vous allez apprendre à définir des environnements d’exécution et des limites d’autorisation afin que les agents puissent utiliser GitHub et les outils connectés à MCP en toute sécurité.