Verwenden des GitHub-MCP-Servers

Informationen zum MCP-Server von GitHub

Der MCP-Server von GitHub ist ein Model-Context-Protocol-Server (MCP), der von GitHub bereitgestellt und verwaltet wird. Mit MCP kannst du KI-Funktionen in andere Tools und Dienste integrieren und so deine Entwicklungsumgebung durch kontextbezogene KI-Unterstützung optimieren.

Weitere Informationen zu MCP findest du in der offiziellen MCP-Dokumentation.

Du kannst über Visual Studio Code oder andere Editoren, die Remote-MCP unterstützen, remote auf den MCP-Server von GitHub zugreifen. Stattdessen kannst du ihn auch lokal in einem MCP-kompatiblen Editor ausführen und so zwischen dem Komfort einer gehosteten Lösung oder der Anpassbarkeit eines selbst gehosteten Setups wählen.

Du kannst den MCP-Remoteserver von GitHub in nur wenigen Schritten nutzen und musst dafür kein lokales Setup vornehmen. Dies ist besonders nützlich für Benutzende, die die KI-Funktionen von GitHub schnell nutzen möchten, ohne einen lokalen MCP-Server zu verwalten.

Eine lokale Ausführung des MCP-Servers von GitHub erfordert mehr Setupschritte, ermöglicht jedoch eine größere Anpassung und Kontrolle über deine KI-Interaktionen.

Du kannst den MCP-Server von GitHub verwenden, um:

• codebezogene Aufgaben zu automatisieren und zu optimieren
• Drittanbietertools (z. B. Cursor, Windsurf oder zukünftige Integrationen) zu verbinden, um die Kontext- und KI-Funktionen von GitHub zu nutzen
• cloudbasierte Workflows zu ermöglichen, die von jedem Gerät aus ohne lokales Setup funktionieren

Verfügbarkeit

Clients wie Visual Studio Code, die JetBrains-IDEs und XCode bieten derzeit breitangelegte Unterstützung für lokale MCP-Server.

Die Unterstützung für Remote-MCP-Server wächst, wobei Editoren wie Visual Studio Code (mit OAuth oder PAT), Visual Studio (nur PAT), JetBrains-IDEs (nur PAT), Xcode (nur PAT), Eclipse (nur PAT), Windsurf (nur PAT) und Cursor (nur PAT) diese Funktionalität bereits anbieten.

Um herauszufinden, ob dein bevorzugter Editor Remote-MCP-Server unterstützt, solltest du die Dokumentation des jeweiligen Editors lesen.

Voraussetzungen

• Ein GitHub-Konto
• Visual Studio Code oder einen anderen MCP-kompatiblen Editor
• If you are a member of an organization or enterprise with a Copilot Business or Copilot Enterprise plan, the "MCP servers in Copilot" policy must be enabled in order to use MCP with Copilot.

Einrichten des MCP-Servers von GitHub in Visual Studio Code

Die folgenden Anweisungen führen dich durch das Setup des MCP-Servers von GitHub in Visual Studio Code Andere MCP-kompatible Editoren erfordern möglicherweise ähnliche Schritte, der exakte Ablauf kann jedoch variieren.

Je nach deinen Anforderungen und Präferenzen kannst du den MCP-Server von GitHub entweder remote oder lokal einrichten. Du kannst deinen GitHub-MCP-Server auch für eine der folgenden Optionen konfigurieren:

• Ein bestimmtes Repository: Dadurch kannst du MCP-Server für alle Personen freigegeben, die das Projekt in Visual Studio Code öffnen. Erstelle hierzu im Stammverzeichnis deines Repositorys eine .vscode/mcp.json-Datei.
• Deine persönliche Instanz von Visual Studio Code: Du bist die einzige Person mit Zugriff auf konfigurierte MCP-Server. Füge deiner settings.json-Datei hierzu in Visual Studio Code die Konfiguration hinzu. MCP-Server, die auf diese Weise konfiguriert wurden, sind in allen Arbeitsbereichen verfügbar.

