GitHub MCP Server deployen: Plattformübergreifende Anleitung für Windows, Linux und macOS

GitHub MCP Server ist der von GitHub offiziell gepflegte Model Context Protocol-Server. Er ermöglicht AI-Hosts wie Cursor, Claude Desktop und VS Code Copilot den standardisierten Zugriff auf die GitHub REST- und GraphQL-APIs – Repositories abfragen, Issues lesen, PRs eröffnen, Code durchsuchen, ohne gh-Ausgaben immer wieder in den Chat zu kopieren.

Dieser Artikel folgt der Reihenfolge „zuerst auswählen, dann die Umgebung einrichten, zuletzt in die IDE integrieren“ und deckt Installationspfade für Windows, Linux und macOS ab – inklusive kopierfertiger Konfigurationsausschnitte und einer Fehlerbehebungs-Checkliste.

Seit April 2025 ist das frühere Community-npm-Paket @modelcontextprotocol/server-github veraltet; das einzige offiziell unterstützte lokale Image ist ghcr.io/github/github-mcp-server, der remote gehostete Endpunkt lautet https://api.githubcopilot.com/mcp/.

Welche Bereitstellungsart passt?

Bevor Sie Software installieren, orientieren Sie sich an der folgenden Tabelle, welchen Weg Sie gehen möchten:

Die Authentifizierung ist bei allen drei Methoden gleich: Entweder ein Personal Access Token (PAT) konfigurieren oder im lokalen Docker-/Binärmodus OAuth per Browser nutzen (Token nur im Arbeitsspeicher, nicht auf der Festplatte).

Allgemeine Vorbereitung

Unabhängig vom gewählten Pfad empfiehlt sich diese Vier-Schritte-Vorbereitung:

1. GitHub-PAT anlegen
   Öffnen Sie die Seite zur Erstellung eines Fine-grained PAT und aktivieren Sie die Berechtigungen passend zu Ihren Tools. Zum reinen Lesen von Repositories reichen meist Contents: Read und Metadata: Read; für PRs oder Issues schreiben Sie zusätzliche Schreibrechte frei.

2. Host-Version prüfen
   - Cursor: Remote Streamable HTTP erst ab v0.48.0
   - Claude Desktop / VS Code: jeweilige MCP-Dokumentation beachten

3. (Lokales Docker) Docker installieren und starten
   - Windows / macOS: Docker Desktop
   - Linux: Docker Engine + aktuellen Benutzer zur Gruppe docker hinzufügen

4. Image vorab ziehen (optional, empfohlen)

docker pull ghcr.io/github/github-mcp-server

Bei unauthorized beim Pull: docker logout ghcr.io ausführen und erneut versuchen – manchmal stört ein abgelaufener ghcr-Login.

Methode 1: Remote gehostet (am wenigsten Aufwand)

GitHub stellt unter https://api.githubcopilot.com/mcp/ einen gehosteten MCP-Endpunkt bereit – ohne Docker auf dem Rechner. Geeignet für Linux-Server, schlanke Windows-Umgebungen oder wenn Unternehmensrichtlinien Container verbieten.

Cursor-Konfigurationsbeispiel

Globale Konfiguration bearbeiten: ~/.cursor/mcp.json (unter Windows: %USERPROFILE%\.cursor\mcp.json):

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

YOUR_GITHUB_PAT durch das echte Token ersetzen, speichern und Cursor vollständig neu starten. Unter Settings → Tools & Integrations → MCP Tools sollte ein grüner Online-Indikator erscheinen; in Composer reicht zur Prüfung die Frage „Liste meine GitHub-Repositories“.

Hinweise

• Im Remote-Modus dominiert derzeit PAT-Authentifizierung; OAuth-Unterstützung ist bei einigen Hosts noch in Arbeit.
• Firmenproxy / Firewall müssen HTTPS-Ausgang zu api.githubcopilot.com erlauben.
• PAT nicht ins Repository schreiben; bei projektweiser .cursor/mcp.json in .gitignore aufnehmen.

