Comment déployer GitHub MCP Server : guide Windows, Linux et macOS

Dans Cursor, vous voulez que l'Agent consulte les Issues, ouvre des PR et lise les fichiers du dépôt — mais vous bloquez sur la question « quel GitHub MCP Server installer » : l'ancien paquet npm est déprécié depuis longtemps, et chaque tutoriel en ligne raconte une histoire différente. Cet article s'appuie sur le dépôt officiel github/github-mcp-server (dernière version v1.7.0 au 31 juillet 2026) et détaille les quatre chemins — hébergement distant, Docker local, binaire précompilé et compilation depuis les sources — à reproduire tel quel sur Windows, Linux et macOS.

Ce que couvre ce guide : création du PAT, chemins de configuration par plateforme, exemples d'intégration Cursor / Claude Desktop / VS Code Copilot, et checklist de validation en sept étapes. Les implémentations MCP non officielles de tiers ne sont pas abordées.

Réponse rapide : comment choisir entre les quatre modes

Consultez d'abord le tableau ci-dessous pour déterminer votre chemin en 30 secondes ; la plupart des développeurs individuels commencent par le mode 1 (hébergement distant), tandis que les équipes en intranet ou ayant besoin d'isoler les identifiants optent pour le mode 2 (Docker).

Avant le déploiement : PAT, client hôte et chemins de config

1. Créer un GitHub Personal Access Token

Rendez-vous sur GitHub → Settings → Personal access tokens pour créer un PAT Fine-grained ou Classic. Scopes couramment utilisés :

• repo — lecture/écriture du contenu des dépôts, branches et commits
• read:org — lecture des informations d'organisation et d'équipe
• Ajoutez read:project, workflow, etc. selon les actions que l'Agent devra effectuer

2. Client hôte MCP et chemins de configuration

Chaque client a son propre fichier de configuration. Le tableau ci-dessous liste les chemins les plus courants par système d'exploitation — après modification du JSON, un redémarrage complet du client est généralement nécessaire. Attention : certains éditeurs reformatent automatiquement le JSON à l'enregistrement ; si le PAT est dans le champ env, vérifiez que guillemets et virgules restent valides après formatage.

Si votre équipe a besoin d'un environnement Mac isolé pour les tests MCP (éviter de laisser le PAT sur un portable personnel), louez un Mac cloud Macstripe comme nœud de test dédié : connectez-vous en SSH pour configurer Docker ou le binaire, et reliez-le à Cursor local via stdio ou un tunnel distant.

Mode 1 : serveur hébergé à distance (identique sur toutes les plateformes)

GitHub fournit un point de terminaison MCP distant officiel : https://api.githubcopilot.com/mcp/. L'avantage : la configuration est strictement identique sur Windows, Linux et macOS, sans processus local ni Docker.

Authentification : en-tête HTTP Authorization: Bearer <YOUR_GITHUB_PAT>. Les noms de champs JSON varient légèrement selon le client ; voici les écritures courantes pour Cursor et VS Code.

Exemple de configuration Cursor / VS Code

Éditez ~/.cursor/mcp.json (ou .cursor/mcp.json au niveau projet) :

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ghp_xxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Après enregistrement, quittez complètement Cursor puis relancez-le. Dans Settings → MCP, vérifiez que github affiche Connected en vert. Lors de la première connexion, suivez les instructions du client si une invite d'autorisation apparaît.

Avec l'hébergement distant, GitHub gère les mises à jour et les correctifs de sécurité du serveur ; vous n'avez qu'à gérer le cycle de vie du PAT. En environnement d'entreprise, si le trafic HTTPS sortant passe par un proxy, configurez HTTPS_PROXY au niveau système ou client pour atteindre api.githubcopilot.com. Test de connectivité en terminal :

curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer ghp_xxxxxxxxxxxxxxxxxxxx" \
  https://api.githubcopilot.com/mcp/

Un code 200 ou 405 (Method Not Allowed — le point de terminaison est joignable) indique que le réseau et le token sont corrects. Un 401 signale un PAT expiré ou des scopes insuffisants.

Mode 2 : déploiement Docker local

Image officielle : ghcr.io/github/github-mcp-server. Docker local convient aux équipes qui ont besoin d'isolation des identifiants, fonctionnement hors ligne ou politique réseau personnalisée. L'image prend en charge l'authentification PAT et OAuth.

Prérequis Docker par plateforme

