Erweitern des Copilot-Programmier-Agent mit Model Context Protocol (MCP)

Hier erfährst du, wie du Model Context Protocol (MCP) verwenden kannst, um die Funktionen des Copilot-Programmier-Agent zu erweitern.

In diesem Artikel

Hinweis

Copilot-Programmier-Agent befindet sich in der public preview. Änderungen sind vorbehalten. Während der Vorschauphase unterliegt die Verwendung des Features den Lizenzbestimmungen für die Vorabversion von GitHub.

Voraussetzung

Lies vor dem Einrichten eines MCP-Servers für Copilot-Programmier-Agent Model Context Protocol (MCP) and Copilot-Programmier-Agent, um sicherzustellen, dass du mit den Konzepten für MCP-Server und Copilot-Programmier-Agent vertraut bist.

Einführung

Als Repositoryadministrator kannst du MCP-Server für die Verwendung in deinem Repository konfigurieren. Verwende hierfür eine JSON-formatierte Konfiguration, in der die Details der MCP-Server angegeben sind, die du verwenden möchtest. Die JSON-Konfiguration gibst du direkt in den Einstellungen für das Repository auf GitHub.com ein.

Warnung

Nachdem du einen MCP-Server konfiguriert hast, ist Copilot in der Lage, die vom Server zur Verfügung gestellten Tools selbstständig zu nutzen und fragt vor deren Verwendung nicht nach deiner Zustimmung.

Hinzufügen einer MCP-Konfiguration zu deinem Repository

Repositoryadministratoren können MCP-Server mithilfe der folgenden Schritte konfigurieren:

  1. Klicke im Abschnitt „Code & automation“ der Randleiste auf Copilot und dann auf Programmier-Agent.

  2. Füge deine Konfiguration im Abschnitt MCP configuration hinzu.

    In den folgenden Abschnitten dieses Artikels wird erläutert, wie du die JSON-Konfiguration schreibst, die du hier eingeben musst.

  3. Klicken Sie auf Speichern.

    Deine Konfiguration wird überprüft, um eine ordnungsgemäße Syntax sicherzustellen.

  4. Wenn für deinen MCP-Server ein Schlüssel oder Geheimnis erforderlich ist, füge deiner Copilot-Umgebung ein Geheimnis hinzu. In deiner MCP-Konfiguration stehen nur Geheimnisse zur Verfügung, deren Namen das Präfix COPILOT_MCP_ vorangestellt ist. Siehe Einrichten einer Copilot-Umgebung für den Copilot-Programmier-Agent.

Schreiben einer JSON-Konfiguration für MCP-Server

MCP-Server werden mit einem speziellen JSON-Format konfiguriert. Die JSON-Datei muss ein mcpServers-Objekt enthalten, wobei der Schlüssel der Name des MCP-Servers (z. B. sentry) und der Wert ein Objekt mit der Konfiguration für diesen MCP-Server ist.

JSON
{
  "mcpServers": {
    "MCP SERVER 1": {
      "command": "VALUE",
      "args": [ VALUES ],
      ...
    },
    "MCP SERVER 2": {
      "command": "VALUE",
      "args": [ VALUES ],
      ...
    },
    ...
  }
}

Das Konfigurationsobjekt kann die folgenden Schlüssel enthalten:

Erforderliche Schlüssel für lokale und MCP-Remoteserver

  • tools (string[]): Die Tools vom MCP-Server, die aktiviert werden. In der Dokumentation des Servers oder im entsprechenden Code findest du möglicherweise eine Liste mit Tools. Es wird dringend empfohlen, bestimmte schreibgeschützte Tools zuzulassen, da der Agent diese Tools autonom verwenden kann und du nicht zuerst zur Genehmigung aufgefordert wirst. Du kannst auch alle Tools aktivieren, indem du * in das Array einschließt.
  • type (string): Copilot-Programmier-Agent akzeptiert "local", "http" oder "sse".

MCP-spezifische lokale Schlüssel

  • command (string): Erforderlich. Der Befehl, der ausgeführt wird, um den MCP-Server zu starten.
  • args (string[]): Erforderlich. Die Argumente, die an command übergeben werden sollen.
  • env (object): Optional. Die Umgebungsvariablen, die an den Server übergeben werden. Dieses Objekt muss den Namen der Umgebungsvariablen, die dem MCP-Server zur Verfügung gestellt werden sollen, einem der folgenden Werte zuordnen:
    • Dem Namen eines GitHub Actions-Geheimnisses, das du konfiguriert hast und das mit COPILOT_MCP_ beginnt.
    • Ein Zeichenfolgenwert.

MCP-spezifische Remoteschlüssel

  • url (string): Erforderlich. Die URL des MCP-Servers.
  • headers (object): Optional. Die Header, die an Anforderungen an den Server angefügt werden sollen. Dieses Objekt sollte den Namen der Headerschlüssel einem der folgenden Elemente zuordnen:
    • Dem Namen eines GitHub Actions-Geheimnisses, das du konfiguriert hast und das mit COPILOT_MCP_ beginnt und dem $ vorangestellt wird
    • Ein Zeichenfolgenwert

