Erweiterung des GitHub Copilot Codierungsagenten mit dem Model Context Protocol (MCP)

Voraussetzung

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

Einleitung

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.

Organisationen und Administratoren von Unternehmen können MCP-Server auch als Element von Benutzerdefinierte Agenten über das YAML-Frontmatter konfigurieren. Weitere Informationen finden Sie unter Konfiguration von benutzerdefinierten Agents.

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.

Hinweis

Copilot Codierungsassistent unterstützt nur von MCP-Servern bereitgestellte Tools. Ressourcen oder Prompts werden nicht unterstützt.
Copilot Codierungsassistent unterstützt derzeit keine MCP-Remoteserver, die OAuth für die Authentifizierung und Autorisierung nutzen.

Hinzufügen einer MCP-Konfiguration zu deinem Repository

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

Navigieren Sie auf GitHub zur Hauptseite des Repositorys.
Klicke unter dem Repositorynamen auf Settings. Wenn die Registerkarte „Einstellungen“ nicht angezeigt wird, wähle im Dropdownmenü die Option Einstellungen aus.
Klicken Sie im Abschnitt „Code & Automatisierung“ in der Seitenleiste auf Copilot und dann auf Programmier-Agent.
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.
Klicken Sie auf Speichern.

Deine Konfiguration wird überprüft, um eine ordnungsgemäße Syntax sicherzustellen.
Wenn Ihr MCP-Server eine Variable, einen Schlüssel oder ein Geheimnis benötigt, fügen Sie eine Variable oder ein Geheimnis zu Ihrer Copilot-Umgebung hinzu. Nur Variablen und Geheimnisse mit Namen, die mit COPILOT_MCP_ beginnen, stehen für Ihre MCP-Konfiguration zur Verfügung. Siehe Einrichten einer Copilot-Umgebung für den Copilot Codierungsassistent.

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 ],
      ...
    },
    ...
  }
}