Ein MCP-Remoteserver von GitHub verwendet standardmäßig die One-Click-OAuth-Authentifizierung . Du kannst sie jedoch auch manuell so konfigurieren, dass ein personal access token (PAT) für die Authentifizierung verwendet wird. Wenn du OAuth verwendest, kann der MCP-Server nur auf die Bereiche zugreifen, die du während der Anmeldung genehmigst. In organisationseigenen Kontexten kann der Zugriff auch durch Administratorrichtlinien eingeschränkt werden, die steuern, welche Bereiche und Apps zulässig sind. Wenn du ein persönliches Zugriffstoken (Personal Access Token, PAT) verwendest, hat der MCP-Server Zugriff auf die vom PAT gewährten Bereiche, die auch den von der Organisation konfigurierten PAT-Einschränkungen unterliegen.

Wenn du ein Enterprise Managed User bist, ist „PAT“ standardmäßig deaktiviert, es sei denn, die Option wurde von einem Unternehmensadmin aktiviert. Wenn „PAT“ deaktiviert ist, kannst du die PAT-Authentifizierung nicht verwenden. Wenn Einschränkungen der OAuth-Zugriffsrichtlinie für dich gelten, muss die OAuth-App für jeden Client (MCP-Hostanwendung) aktiviert sein (mit Ausnahme von Visual Studio Code und Visual Studio, da sie Microsoft-IDEs mit nativer Copilot-Integration sind).

• Konfigurieren des MCP-Remoteservers mit OAuth
• Konfigurieren des MCP-Remoteservers mit einem PAT
• Setup eines lokalen MCP-Servers

Konfigurieren des MCP-Remoteservers mit OAuth

Du musst kein PAT erstellen oder zusätzliche Software installieren, um den MCP-Remoteserver von GitHub mit OAuth zu verwenden. Du kannst ihn direkt in Visual Studio Code einrichten. Du kannst auch einzelne Toolsets installieren, entweder im schreibgeschützten Modus oder mit vollständigem Lese-/Schreibzugriff, um die Funktionen des Servers an deine spezifischen Anforderungen anzupassen. Weitere Informationen findest du unter Konfigurieren von Tools.

1. Öffne die Befehlspalette in Visual Studio Code, indem du STRG+UMSCHALT+P (Windows/Linux) / BEFEHL+UMSCHALT+P (Mac) drückst.

2. Gib mcp: add server ein, und drücke dann die EINGABETASTE.

3. Wähle HTTP (HTTP or Server-Sent Events) aus der Liste aus.

4. Gib http://api.githubcopilot.com/mcp/ in das Feld Server URL ein, und drücke die EINGABETASTE.

5. Drücke die EINGABETASTE unter Enter Server ID, um die Standardserver-ID zu verwenden, oder gib eine benutzerdefinierte Server-ID ein.

6. Wähle unter Choose where to save the configuration aus, wo die Konfiguration des MCP-Servers gespeichert werden soll.

   • Visual Studio Code öffnet die Konfiguration und fügt sie entweder der im Editor ausgewählten Datei hinzu oder erstellt eine neue Datei, wenn noch keine vorhanden ist.

7. Klicke im Visual Studio Code-Popup auf Allow, um den MCP-Server für OAuth zu autorisieren, und wähle dein persönliches Konto aus der Liste aus.

Konfigurieren des MCP-Remoteservers mit einem PAT

Um den MCP-Remoteserver von GitHub mit einem PAT zu konfigurieren, musst du zunächst sicherstellen, dass du ein PAT mit den erforderlichen Zugriffsbereichen erstellt hast, die du dem MCP-Server gewähren möchtest. Weitere Informationen finden Sie unter Verwalten deiner persönlichen Zugriffstoken.