• Windows : installez Docker Desktop, activez le backend WSL2, vérifiez que docker version répond. Dans Docker Desktop → Settings → Resources, allouez au moins 2 Go de RAM pour éviter un OOM au démarrage du conteneur.
• macOS : installez Docker Desktop for Mac (Apple Silicon tire automatiquement l'image ARM, sans config supplémentaire). Avec Docker Intel via Rosetta, vérifiez que les couches d'image correspondent à la bonne architecture.
• Linux : installez Docker Engine (sudo apt install docker.io ou équivalent), ajoutez votre utilisateur au groupe docker puis reconnectez-vous, sinon chaque commande nécessite sudo docker.

Le contenu de mcp.json est identique sur les trois plateformes — un autre avantage de Docker par rapport au binaire : une seule config à partager entre développeurs Windows, macOS et Linux.

Mode PAT — configuration mcp.json

Docker reçoit le PAT via la variable GITHUB_PERSONAL_ACCESS_TOKEN :

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

Mode OAuth — mapper le port de callback

Avec OAuth, mappez le port de callback du conteneur vers 127.0.0.1:8085 sur l'hôte et définissez GITHUB_OAUTH_CALLBACK_PORT=8085 :

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-p", "127.0.0.1:8085:8085",
        "-e", "GITHUB_OAUTH_CALLBACK_PORT=8085",
        "ghcr.io/github/github-mcp-server"
      ]
    }
  }
}

Lors de la première connexion, le navigateur ouvre la page d'autorisation GitHub ; après validation, le serveur gère le token — plus besoin d'écrire le PAT dans le JSON.

Vérifier que l'image Docker est accessible

docker pull ghcr.io/github/github-mcp-server
docker run --rm ghcr.io/github/github-mcp-server --version

Si le MCP Server tourne sur un Mac distant isolé (par ex. un nœud Macstripe), un développeur Windows peut faire transiter stdio via un tunnel SSH vers Cursor local — environnement macOS cohérent sans exposer le PAT sur le portable. Pour les bonnes pratiques de sécurité et de mise en production MCP, consultez le guide de déploiement MCP AGNTCon.

Mode 3 : binaire précompilé

Sans Docker, téléchargez le paquet précompilé depuis GitHub Releases (à partir de v1.7.0) :

Installation macOS / Linux et PATH

# Exemple macOS ARM
tar -xzf github-mcp-server_Darwin_arm64.tar.gz
sudo mv github-mcp-server /usr/local/bin/
chmod +x /usr/local/bin/github-mcp-server
github-mcp-server --version

Installation Windows

# PowerShell
Expand-Archive github-mcp-server_Windows_x86_64.zip -DestinationPath C:\Tools\github-mcp-server
# Ajoutez C:\Tools\github-mcp-server au PATH système

Configuration mcp.json (mode stdio)