Beispielkonfigurationen

Beispiel: Sentry

Der Sentry-MCP-Server gewährt Copilot authentifizierten Zugriff auf Ausnahmen, die in Sentry aufgezeichnet wurden.

JavaScript
// If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
{
  "mcpServers": {
    "sentry": {
      "type": "local",
      "command": "npx",
      // We can use the $SENTRY_HOST environment variable which is passed to
      // the server because of the `env` value below.
      "args": ["@sentry/mcp-server@latest", "--host=$SENTRY_HOST"],
      "tools": ["get_issue_details", "get_issue_summary"],
      "env": {
        // We can specify an environment variable value as a string...
        "SENTRY_HOST": "http://contoso.sentry.io",
        // or refer to a GitHub Actions secret with a name starting with
        // `COPILOT_MCP_`
        "SENTRY_ACCESS_TOKEN": "COPILOT_MCP_SENTRY_ACCESS_TOKEN"
      }
    }
  }
}

Beispiel: Notion

Der Notion-MCP-Server gewährt Copilot authentifizierten Zugriff auf Hinweise und andere Inhalte von Notion.

JavaScript
// If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
{
  "mcpServers": {
    "notionApi": {
      "type": "local",
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        // We can use the $NOTION_API_KEY environment variable which is passed to
        // the server because of the `env` value below.
        "OPENAPI_MCP_HEADERS={\"Authorization\": \"Bearer $NOTION_API_KEY\", \"Notion-Version\": \"2022-06-28\"}",
       "mcp/notion"
      ],
      "env": {
        // The value of the `COPILOT_MCP_NOTION_API_KEY` secret will be passed to the
        // server command as an environment variable called `NOTION_API_KEY`
        "NOTION_API_KEY": "COPILOT_MCP_NOTION_API_KEY"
      },
      "tools": ["*"]
    }
  }
}

Beispiel: Azure

Der Azure-MCP-Server stellt eine direkte Verbindung zwischen Copilot und wichtigen Azure-Diensten wie Azure Cosmos DB und der Azure Storage-Plattform her.

Zur Verwendung von Azure MCP mit dem Copilot-Programmier-Agent musst du die Datei copilot-setup-steps.yml des Repositorys aktualisieren, um einen Workflowschritt für die Anmeldung bei Azure einzubinden.

  1. Konfiguriere OIDC in einer Microsoft Entra-Anwendung und lege dabei GitHub als vertrauenswürdig fest. Informationen hierzu findest du unter Verwenden der Azure-Anmeldeaktion mit OpenID Connect.

  2. Falls noch nicht geschehen, füge die Actions-Workflowdatei .github/workflows/copilot-setup-steps.yml in deinem Repository hinzu.

  3. Füge dem copilot-setup-steps-Workflowauftrag einen Schritt für die Anmeldung bei Azure hinzu.

    YAML
    on:
  workflow_dispatch:
permissions:
  id-token: write
  contents: read
jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    environment: copilot
    steps:
      - name: Azure login
        uses: azure/login@a457da9ea143d694b1b9c7c869ebb04ebe844ef5
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    Mit dieser Konfiguration wird sichergestellt, dass die Aktion azure/login bei der Ausführung von Copilot-Programmier-Agent ausgeführt wird.

  4. Füge in der Copilot-Umgebung deines Repositorys Geheimnisse für deine AZURE_CLIENT_ID, AZURE_TENANT_ID und AZURE_SUBSCRIPTION_ID hinzu.

  5. Konfiguriere den Azure-MCP-Server, indem du deiner MCP-Konfiguration ein azure-Objekt hinzufügst.

JSON
 {
   "mcpServers": {
     "Azure": {
      "type": "local",
      "command": "npx",
      "args": [
        "-y",
        "@azure/mcp@latest",
        "server",
        "start"
       ],
      "tools": ["*"]
     }
   }
 }

Beispiel: Cloudflare

Der Cloudflare-MCP-Server erstellt Verbindungen zwischen deinen Cloudflare-Diensten, einschließlich Verarbeitungsdokumentation und Datenanalyse.

JSON
{
  "mcpServers": {
    "cloudflare": {
      "type": "sse",
      "url": "http://docs.mcp.cloudflare.com/sse",
      "tools": ["*"]
    }
  }
}

Wiederverwendung deiner MCP-Konfiguration in Visual Studio Code

Wenn du bereits MCP-Server in VS Code konfiguriert hast, kannst du eine ähnliche Konfiguration für den Copilot-Programmier-Agent verwenden.

Je nachdem, wie VS Code konfiguriert ist, findest du deine MCP-Einstellungen in der .vscode/mcp.json-Datei deines Repositorys oder in der privaten settings.json-Datei deines Computers.

Zur Anpassung der Konfiguration für Copilot-Programmier-Agent musst du folgende Schritte durchführen:

  1. Füge für jeden MCP-Server einen tools-Schlüssel hinzu, der angibt, welche Tools für Copilot zur Verfügung stehen sollen.
  2. Wenn du inputs konfiguriert hast, wechsle zur direkten Verwendung von env.
  3. Wenn du envFile konfiguriert hast, wechsle zur direkten Verwendung von env.
  4. Aktualisiere alle Verweise auf inputs in deiner args-Konfiguration, sodass stattdessen auf Umgebungsvariablen von env verwiesen wird.