Du musst den MCP-Server manuell Visual Studio Code konfigurieren, um das PAT für die Autorisierung zu verwenden.

1. Öffne die Befehlspalette in Visual Studio Code, indem du STRG+UMSCHALT+P (Windows/Linux) / BEFEHL+UMSCHALT+P (Mac) drückst.

2. Gib mcp: add server ein, und drücke dann die EINGABETASTE.

3. Wähle HTTP (HTTP or Server-Sent Events) aus der Liste aus.

4. Gib http://api.githubcopilot.com/mcp/ in das Feld Server URL ein, und drücke die EINGABETASTE.

5. Drücke die EINGABETASTE unter Enter Server ID, um die Standardserver-ID zu verwenden, oder gib eine benutzerdefinierte Server-ID ein.

6. Wähle unter Choose where to save the configuration aus, wo die Konfiguration des MCP-Servers gespeichert werden soll.

   • Visual Studio Code öffnet die Konfiguration und fügt sie entweder der im Editor ausgewählten Datei hinzu oder erstellt eine neue Datei, wenn noch keine vorhanden ist.

7. Klicke im Visual Studio Code-Popup auf Cancel, um die OAuth-Autorisierung abzulehnen.

8. Für die Verwendung eines PAT musst du die Konfigurationsdatei manuell bearbeiten. Füge in der Konfigurationsdatei am Ende der url-Zeile Folgendes hinzu:

   JSON

       ,
         "headers": {
           "Authorization": "Bearer ${input:github_token}"
         }
       },
     },
     "inputs": [
       {
         "id": "github_token",
         "type": "promptString",
         "description": "GitHub Personal Access Token",
         "password": true
       }
     ]
   }
   

9. In der Datei wird eine „Restart“-Schaltfläche angezeigt. Klicke auf „Restart“, um den MCP-Server mit der neuen Konfiguration neu zu starten.

   

10. In der Befehlspalette wird eine Aufforderung angezeigt, dein GitHub-Token einzugeben. Gib das zuvor erstellte PAT ein, und drücke die EINGABETASTE.

    • Der MCP-Server wird jetzt so konfiguriert, dass er das PAT für die Autorisierung verwendet.

Setup eines lokalen MCP-Servers

Für die lokale Verwendung des MCP-Servers von GitHub muss Docker auf deinem Computer installiert sein und ausgeführt werden. Darüber hinaus kannst du dich nur mit einem PAT authentifizieren, da OAuth für lokale MCP-Server nicht unterstützt wird.

1. Vergewissere dich, dass Docker auf deinem Computer installiert ist und ausgeführt wird. Weitere Informationen findest du in den Docker-Installationsanweisungen.

2. Erstelle ein PAT, das (mindestens) Zugriff auf die Bereiche read:packages und repo gewährt. Weitere Informationen finden Sie unter Verwalten deiner persönlichen Zugriffstoken.

3. Entscheide, ob du den MCP-Server für ein bestimmtes Repository oder für deine persönliche Visual Studio Code-Instanz konfigurieren möchtest.

   • Wenn du ein bestimmtes Repository verwendest, öffne die .vscode/mcp.json-Datei in Visual Studio Code, und füge die folgende Konfiguration hinzu:
   JSON

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

   • Wenn du deine persönliche Visual Studio Code-Instanz verwendest, öffne deine settings.json-Datei in Visual Studio Code:
     • Drücke STRG+UMSCHALT+P (Windows/Linux) oder BEFEHL+UMSCHALT+P (macOS).
     • Gib Preferences: Open Settings (JSON) ein, und wähle die Einstellung aus.
     • Fügen Sie die folgende Konfiguration hinzu:
   JSON

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

4. Speichern Sie die Datei.

5. In der Befehlspalette wird eine Aufforderung angezeigt, dein GitHub-Token einzugeben. Gib das zuvor erstellte PAT ein, und drücke die EINGABETASTE.

   • Der MCP-Server wird jetzt so konfiguriert, dass er lokal ausgeführt wird und das PAT für die Autorisierung verwendet.

