GitHub MCP Server bereitstellen: Windows-, Linux- und macOS-Leitfaden

Sie möchten, dass Ihr Cursor-Agent Issues nachschlägt, PRs eröffnet und Repo-Dateien liest — bleiben aber bei der Frage hängen, welchen GitHub MCP Server Sie installieren sollen. Das alte npm-Paket ist längst veraltet, und jedes Online-Tutorial sagt etwas anderes. Dieser Leitfaden orientiert sich am offiziellen Repository github/github-mcp-server (Stand 2026-07-31 neueste Version v1.7.0) und erklärt alle vier Bereitstellungswege — Remote-Hosting, lokales Docker, vorkompilierte Binaries und Source-Builds — mit Copy-Paste-Konfigurationen für Windows, Linux und macOS.

Was dieser Artikel abdeckt: PAT-Einrichtung, Konfigurationspfade pro Plattform, Integrationsbeispiele für Cursor / Claude Desktop / VS Code Copilot sowie eine Sieben-Schritte-Abnahmecheckliste. Nicht-offizielle Server-Implementations von Drittanbietern sind ausgeschlossen.

Quick Answer: Welchen Bereitstellungsweg wählen?

Orientieren Sie sich an der Tabelle — in 30 Sekunden zum passenden Weg. Die meisten Einzelentwickler starten mit Methode 1 (Remote-Hosting); Teams im Intranet oder mit strikter Credential-Isolation wählen Methode 2 (Docker).

Vor der Bereitstellung: PAT, Host-Apps und Konfigurationspfade

1. GitHub Personal Access Token erstellen

Gehen Sie zu GitHub → Settings → Personal access tokens und erstellen Sie einen Fine-grained- oder Classic-PAT. Häufige Scopes:

• repo — Lesen/Schreiben von Repo-Inhalten, Branches und Commits
• read:org — Organisations- und Teaminformationen lesen
• Fügen Sie read:project, workflow usw. je nach Agent-Aktionen hinzu

2. MCP-Host-Apps und Konfigurationspfade

Jeder Client speichert die MCP-Konfiguration an einem anderen Ort. Die Tabelle listet die häufigsten Pfade pro OS — nach JSON-Änderungen meist vollständiger Neustart nötig. Manche Editoren formatieren JSON beim Speichern; wenn der PAT im env-Feld steht, prüfen Sie Anführungszeichen und Kommas danach.

Wenn Ihr Team eine isolierte Mac-Umgebung für MCP-Integrationstests braucht (damit PATs nicht auf privaten Laptops landen), mieten Sie einen Macstripe Cloud Mac als dedizierten Testknoten — per SSH Docker oder Binary konfigurieren und mit lokalem Cursor über stdio oder Remote-Tunnel verbinden.

Methode 1: Remote-gehosteter Server (plattformübergreifend identisch)

GitHub stellt einen offiziellen Remote-MCP-Endpunkt bereit: https://api.githubcopilot.com/mcp/. Der Vorteil: identische Konfiguration unter Windows, Linux und macOS — ohne lokalen Prozess oder Docker.

Authentifizierung: Senden Sie Authorization: Bearer <YOUR_GITHUB_PAT> im HTTP-Request-Header. JSON-Feldnamen variieren leicht je Client; unten die gängigen Muster für Cursor und VS Code.

Cursor / VS Code Konfigurationsbeispiel

Bearbeiten Sie ~/.cursor/mcp.json (oder projektbezogenes .cursor/mcp.json):

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

Nach dem Speichern Cursor vollständig beenden und neu starten. Unter Settings → MCP prüfen, ob github grün Connected zeigt. Bei erster Verbindung Client-Anweisungen folgen.

Beim Remote-Hosting kümmert sich GitHub um Server-Updates und Sicherheitspatches — Sie verwalten nur den PAT-Lebenszyklus. In Unternehmensnetzen mit HTTPS-Proxy HTTPS_PROXY setzen, damit api.githubcopilot.com erreichbar ist. Konnektivität im Terminal testen:

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

Antwort 200 oder 405 (Method Not Allowed — Endpunkt erreichbar) bedeutet Netzwerk und Token sind grundsätzlich in Ordnung. 401 deutet auf abgelaufenen PAT oder unzureichende Scopes hin.

Methode 2: Lokale Docker-Bereitstellung

Offizielles Image: ghcr.io/github/github-mcp-server. Lokales Docker eignet sich für Teams mit Credential-Isolation, Offline-Betrieb oder eigenen Netzwerkrichtlinien. Das Image unterstützt PAT und OAuth.

Docker-Voraussetzungen pro Plattform

