Comment utiliser le serveur MCP GitHub

```html

Introduction à GitHub MCP et son objectif

GitHub MCP Server représente une avancée passionnante dans les outils de développement, offrant une intégration transparente entre l'intelligence artificielle et l'écosystème robuste de GitHub. Model Context Protocol (MCP) est une méthode standardisée permettant aux Large Language Models (LLMs) d'interagir avec des outils et des sources de données externes. Le serveur MCP officiel de GitHub comble cette lacune spécifiquement pour les référentiels GitHub, permettant aux assistants d'IA d'accéder, de rechercher et d'interagir avec les données GitHub via une interface structurée.

Dans ce tutoriel, nous allons explorer comment configurer et utiliser efficacement GitHub MCP Server pour améliorer votre flux de travail de développement. Que vous cherchiez à automatiser les tâches GitHub de routine, à obtenir des informations plus approfondies sur les référentiels ou à créer des outils basés sur l'IA qui interagissent avec GitHub, ce guide vous fournira les connaissances nécessaires pour commencer.

💡

Avant de vous plonger dans la configuration de Github MCP Server, consultez Apidog, un outil puissant pour la conception, le test et la documentation des API. Apidog vous permet d'intégrer de manière transparente vos API, améliorant ainsi votre flux de travail avec des modèles structurés et une collaboration facile. Si vous cherchez à booster votre automatisation et votre gestion des API, Apidog est un excellent outil complémentaire à utiliser avec Zapier MCP.

button

Comprendre les bases de GitHub MCP Server

GitHub MCP Server implémente le Model Context Protocol pour fournir une interface standardisée entre les modèles d'IA et les API de GitHub. Plutôt que d'avoir des outils d'IA qui analysent le code HTML brut ou interagissent avec GitHub de manière imprévisible, le serveur MCP fournit des outils et des ressources structurés que les assistants d'IA peuvent utiliser de manière fiable.

Voici ce que permet GitHub MCP Server :

Exécution automatisée du flux de travail GitHub
Extraction et analyse des données du référentiel
Interaction avec les problèmes, les demandes de tirage et le code
Intégration avec les assistants de codage d'IA comme GitHub Copilot

Lorsqu'un assistant d'IA a besoin d'informations de GitHub, il envoie une requête au serveur MCP, qui traite ensuite cette requête et renvoie des données structurées. Cela crée une expérience plus fiable et cohérente lors de l'utilisation d'outils d'IA qui doivent accéder aux ressources GitHub.

Configuration de votre environnement GitHub MCP Server

Avant de pouvoir commencer à utiliser GitHub MCP Server, vous devrez configurer votre environnement. La condition préalable principale est Docker, qui est requis pour exécuter le serveur dans un conteneur. Vous aurez également besoin d'un GitHub Personal Access Token (PAT) pour vous authentifier auprès des API de GitHub.

Création d'un GitHub MCP Personal Access Token

Accédez aux paramètres de votre compte GitHub
Accédez à Paramètres du développeur > Personal access tokens > Fine-grained tokens
Cliquez sur "Generate new token"
Donnez un nom descriptif à votre jeton
Définissez la date d'expiration
Sélectionnez les référentiels auxquels vous souhaitez que le jeton accède
Choisissez les autorisations nécessaires en fonction des outils GitHub MCP que vous utiliserez
Cliquez sur "Generate token" et copiez-le dans un endroit sûr

N'oubliez pas de sécuriser votre jeton, car il donne accès à votre compte GitHub. Les autorisations que vous accordez doivent être limitées à ce qui est requis pour votre cas d'utilisation spécifique.

Installation de GitHub MCP Server pour différents IDE

Configuration de GitHub MCP pour VS Code

VS Code offre l'un des moyens les plus simples de s'intégrer à GitHub MCP Server. Voici comment le configurer :

Ouvrez VS Code
Appuyez sur Ctrl + Maj + P (ou Cmd + Maj + P sur macOS)
Tapez "Preferences: Open User Settings (JSON)"
Ajoutez la configuration JSON suivante à votre fichier de paramètres :

{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "github_token",
        "description": "GitHub Personal Access Token",
        "password": true
      }
    ],
    "servers": {
      "github": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-e",
          "GITHUB_PERSONAL_ACCESS_TOKEN",
          "ghcr.io/github/github-mcp-server"
        ],
        "env": {
          "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
        }
      }
    }
  }
}

Vous pouvez également créer un fichier .vscode/mcp.json dans votre espace de travail pour partager cette configuration avec d'autres. Dans ce cas, vous n'avez pas besoin de la clé de niveau supérieur "mcp".

Implémentation de GitHub MCP pour Claude Desktop

Claude Desktop prend également en charge les serveurs MCP. Voici comment le configurer :

Créez la configuration suivante :

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}

Remplacez <YOUR_TOKEN> par votre GitHub Personal Access Token réel

GitHub MCP Server pour les utilisateurs d'entreprise

Si vous utilisez GitHub Enterprise Server au lieu de github.com, vous devrez spécifier le nom d'hôte de votre instance Enterprise. Cela peut être fait en utilisant l'indicateur --gh-host lors de l'exécution du serveur ou en définissant la variable d'environnement GH_HOST.

Par exemple, dans votre configuration VS Code, vous modifierez le tableau "args" pour inclure :

"args": [
  "run",
  "-i",
  "--rm",
  "-e",
  "GITHUB_PERSONAL_ACCESS_TOKEN",
  "-e",
  "GH_HOST=github.mycompany.com",
  "ghcr.io/github/github-mcp-server"
]

Cela garantit que le serveur MCP communique avec votre instance GitHub Enterprise plutôt qu'avec le github.com public.

Explorer les outils GitHub MCP Server

GitHub MCP Server fournit un ensemble complet d'outils classés par fonctionnalité. Voici quelques-unes des principales catégories d'outils :

Aperçu des outils utilisateur GitHub MCP

Les outils utilisateur permettent aux assistants d'IA de récupérer des informations sur l'utilisateur GitHub authentifié. L'outil principal est :

get_me : Récupère les détails sur l'utilisateur actuellement authentifié sans nécessiter de paramètres.

Outils de gestion des problèmes GitHub MCP

Les outils de problèmes permettent aux assistants d'IA d'interagir avec les problèmes GitHub :

get_issue : Récupère les détails du problème en spécifiant le propriétaire, le référentiel et le numéro du problème
create_issue : Crée de nouveaux problèmes avec un titre, un corps, des personnes affectées et des étiquettes personnalisables
add_issue_comment : Ajoute des commentaires aux problèmes existants
list_issues : Liste et filtre les problèmes de référentiel avec divers critères
update_issue : Met à jour les problèmes existants
search_issues : Recherche des problèmes dans GitHub

Gestion des demandes de tirage GitHub MCP

Les outils de demande de tirage permettent l'interaction avec les demandes de tirage GitHub :

get_pull_request : Récupère les détails de la demande de tirage
list_pull_requests : Liste et filtre les demandes de tirage du référentiel
merge_pull_request : Fusionne les demandes de tirage ouvertes
get_pull_request_files : Récupère les fichiers modifiés dans une demande de tirage
create_pull_request : Crée de nouvelles demandes de tirage
update_pull_request_branch : Met à jour une branche de demande de tirage avec les dernières modifications de la base

Exploration des outils de référentiel GitHub MCP

Les outils de référentiel permettent d'accéder au contenu du référentiel et à sa gestion :

create_or_update_file : Modifie des fichiers uniques dans les référentiels
push_files : Valide plusieurs modifications de fichiers à la fois
search_repositories : Recherche des référentiels dans GitHub
create_repository : Crée de nouveaux référentiels
get_file_contents : Récupère le contenu des fichiers à partir des référentiels
create_branch : Crée de nouvelles branches dans les référentiels

Ressources GitHub MCP pour le contenu du référentiel

En plus des outils, GitHub MCP Server fournit des modèles de ressources qui permettent un accès direct au contenu du référentiel. Ces modèles suivent des modèles d'URL spécifiques :

Contenu de base du référentiel : repo://{owner}/{repo}/contents{/path*}
Contenu spécifique à une branche : repo://{owner}/{repo}/refs/heads/{branch}/contents{/path*}
Contenu spécifique à une validation : repo://{owner}/{repo}/sha/{sha}/contents{/path*}
Contenu spécifique à une balise : repo://{owner}/{repo}/refs/tags/{tag}/contents{/path*}
Contenu spécifique à la demande de tirage : repo://{owner}/{repo}/refs/pull/{prNumber}/head/contents{/path*}

Ces ressources permettent aux assistants d'IA d'accéder directement à des versions spécifiques du contenu du référentiel.

Personnalisation des descriptions du serveur GitHub MCP

Vous pouvez personnaliser les descriptions des outils GitHub MCP pour mieux correspondre à votre flux de travail ou à vos préférences linguistiques. Il existe deux approches principales :

Utilisation d'un fichier de configuration :
Créez un fichier github-mcp-server-config.json dans le même répertoire que le binaire avec des descriptions remplacées :

{
  "TOOL_ADD_ISSUE_COMMENT_DESCRIPTION": "une autre description",
  "TOOL_CREATE_BRANCH_DESCRIPTION": "Créez une nouvelle branche dans un référentiel GitHub"
}

Utilisation de variables d'environnement :
Définissez des variables d'environnement avec le préfixe GITHUB_MCP_ :

export GITHUB_MCP_TOOL_ADD_ISSUE_COMMENT_DESCRIPTION="une autre description"

Pour exporter les traductions actuelles comme point de départ, exécutez :

./github-mcp-server --export-translations

Construction de GitHub MCP Server à partir de la source

Si vous préférez ne pas utiliser Docker, vous pouvez créer GitHub MCP Server à partir de la source :

Clonez le référentiel : git clone https://github.com/github/github-mcp-server.git
Accédez au répertoire du référentiel : cd github-mcp-server
Utilisez Go pour créer le binaire dans le répertoire cmd/github-mcp-server
Exécutez le serveur en utilisant github-mcp-server stdio avec la variable d'environnement GITHUB_PERSONAL_ACCESS_TOKEN définie

Conclusion : Maximiser GitHub MCP pour le développement

GitHub MCP Server représente une avancée significative dans l'intégration des outils d'IA avec l'écosystème de GitHub. En fournissant une interface standardisée via le Model Context Protocol, il permet aux assistants d'IA d'interagir avec les données GitHub de manière structurée et prévisible.

Tout au long de ce tutoriel, nous avons vu comment configurer GitHub MCP Server, exploré ses différents outils et ressources, et appris à le personnaliser pour répondre à des besoins spécifiques. En tirant parti de GitHub MCP Server dans votre flux de travail de développement, vous pouvez améliorer la productivité, rationaliser les interactions GitHub et débloquer de nouvelles possibilités pour les outils de développement basés sur l'IA.

Alors que l'IA continue de transformer le développement logiciel, des outils comme GitHub MCP Server joueront un rôle de plus en plus important dans la création d'une intégration transparente entre les assistants d'IA et les plateformes de développement. En maîtrisant GitHub MCP Server dès maintenant, vous vous positionnez à l'avant-garde de cette intersection passionnante de l'IA et du développement logiciel.

```