{
  "mcpServers": {
    "github": {
      "command": "github-mcp-server",
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Sous Windows, si le PATH ne fonctionne pas, utilisez le chemin absolu : "command": "C:\\Tools\\github-mcp-server\\github-mcp-server.exe".

Le binaire démarre vite et n'a pas besoin du démon Docker ; en revanche, les mises à jour exigent de retélécharger le Release et de remplacer le fichier. Documentez en interne la version en usage (ex. v1.7.0) et son checksum pour éviter des comportements divergents entre membres de l'équipe.

Mode 4 : compilation depuis les sources (avancé)

Pour une branche personnalisée, une contribution PR ou un audit complet du code, compilez depuis le dépôt officiel. Prérequis : Go 1.24+.

git clone https://github.com/github/github-mcp-server.git
cd github-mcp-server
git checkout v1.7.0   # ou main
go build -o github-mcp-server ./cmd/github-mcp-server
./github-mcp-server --version

Utilisez le binaire compilé comme en mode 3 : dans mcp.json, pointez command vers le chemin du binaire. En production, fixez un tag (ex. v1.7.0) plutôt que de suivre main.

La compilation convient aux contributeurs de github/github-mcp-server et aux équipes sécurité qui auditent chaque ligne avant de distribuer un binaire interne. Sans besoin de personnalisation, les modes 1 ou 2 suffisent — inutile d'installer la toolchain Go.

Connexion aux clients MCP courants : Cursor, Claude Desktop, VS Code Copilot

La structure JSON diffère légèrement entre clients, mais le principe est le même : déclarer une entrée mcpServers. Ci-dessous le cas le plus courant (Docker en mode PAT ; pour l'hébergement distant, remplacez command/args par url + headers).

Cursor

Config globale ~/.cursor/mcp.json, config projet .cursor/mcp.json. La config projet convient quand un seul dépôt a besoin du GitHub MCP — par ex. contribution open source et side project avec des PAT différents. Après redémarrage, demandez « liste mes dépôts GitHub » dans le chat ; si l'Agent répond qu'il n'a pas d'outils GitHub, le MCP n'est pas chargé — consultez le panneau MCP et les journaux.

Claude Desktop

Éditez claude_desktop_config.json sur votre plateforme ; la structure est identique à Cursor, avec mcpServers en clé racine :

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

Enregistrez, quittez Claude Desktop puis rouvrez-le. Sous macOS : icône barre de menus → Settings → Developer pour les journaux MCP.

VS Code Copilot (mode Agent)

À partir de VS Code 1.99+, Copilot Chat prend en charge MCP. Command Palette → MCP: Add Server, ou créez .vscode/mcp.json dans l'espace de travail. L'écriture hébergement distant est identique à Cursor.

Entre Cursor et Claude Code ? Consultez notre comparatif des outils de codage IA avant de choisir l'hôte MCP.

Checklist en sept étapes et dépannage

Après configuration, validez point par point que l'Agent peut réellement appeler les outils GitHub.

• Étape 1 : PAT créé avec repo (et read:org si nécessaire)
• Étape 2 : syntaxe JSON de mcp.json valide (vérifiez avec jq . ou un validateur en ligne)
• Étape 3 : client complètement redémarré (pas seulement la fenêtre fermée)
• Étape 4 : panneau MCP : github en Connected / vert
• Étape 5 : « liste mes dépôts GitHub » renvoie de vrais noms de dépôts
• Étape 6 : lecture d'un fichier dans un dépôt privé pour confirmer les permissions PAT
• Étape 7 : journaux client sans 401 Unauthorized ni connection refused

Tableau de dépannage courant

Ancienne idée reçue : « un paquet npm suffit pour GitHub ».
Depuis avril 2025, la voie officielle est github/github-mcp-server ; en hébergement distant, connectez-vous à api.githubcopilot.com/mcp/ — ne cherchez plus server-github.

Questions fréquentes

Hébergement distant ou Docker local : que choisir ?

Pour un essai personnel ou une validation rapide en équipe, privilégiez l'hébergement distant GitHub (https://api.githubcopilot.com/mcp/) : même configuration partout, aucun processus à maintenir. Pour le hors ligne, un jeu d'outils personnalisé ou une isolation stricte des identifiants, choisissez Docker local (ghcr.io/github/github-mcp-server).

Peut-on encore utiliser le paquet npm @modelcontextprotocol/server-github ?

Non. Ce paquet a été déprécié en avril 2025. Utilisez le dépôt officiel github/github-mcp-server (actuellement v1.7.0).

Quels scopes PAT sont nécessaires ?

Un PAT Fine-grained ou Classic doit au minimum inclure repo (lecture/écriture des dépôts) et read:org (informations d'organisation). Pour Issues, Pull Requests ou Projects, ajoutez les scopes correspondants.

Que faire si le pull Docker échoue sous Windows ?

Vérifiez Docker Desktop et le backend WSL2 ; allouez assez de mémoire dans Settings → Resources ; exécutez docker login ghcr.io puis docker pull ghcr.io/github/github-mcp-server.

Cursor ne prend pas en compte les modifications de mcp.json : que faire ?

Quittez complètement Cursor puis relancez-le ; vérifiez les conflits entre ~/.cursor/mcp.json et .cursor/mcp.json (le projet prime) ; consultez Settings → MCP pour l'état et les journaux.

Conclusion

La voie officielle pour déployer GitHub MCP Server est désormais claire :

1. Démarrage le plus rapide — hébergement distant https://api.githubcopilot.com/mcp/ + PAT, même JSON partout
2. Contrôle local — image Docker ghcr.io/github/github-mcp-server, PAT ou OAuth
3. Sans Docker — binaire précompilé depuis Releases, PATH configuré
4. Personnalisation avancée — compilation Go 1.24+, tag fixe en production

Commencez par l'hébergement distant dans Cursor : listez les dépôts → lisez un fichier → consultez une Issue. Une fois le PAT validé, décidez si vous migrez vers Docker ou un Mac distant isolé.

En équipe, versionnez la config MCP (sans PAT en clair) et injectez le token via variables d'environnement ou un gestionnaire de secrets — aligné avec les bonnes pratiques de déploiement MCP sécurisé. Les développeurs Windows qui enchaînent builds iOS et workflows Agent peuvent louer un Mac cloud Macstripe à la journée : SSH en ~5 minutes, MCP Server, Xcode et Fastlane sur le même macOS, le portable ne sert que de terminal distant — bien plus stable que Docker + plugins Xcode distants sur la machine personnelle.

Pour aller plus loin

• AGNTCon MCPCon Europe 2026 : déployer un MCP Server →
• Claude Code vs Cursor vs Codex : choisir vos outils IA en 2026 →
• CI iOS lent sur GitHub Actions : file d'attente et Mac cloud 2026 →