Toolkonfiguration

Der MCP-Server von GitHub unterstützt auch die Installation einzelner Toolsets, entweder im schreibgeschützten Modus oder mit vollständigem Lese-/Schreibzugriff, um die Funktionen des Servers an deine spezifischen Anforderungen anzupassen. Informationen zu One-Click-Installationsoptionen der einzelnen Toolsets findest du im Repository des GitHub-MCP-Servers.

Verwenden des MCP-Servers von GitHub in Visual Studio Code

Mit dem MCP-Server von GitHub kannst du Copilot Chat in Visual Studio Code verwenden, um verschiedenste Aktionen auf GitHub auszuführen.

1. Öffne Copilot Chat durch Klicken auf das Symbol auf der Titelleiste von Visual Studio Code.
2. Wähle im Feld Copilot Chat im Popupmenü die Option Agent aus.
3. Um die verfügbaren Aktionen anzuzeigen, klicke im Copilot Chat-Feld auf das Symbol Select tools.
   • Im Dropdownmenü Tools wird unter MCP Server:GitHub eine Liste der verfügbaren Aktionen angezeigt.
4. Gib einen Befehl oder eine Frage, der bzw. die sich auf die auszuführende Aktion beziehen, in das Copilot Chat-Feld ein, und drücke die EINGABETASTE.
   • Du kannst den MCP-Server von GitHub beispielsweise bitten, ein neues Issue zu erstellen, Pull Requests aufzulisten oder Repositoryinformationen abzurufen.
5. Der MCP-Server von GitHub verarbeitet deine Anfrage und stellt eine Antwort in der Chatschnittstelle bereit.
   • Möglicherweise wirst du im Copilot Chat -Feld aufgefordert, zusätzliche Berechtigungen zu erteilen oder weitere Informationen anzugeben, um die Aktion abzuschließen.
6. Befolge die Aufforderungen, um die Aktion abzuschließen.

Problembehandlung

Wenn beim Verwenden des MCP-Servers von GitHub Probleme auftreten, kannst du bestimmte Schritte zur Problembehandlung ausführen, die oft helfen.

Autorisierungsprobleme

Wenn beim Autorisieren des MCP-Servers Probleme auftreten, stelle Folgendes sicher:

• Stelle sicher, dass du in der IDE deiner Wahl bei GitHub angemeldet bist.

Wenn du dich mit einem personal access token (PAT) authentifizierst, stelle sicher, dass:

• dein GitHub-PAT gültig und für die Bereiche autorisiert ist, die für die gewünschten Aktionen erforderlich sind
• Du hast das richtige PAT eingegeben.

Probleme beim Copilot-Agent-Modus

Wenn du Probleme mit dem Copilot Chat-Agent-Modus hast, stelle sicher, dass:

• du im Copilot Chat-Feld den richtigen Agent ausgewählt hast
• Du hast den MCP-Server ordnungsgemäß in deiner IDE konfiguriert.
• du die erforderlichen Berechtigungen zum Ausführen der gewünschten Aktionen hast

Allgemeine Tipps

Wenn andere Probleme mit dem MCP-Server von GitHub auftreten, können diese allgemeinen Tipps dir bei der Problembehandlung helfen:

• Überprüfe die Ausgabeprotokolle des MCP-Servers auf Fehlermeldungen.
• Wenn du den MCP-Server lokal ausführst, stelle sicher, dass deine lokale Umgebung ordnungsgemäß für die Ausführung von Docker-Containern eingerichtet ist.
• Starte den MCP-Server oder deine IDE neu.

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }

  {
    "servers": {
        "github": {
            "url": "http://api.githubcopilot.com/mcp/",
            "requestInit": {
                "headers": {
                    "Authorization": "Bearer YOUR_GITHUB_PAT"
                }
            }
        }
    }
  }