• Windows: Installieren Sie Docker Desktop, aktivieren Sie das WSL2-Backend und prüfen Sie docker version. Unter Docker Desktop → Settings → Resources mindestens 2 GB RAM zuweisen, um OOM beim Containerstart zu vermeiden.
• macOS: Installieren Sie Docker Desktop for Mac (Apple Silicon lädt ARM-Images automatisch). Bei Intel-Docker unter Rosetta prüfen, ob die richtigen Architektur-Layer gezogen werden.
• Linux: Installieren Sie Docker Engine (sudo apt install docker.io o. Ä.), fügen Sie den Benutzer zur Gruppe docker hinzu und melden Sie sich neu an — sonst ist jedes Mal sudo docker nötig.

Der mcp.json-Inhalt ist auf allen drei Plattformen identisch — ein weiterer Docker-Vorteil gegenüber Binaries: einmal schreiben, im Team unter Windows / macOS / Linux wiederverwenden.

PAT-Modus — mcp.json-Konfiguration

Docker erhält den PAT über die Umgebungsvariable 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"
      }
    }
  }
}

OAuth-Modus — Callback-Port mappen

Beim OAuth-Flow mappen Sie den Container-Callback-Port auf 127.0.0.1:8085 am Host und setzen 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"
      ]
    }
  }
}

Bei der ersten Verbindung öffnet der Browser die GitHub-Autorisierungsseite. Nach Freigabe verwaltet der Server das Token — kein PAT im JSON nötig.

Docker-Image-Pull prüfen

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

Läuft der MCP Server auf einem isolierten Remote-Mac (z. B. Macstripe-Cloud-Knoten), können Windows-Entwickler stdio per SSH-Tunnel an lokalen Cursor weiterleiten — macOS-Umgebung konsistent, ohne PAT auf dem privaten PC. Mehr zu MCP-Sicherheit und Betrieb im MCP-Bereitstellungsleitfaden.

Methode 3: Vorkompilierte Binaries

Ohne Docker laden Sie ein vorkompiliertes Paket von GitHub Releases herunter (ab v1.7.0):

macOS / Linux Installation und PATH

# macOS ARM Beispiel
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

Windows install

# PowerShell
Expand-Archive github-mcp-server_Windows_x86_64.zip -DestinationPath C:\Tools\github-mcp-server
# C:\Tools\github-mcp-server zum System-PATH hinzufügen

mcp.json-Konfiguration (stdio-Modus)

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

Wenn PATH unter Windows nicht greift, nutzen Sie einen absoluten Pfad: "command": "C:\\Tools\\github-mcp-server\\github-mcp-server.exe".

Binaries starten schnell und brauchen keinen Docker-Daemon; Upgrades sind manuell. Dokumentieren Sie Version (z. B. v1.7.0) und Checksumme, damit nicht jeder eine andere Server-Version mit inkonsistentem Tool-Verhalten fährt.

Methode 4: Aus Quellcode bauen (Fortgeschritten)

Bei eigenem Branch, PR-Beiträgen oder vollständigem Code-Audit aus dem offiziellen Repo bauen. Voraussetzung: Go 1.24+.

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

Wie Methode 3 nutzen und command in mcp.json auf den Build-Pfad zeigen. In Produktion Release-Tag (z. B. v1.7.0) pinnen statt main.

Source-Builds passen für PR-Contributors zu github/github-mcp-server und Security-Teams, die Code prüfen und interne Patches verteilen. Ohne Anpassungsbedarf reichen Methode 1 oder 2 — keine Go-Toolchain nötig.

An gängige MCP-Hosts anbinden: Cursor, Claude Desktop, VS Code Copilot

Die JSON-Struktur unterscheidet sich leicht, aber alle deklarieren einen mcpServers-Eintrag. Unten das häufigste Muster (Docker PAT; bei Remote-Hosting command/args durch url + headers ersetzen).

Cursor

Global: ~/.cursor/mcp.json, Projekt: .cursor/mcp.json. Projekt-Config passt, wenn nur dieses Repo GitHub MCP braucht — z. B. Open-Source mit anderem PAT als Side Projects. Nach Neustart im Chat „Liste meine GitHub-Repositories“ anfragen. Sagt der Agent, er habe keine GitHub-Tools, ist MCP nicht geladen — MCP-Panel-Logs prüfen.

Claude Desktop

Bearbeiten Sie claude_desktop_config.json für Ihre Plattform. Struktur wie bei Cursor, Top-Level-Key ebenfalls mcpServers:

{
  "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"
      }
    }
  }
}

Speichern, Claude Desktop beenden und neu öffnen. Unter macOS: Menüleisten-Icon → Settings → Developer für MCP-Logs.