Methode 2: Docker lokal (offiziell empfohlen)

Die Docker-Variante kommuniziert per stdio mit dem Host: Der Host startet docker run -i ..., der Containerprozess liest und schreibt über Standard-Ein-/Ausgabe. Das ist auch der Standardbefehl hinter Ein-Klick-Installation in Claude Desktop, Windsurf und Cursor.

Installation unter macOS

1. Docker Desktop for Mac installieren (Apple Silicon: ARM64-Version).
2. Im Menüleisten-Walsymbol Running anzeigen.
3. Im Terminal prüfen:

docker run --rm ghcr.io/github/github-mcp-server --help

4. In ~/.cursor/mcp.json eintragen:

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

Installation unter Linux

1. Je nach Distribution Docker Engine installieren (Ubuntu-Beispiel: sudo apt install docker.io).
2. Benutzer zur docker-Gruppe hinzufügen, um sudo zu vermeiden:

sudo usermod -aG docker "$USER"
newgrp docker

3. Docker-Daemon starten: sudo systemctl enable --now docker.
4. MCP-Konfiguration identisch mit macOS – Pfad weiterhin ~/.cursor/mcp.json.

Auf einem Linux-Server ohne grafische Oberfläche können Sie statt PAT im Klartext in der Konfiguration eine Umgebungsvariable setzen:

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_xxxx"

Im env-Block von mcp.json dieselbe Variable referenzieren (manche Hosts unterstützen ${env:GITHUB_PERSONAL_ACCESS_TOKEN} – Host-Dokumentation beachten).

Installation unter Windows

1. Docker Desktop for Windows installieren.
   - WSL-2-Backend empfohlen (Settings → General → Use WSL 2 based engine).
2. Prüfen, dass das Docker-Desktop-Symbol in der Taskleiste läuft.
3. Konfigurationspfad: %USERPROFILE%\.cursor\mcp.json.
4. JSON-Inhalt wie unter macOS; command bleibt docker (Docker Desktop fügt die CLI dem PATH hinzu).

Typische Windows-Falle: In WSL läuft docker, aber Cursor unter Windows liest die Windows-seitige mcp.json – Konfigurationen nicht vermischen. Läuft Cursor unter Windows und das Projekt in WSL, MCP bevorzugt im Windows-Benutzerverzeichnis konfigurieren.

OAuth-Anmeldung (ohne PAT von Hand)

Das offizielle Image enthält OAuth-App-Anmeldedaten. Im Docker-Modus den Callback-Port auf die lokale Loopback-Adresse mappen:

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

Beim ersten Verbindungsaufbau öffnet sich der Browser zur GitHub-Anmeldung; das Token liegt im Speicher und verfällt beim Containerende. Für Headless-Server siehe den Device-Code-Fallback in der offiziellen Dokumentation.

Methode 3: Go aus Quellcode (ohne Docker)

Geeignet ohne Docker oder wenn das Toolset eingeschränkt werden soll (nur Teil der API-Funktionen).

Gemeinsame Schritte auf allen Plattformen

Voraussetzung: Go 1.24+ installieren.

git clone https://github.com/github/github-mcp-server.git
cd github-mcp-server
go build -o github-mcp-server cmd/github-mcp-server/main.go

Der Name der Binärdatei ist frei wählbar; im Folgenden ./github-mcp-server.

Start mit PAT (stdio-Modus):

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_xxxx"
./github-mcp-server stdio

Cursor mit lokaler Binärdatei:

{
  "mcpServers": {
    "github": {
      "command": "/绝对路径/github-mcp-server",
      "args": ["stdio"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT"
      }
    }
  }
}

Zum Aktualisieren erneut git pull && go build – kein Warten auf ein neues Docker-Image.

Andere IDEs und CLI anbinden