{
  "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 remote MCP-Server**

* tools (string[]): Die zu aktivierenden Tools des MCP-Servers. 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 Codierungsassistent akzeptiert `"local"`, `"stdio"`, `"http"` oder `"sse"`.

        **Lokale MCP-spezifische 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 sollte den Namen der Umgebungsvariablen abbilden, die Ihrem MCP-Server zur Verfügung gestellt werden soll, auf eines der folgenden:

Eine Referenz für den Ersatz auf ein Geheimnis oder eine Variable in der Copilot-Umgebung, z. B. $COPILOT_MCP_API_KEY oder ${COPILOT_MCP_API_KEY}. Referenzierte Namen müssen mit COPILOT_MCP_ beginnen.

Ein Literalwert einer Zeichenkette.

      **Remote MCP-spezifische Schlü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 Kopfzeilenschlüssel einem der folgenden Zuordnen:
```
- Eine Referenz für den Ersatz auf ein Geheimnis oder eine Variable in der Copilot-Umgebung, z. B. $COPILOT_MCP_API_KEY oder ${COPILOT_MCP_API_KEY}. Referenzierte Namen müssen mit COPILOT_MCP_ beginnen.
- Ein literaler Zeichenfolgenwert.

Beachten Sie, dass alle string- und string[]-Felder außer tools & type die Ersetzung durch eine Variable oder einen geheimen Schlüssel unterstützen, die Sie in Ihrer Copilot-Umgebung konfiguriert haben.

Variablenersetzung

Die folgenden Syntaxmuster werden für Verweise auf Umgebungsvariablen unterstützt, die in der Copilot-Umgebung konfiguriert sind:

Syntax	Beispiel
`$VAR`	`$COPILOT_MCP_API_KEY`
`${VAR}`	`${COPILOT_MCP_API_KEY}`
`${VAR:-default}`	`${COPILOT_MCP_API_KEY:-fallback_value}`

Beispielkonfigurationen

Die folgenden Beispiele zeigen MCP-Serverkonfigurationen für verschiedene Anbieter.

```
        [Sentry](#example-sentry)
```
```
        [Notion](#example-notion)
```
```
        [Azure](#example-azure)
```

        [Cloudflare](#example-cloudflare)

        [Azure DevOps](#example-azure-devops)

        [Atlassian](#example-atlassian)

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": "https://contoso.sentry.io",
        // or refer to a variable or secret in your Copilot environment
        // with a name starting with `COPILOT_MCP_`
        "SENTRY_ACCESS_TOKEN": "$COPILOT_MCP_SENTRY_ACCESS_TOKEN"
      }
    }
  }
}

// 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": "https://contoso.sentry.io",
        // or refer to a variable or secret in your Copilot environment
        // 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": ["*"]
    }
  }
}

// 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

Das Microsoft MCP-Repository umfasst den Azure MCP-Server, der Copilot das Verstehen von Azure-spezifischen Dateien und Azure-Ressourcen innerhalb des Abonnements ermöglicht, wenn der Code geändert wird.

Wenn Sie Ihr Repository automatisch mit einer copilot-setup-steps.yml-Datei konfigurieren möchten, um sich bei Azure zu authentifizieren, sowie geheime Schlüssel für die Authentifizierung, klonen Sie das Repository lokal, und führen Sie dann die Azure Developer CLI des Befehls azd coding-agent config im Stammverzeichnis des Repositorys aus.

Nachdem Sie den Befehl ausgeführt und die erstellte Pullanforderung zusammengeführt haben, können Sie die MCP-Konfiguration zu Ihrem Repository hinzufügen.

JSON

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

 {
   "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": "https://docs.mcp.cloudflare.com/sse",
      "tools": ["*"]
    }
  }
}

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

Beispiel: Azure DevOps

Der Azure DevOps MCP-Server erstellt eine nahtlose Verbindung zwischen Copilot und den Azure DevOps-Diensten, einschließlich Ihrer Arbeitselemente, Pipelines oder Dokumentation.

Um den Azure DevOps MCP-Server mit Copilot Codierungsassistent zu verwenden, müssen Sie die copilot-setup-steps.yml Datei des Repositorys aktualisieren, um einen Azure Anmeldeworkflowschritt einzuschließen.

Konfigurieren Sie OIDC in einer Microsoft Entra-Anwendung und vertrauen Sie GitHub. Weitere Informationen finden Sie unter Use the Azure Login action with OpenID Connect.
Richte den Zugriff auf die Azure DevOps-Organisation und Projekte für die Anwendungsidentität ein. Weitere Informationen findest du unter Hinzufügen von Organisationsbenutzern und Verwalten des Zugriffs.
Falls noch nicht geschehen, füge die Actions-Workflowdatei .github/workflows/copilot-setup-steps.yml in deinem Repository hinzu.

Fügen Sie dem Workflow-Auftrag copilot-setup-steps einen Azure-Anmeldeschritt hinzu.

YAML

# Dieser Workflow verwendet Aktionen, die nicht von GitHub zertifiziert sind.
# Sie werden von einem Drittanbieter bereitgestellt und unterliegen
# separaten Nutzungsbedingungen, Datenschutzbestimmungen und Support
# Onlinedokumentation.
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 }}
          allow-no-subscriptions: true

# Dieser Workflow verwendet Aktionen, die nicht von GitHub zertifiziert sind.
# Sie werden von einem Drittanbieter bereitgestellt und unterliegen
# separaten Nutzungsbedingungen, Datenschutzbestimmungen und Support
# Onlinedokumentation.
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 }}
          allow-no-subscriptions: true

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

Füge in der Copilot-Umgebung deines Repositorys Geheimnisse für AZURE_CLIENT_ID und AZURE_TENANT_ID hinzu.
Konfiguriere den Azure DevOps-MCP-Server, indem du deiner MCP-Konfiguration ein ado-Objekt mit definierten Tools hinzufügst, die von Copilot Codierungsassistent verwendet werden sollen.

JSON

{
  "mcpServers": {
    "ado": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@azure-devops/mcp", "<your-azure-devops-organization>", "-a", "azcli"],
      "tools": ["wit_get_work_item", "wit_get_work_items_batch_by_ids", ...]
    }
  }
}

{
  "mcpServers": {
    "ado": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@azure-devops/mcp", "<your-azure-devops-organization>", "-a", "azcli"],
      "tools": ["wit_get_work_item", "wit_get_work_items_batch_by_ids", ...]
    }
  }
}

Beispiel: Atlassian

Der Atlassian MCP Server ermöglicht Copilot authentifizierten Zugriff auf Ihre Atlassian-Apps, einschließlich Jira, Compass und Confluence.

Weitere Informationen zur Authentifizierung auf dem Atlassian MCP-Server mithilfe eines API-Schlüssels finden Sie unter Konfigurieren der Authentifizierung über API-Token in der Atlassian-Dokumentation.

JavaScript

// If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
{
  "mcpServers": {
    "atlassian-rovo-mcp": {
      "command": "npx",
      "type": "local",
      "tools": ["*"],
      "args": [
        "mcp-remote@latest",
        "https://mcp.atlassian.com/v1/mcp",
        // We can use the $ATLASSIAN_API_KEY environment variable which is passed
        // to the server because of the `env` value below.
        "--header",
        "Authorization: Basic $ATLASSIAN_API_KEY"
      ],
      "env": {
        // The value of the `COPILOT_MCP_ATLASSIAN_API_KEY` secret will be passed
        // to the server command as an environment variable
        // called `ATLASSIAN_API_KEY`.
        "ATLASSIAN_API_KEY": "$COPILOT_MCP_ATLASSIAN_API_KEY"
      }
    }
  }
}

// If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
{
  "mcpServers": {
    "atlassian-rovo-mcp": {
      "command": "npx",
      "type": "local",
      "tools": ["*"],
      "args": [
        "mcp-remote@latest",
        "https://mcp.atlassian.com/v1/mcp",
        // We can use the $ATLASSIAN_API_KEY environment variable which is passed
        // to the server because of the `env` value below.
        "--header",
        "Authorization: Basic $ATLASSIAN_API_KEY"
      ],
      "env": {
        // The value of the `COPILOT_MCP_ATLASSIAN_API_KEY` secret will be passed
        // to the server command as an environment variable
        // called `ATLASSIAN_API_KEY`.
        "ATLASSIAN_API_KEY": "$COPILOT_MCP_ATLASSIAN_API_KEY"
      }
    }
  }
}

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 Codierungsassistent 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 Codierungsassistent musst du folgende Schritte durchführen:

Füge für jeden MCP-Server einen tools-Schlüssel hinzu, der angibt, welche Tools für Copilot zur Verfügung stehen sollen.
Wenn du inputs konfiguriert hast, wechsle zur direkten Verwendung von env.
Wenn du envFile konfiguriert hast, wechsle zur direkten Verwendung von env.
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 Codierungsassistent

Für einige MCP-Server sind Schlüssel oder Geheimnisse erforderlich. Damit du diese Server im Copilot Codierungsassistent 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.

Navigieren Sie auf GitHub zur Hauptseite des Repositorys.
Klicke unter dem Repositorynamen auf Settings. Wenn die Registerkarte „Einstellungen“ nicht angezeigt wird, wähle im Dropdownmenü die Option Einstellungen aus.
Klicke auf der linken Randleiste auf Umgebungen.
Klicke auf Neue Umgebung.
Gib der neuen Umgebung den Namen copilot, und klicke auf Configure environment.
Klicke unter „Environment secrets“ auf Add environment secret.
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.

Erstelle im Repository ein Issue, und weise es Copilot zu.
Warte einen Moment, bis Copilot eine 👀-Reaktion für das Issue hinterlässt.
Warte einen Moment, bis Copilot einen Pull Request erstellt, der auf der Zeitachse des Issues angezeigt wird.
Klicken Sie auf die erstellte Pull-Anfrage in der Zeitleiste und warten Sie, bis ein Zeitleistenereignis "Copilot hat die Arbeit begonnen" angezeigt wird.
Klicke auf View session, um die Copilot Codierungsassistent-Protokolle zu öffnen.
Klicke oben rechts in der Protokollanzeige auf die Schaltfläche mit den Auslassungspunkten (...) und dann in der Seitenleiste auf Copilot.
Klicke auf den Schritt Start MCP Servers, um die Protokolle aufzuklappen.
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 GitHub Copilot-Codierungs-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.

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.
Navigieren Sie auf GitHub zur Hauptseite des Repositorys.
Klicke unter dem Repositorynamen auf Settings. Wenn die Registerkarte „Einstellungen“ nicht angezeigt wird, wähle im Dropdownmenü die Option Einstellungen aus.
Klicken Sie im Abschnitt „Code & Automatisierung“ in der Seitenleiste auf Copilot und dann auf Programmier-Agent.

Füge deine Konfiguration im Abschnitt MCP configuration hinzu. Sie können beispielsweise Folgendes hinzufügen:

JavaScript

 // If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
 {
   "mcpServers": {
     "github-mcp-server": {
       "type": "http",
       // Remove "/readonly" to enable wider access to all tools.
       // Then, use the "X-MCP-Toolsets" header to specify which toolsets you'd like to include.
       // Use the "tools" field to select individual tools from the toolsets.
       "url": "https://api.githubcopilot.com/mcp/readonly",
       "tools": ["*"],
       "headers": {
         "X-MCP-Toolsets": "repos,issues,users,pull_requests,code_security,secret_protection,actions,web_search"
       }
     }
   }
 }

 // If you copy and paste this example, you will need to remove the comments prefixed with `//`, which are not valid JSON.
 {
   "mcpServers": {
     "github-mcp-server": {
       "type": "http",
       // Remove "/readonly" to enable wider access to all tools.
       // Then, use the "X-MCP-Toolsets" header to specify which toolsets you'd like to include.
       // Use the "tools" field to select individual tools from the toolsets.
       "url": "https://api.githubcopilot.com/mcp/readonly",
       "tools": ["*"],
       "headers": {
         "X-MCP-Toolsets": "repos,issues,users,pull_requests,code_security,secret_protection,actions,web_search"
       }
     }
   }
 }

Weitere Informationen zu Toolsets finden Sie in der README in der GitHub Remote MCP Server-Dokumentation.

Klicken Sie auf Speichern.
Klicke auf der linken Randleiste auf Umgebungen.
Klicke auf die copilot-Umgebung.
Klicke unter „Environment secrets“ auf Add environment secret.
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

        [AUTOTITLE](/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers)

        [AUTOTITLE](/copilot/how-tos/use-copilot-agents/coding-agent/create-custom-agents)

        [AUTOTITLE](/copilot/customizing-copilot/customizing-the-development-environment-for-copilot-coding-agent)

        [AUTOTITLE](/copilot/customizing-copilot/extending-copilot-chat-with-mcp)

Erweiterung des GitHub Copilot Codierungsagenten mit dem Model Context Protocol (MCP)

In diesem Artikel