Weitere Informationen zu MCP in VS Code findest du in der Dokumentation zu VS Code.

Einrichten einer Copilot-Umgebung für den Copilot-Programmier-Agent

Für einige MCP-Server sind Schlüssel oder Geheimnisse erforderlich. Damit du diese Server im Copilot-Programmier-Agent musst du einer Umgebung Geheimnisse für Copilot hinzufügen. Dadurch wird sichergestellt, dass die Geheimnisse richtig erkannt und an den entsprechenden MCP-Server weitergeleitet werden, den du konfiguriert hast.

Damit du eine Copilot-Umgebung für dein Repository konfigurieren kannst, musst du Repositoryadministrator sein.

  1. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

  2. Wähle unter dem Namen deines Repositorys die Option Einstellungen aus. Wenn die Registerkarte „Einstellungen“ nicht angezeigt wird, wähle im Dropdownmenü die Option Einstellungen aus.

    Screenshot eines Repositoryheaders mit den Registerkarten. Die Registerkarte „Einstellungen“ ist dunkelorange umrandet.

  3. Klicke auf der linken Randleiste auf Umgebungen.

  4. Klicke auf Neue Umgebung.

  5. Gib der neuen Umgebung den Namen copilot, und klicke auf Configure environment.

  6. Klicke unter „Environment secrets“ auf Add environment secret.

  7. Gib dem Geheimnis einen Namen, der mit COPILOT_MCP_ beginnt. Füge den Geheimniswert hinzu, und klicke auf Add secret.

Überprüfen einer MCP-Konfiguration

Nachdem du deine MCP-Konfiguration eingerichtet hast, solltest du sie testen, um sicherzustellen, dass sie ordnungsgemäß eingerichtet ist.

  1. Erstelle im Repository ein Issue, und weise es Copilot zu.
  2. Warte einen Moment, bis Copilot eine 👀-Reaktion für das Issue hinterlässt.
  3. Warte einen Moment, bis Copilot einen Pull Request erstellt, der auf der Zeitachse des Issues angezeigt wird.
  4. Klicke auf den Pull Request auf der Zeitachse, und warte, bis das Zeitachsenereignis „Copilot started work“ angezeigt wird.
  5. Klicke auf View session, um die Copilot-Programmier-Agent-Protokolle zu öffnen.
  6. Klicke oben rechts in der Protokollanzeige auf die Schaltfläche mit den Auslassungspunkten (...) und dann in der Seitenleiste auf Copilot.
  7. Klicke auf den Schritt Start MCP Servers, um die Protokolle aufzuklappen.
  8. Wenn deine MCP-Server erfolgreich gestartet wurden, werden die entsprechenden Tools unten in den Protokollen aufgeführt.

Wenn für deine MCP-Server Abhängigkeiten erforderlich sind, die nicht standardmäßig auf dem GitHub Actions-Runner installiert sind, z. B. uv und pipx, oder für die spezielle Einrichtungsschritte erforderlich sind, musst du möglicherweise eine copilot-setup-steps.yml-Actions-Workflowdatei erstellen, um sie zu installieren. Weitere Informationen finden Sie unter Anpassen der Entwicklungsumgebung für den Copilot-Programmier-Agent.

Anpassen des integrierten GitHub-MCP-Servers

Der MCP-Server GitHub ist standardmäßig aktiviert und stellt eine Verbindung zu GitHub mit einem speziell zugewiesenen Token her, das nur Lesezugriff auf das aktuelle Repository hat.

Wenn du Copilot den Zugriff auf Daten außerhalb des aktuellen Repositorys erlauben willst, kannst du ein personal access token mit erweitertem Zugriff vergeben.

  1. Erstelle ein personal access token mit den entsprechenden Berechtigungen. Es wird empfohlen, ein fine-grained personal access token zu verwenden, wobei du den Zugriff des Tokens auf schreibgeschützte Berechtigungen für bestimmte Repositorys beschränken kannst. Weitere Informationen zu personal access tokens findest du unter Verwalten deiner persönlichen Zugriffstoken.

  2. Klicke im Abschnitt „Code & automation“ der Randleiste auf Copilot und dann auf Programmier-Agent.

  3. Füge deine Konfiguration im Abschnitt MCP configuration hinzu.

  4. Klicken Sie auf Speichern.

  5. Klicke auf der linken Randleiste auf Umgebungen.

  6. Klicke auf die copilot-Umgebung.

  7. Klicke unter „Environment secrets“ auf Add environment secret.

  8. Rufe das Geheimnis COPILOT_MCP_GITHUB_PERSONAL_ACCESS_TOKEN ab. Gib dein personal access token in das Feld „Value“ ein, und klicke auf Add secret.

Informationen zur Verwendung des MCP-Servers von GitHub in anderen Umgebungen findest du unter Verwenden des GitHub-MCP-Servers.

Nächste Schritte