VS Code Copilot (Agent-Modus)

Ab VS Code 1.99+ unterstützt Copilot Chat MCP. Command Palette → MCP: Add Server oder .vscode/mcp.json im Workspace. Remote-Hosting-Konfiguration identisch zu Cursor.

Unsicher zwischen Cursor und Claude Code? Lesen Sie unseren KI-Coding-Tools-Vergleich, bevor Sie einen MCP-Host wählen.

Sieben-Schritte-Abnahmecheckliste und Fehlerbehebung

Nach der Konfiguration die Checkliste durchgehen und prüfen, ob der Agent GitHub-Tools wirklich aufrufen kann.

• Schritt 1: PAT erstellt mit repo-Scope (ggf. read:org usw.)
• Schritt 2: mcp.json-JSON gültig (jq . oder Online-Validator)
• Schritt 3: Client vollständig neu gestartet (nicht nur Fenster geschlossen)
• Schritt 4: MCP-Panel zeigt github als Connected / grün
• Schritt 5: „Liste meine GitHub-Repositories“ im Chat liefert echte Repo-Namen
• Schritt 6: Datei aus privatem Repo lesen, um PAT-Berechtigungen zu prüfen
• Schritt 7: Client-Logs ohne 401 Unauthorized oder connection refused

Häufige Probleme

Altes Denkmuster: „npm-Paket installieren und mit GitHub verbunden.“
Seit April 2025 ist der offizielle Weg github/github-mcp-server; für Remote-Hosting api.githubcopilot.com/mcp/ — nicht mehr nach server-github suchen.

Häufig gestellte Fragen

Remote-Hosting oder lokales Docker — was wählen?

Für persönliche Tests oder schnelle Team-Validierung: GitHub Remote-Hosting (https://api.githubcopilot.com/mcp/) — gleiche Config überall, kein Prozess-Betrieb. Bei Offline, eigenem Tool-Set oder strikter Credential-Isolation: lokales Docker (ghcr.io/github/github-mcp-server).

Kann ich noch npm @modelcontextprotocol/server-github nutzen?

Nein. Das npm-Paket wurde im April 2025 eingestellt. Nutzen Sie das offizielle Repo github/github-mcp-server (aktuell v1.7.0).

Welche PAT-Scopes brauche ich?

Fine-grained oder Classic PAT mindestens mit repo (Repos lesen/schreiben) und read:org (Organisation). Für Issues, Pull Requests oder Projects passende Scopes ergänzen.

Docker-Image-Pull schlägt unter Windows fehl — was tun?

Docker Desktop mit WSL2 prüfen; unter Settings → Resources genug Speicher; docker login ghcr.io, dann docker pull ghcr.io/github/github-mcp-server erneut.

mcp.json in Cursor geändert, aber nichts passiert?

Nach dem Speichern Cursor vollständig beenden und neu starten; Konflikte zwischen ~/.cursor/mcp.json und Projekt-.cursor/mcp.json prüfen (Projekt gewinnt); Settings → MCP für Status und Logs.

Fazit

Der offizielle Bereitstellungsweg für GitHub MCP Server ist klar:

1. Schnellster Start — Remote-Hosting https://api.githubcopilot.com/mcp/ + PAT, ein JSON für alle Plattformen
2. Lokale Kontrolle — Docker-Image ghcr.io/github/github-mcp-server, PAT oder OAuth
3. Ohne Docker — vorkompilierte Binary von Releases, PATH setzen
4. Erweiterte Anpassung — Go-1.24+-Source-Build, Release-Tag in Produktion pinnen

Starten Sie in Cursor mit Remote-Hosting: Repos listen → Datei lesen → Issue nachschlagen. Stimmen die PAT-Scopes, entscheiden Sie über Docker oder isolierte Remote-Mac-Umgebung.

Versionieren Sie MCP-Configs (ohne PAT-Klartext) und injizieren Sie Tokens per Umgebungsvariablen oder Secrets Manager — wie bei sicheren MCP-Bereitstellungspraktiken. Windows-Entwickler mit iOS-Builds und Agent-Workflows können einen Macstripe Cloud Mac tageweise mieten — SSH in ~5 Minuten, MCP Server, Xcode und Fastlane auf demselben macOS-Knoten, Laptop nur als Remote-Terminal. Deutlich stabiler als Docker plus Remote-Xcode-Plugins auf dem Privat-PC.

Weiterführende Links

• MCP-Server bereitstellen: Praxisleitfaden →
• Claude Code vs Cursor vs Codex: KI-Coding-Tools im Vergleich 2026 →
• Langsame iOS-CI mit GitHub Actions? Cloud Mac hilft →