Die Konfigurationsschlüssel variieren je nach Host, der Docker-Befehlskern bleibt gleich:

docker run -i --rm \
  -e GITHUB_PERSONAL_ACCESS_TOKEN \
  ghcr.io/github/github-mcp-server

• Claude Desktop: Block mcpServers in claude_desktop_config.json, Struktur wie bei Cursor.
• VS Code Copilot: Remote und lokal; lokal ebenfalls Docker-Image empfohlen.
• Claude Code CLI: eher schlanke Binärdatei, weniger Container-Overhead.

Vollständige Beispiele je Host im Verzeichnis docs/installation-guides/ des offiziellen Repositories.

Sicherheit und Betrieb

1. PAT mit Minimalrechten: Berechtigungen passend zum Toolset, regelmäßig rotieren.
2. Konfigurationsdateirechte: chmod 600 ~/.cursor/mcp.json (Linux / macOS).
3. Nur-Lesen-Modus: Startparameter können read-only aktivieren, damit die KI das Repo nicht versehentlich ändert.
4. GitHub Enterprise Server: Eigene OAuth App / GitHub App nötig, Standard-OAuth von github.com nicht nutzbar – siehe offizielles docs/oauth-login.md.

Plattformunterschiede im Detail

Pfade und Umgebungsvariablen

~/.cursor/mcp.json

Globale MCP-Konfiguration unter macOS und Linux; unter Windows entspricht das %USERPROFILE%\.cursor\mcp.json.

GITHUB_PERSONAL_ACCESS_TOKEN

Name der PAT-Umgebungsvariable im Docker- bzw. Binärmodus; hat Vorrang vor dem OAuth-Flow.

GITHUB_OAUTH_CALLBACK_PORT

Port für den OAuth-Browser-Callback; in Docker-Szenarien meist fest 8085.

Tastenkürzel und Gewohnheiten

In Cursor Composer öffnet Cmd+Shift+P (Windows: Ctrl+Shift+P) die Befehlspalette für MCP-Einstellungen. Früher nutzten manche npx @modelcontextprotocol/server-github in einer Zeile – diese Methode ist veraltet; stattdessen Docker oder den Remote-Endpunkt aus diesem Artikel verwenden.

In Produktion PAT in Umgebungsvariablen oder einem Secrets-Manager ablegen, nicht in git-getrackten Projektdateien.

Prüfliste (vor dem Rollout)

1. Grüner Punkt im MCP-Panel
2. Toolliste mit Einträgen zum Präfix github_*
3. Schreibgeschützte Aktion (z. B. Repos auflisten) erfolgreich

Hinweis zu Logdateien

Cursor-Logs: Help → Toggle Developer Tools → Console, nach MCP filtern; Claude Desktop je nach Plattform unterschiedlich – vollständige Liste im offiziellen Troubleshooting-Abschnitt.

Fehlerbehebung auf einen Blick

Schnelltest lokal: Docker-Befehl im Terminal manuell ausführen und stderr auf sofortige Fehler prüfen; mit dem MCP-Startbefehl in den IDE-Logs abgleichen.

Kurzfassung

• Schnellster Einstieg: Remote https://api.githubcopilot.com/mcp/ + PAT, Cursor v0.48+ mit url konfigurieren.
• Stabil und reproduzierbar: Auf allen Plattformen einheitlich docker run -i --rm ... ghcr.io/github/github-mcp-server.
• Maximal schlank oder anpassbar: go build zur Binärdatei, Anbindung per stdio.

Nach dem Setup spart MCP Zeit, wenn Sie GitHub in natürlicher Sprache steuern – z. B. „Fasse die letzten 5 offenen Issues im kvmkit-Repo zusammen“. Wer parallel CI/CD-Pipelines oder 24/7 Cloud-Mac-Build-Knoten aufbaut, kann MCP-gestützte Entwicklung und automatisierte Releases in einer Toolchain planen.

FAQ