Verbinden von Agents mit externen Tools

Stellen Sie eine Verbindung Copilot-Cloud-Agent mit externen Tools und Datenquellen über das Model Context Protocol (MCP) her.

In diesem Artikel

Voraussetzung

Bevor Sie einen MCP-Server für Copilot-Cloud-Agent einrichten, lesen Sie Model Context Protocol (MCP) und GitHub Copilot Cloud-Agent, um sicherzustellen, dass Sie die Konzepte rund um MCP-Server und Copilot-Cloud-Agent verstehen.

Introduction

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. Sie geben die JSON-Konfiguration direkt bei den Einstellungen für das Repository GitHub.com ein.

Organisations- und Unternehmensadministratoren können auch MCP-Server als Teil von Benutzerdefinierte Agenten konfigurieren, indem sie YAML-Frontmatter verwenden. Weitere Informationen findest du unter Konfiguration von benutzerdefinierten Agents.

Warnung

Nachdem Sie einen MCP-Server konfiguriert haben, Copilot können Sie die vom Server bereitgestellten Tools autonom verwenden und werden vor der Verwendung nicht mehr um Ihre Genehmigung bitten.

Hinweis

* Copilot-Cloud-Agent unterstützt nur Tools, die von MCP-Servern bereitgestellt werden. Ressourcen oder Prompts werden nicht unterstützt. * Copilot-Cloud-Agent unterstützt derzeit keine Remote-MCP-Server, die OAuth für Authentifizierung und Autorisierung nutzen.

Hinzufügen einer MCP-Konfiguration zu deinem Repository

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

  1. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

  2. Klicke unter dem Repositorynamen auf Settings. 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. Klicken Sie im Abschnitt "Code & Automatisierung" der Randleiste auf Copilot dann Cloudagent.

  4. 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.

  5. Klicke auf Speichern.

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

  6. Wenn Ihr MCP-Server eine Variable, einen Schlüssel oder ein Geheimnis benötigt, fügen Sie für Copilot-Cloud-Agent einen Geheimnis oder eine Variable hinzu, deren Name mit dem Präfix COPILOT_MCP_ versehen ist. Nur Agentgeheimnisse und Variablen, deren Namen mit COPILOT_MCP_ beginnen, stehen Ihrer MCP-Konfiguration zur Verfügung. Siehe Konfigurieren von geheimen Schlüsseln und Variablen für Copilot Cloud-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 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-Cloud-Agent 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 (freiwillig). 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:
    • Ein Ersetzungsverweis auf ein Geheimnis oder eine Variable in Ihrer Copilot Umgebung, wie zum Beispiel $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 (freiwillig). Die Header, die an Anforderungen an den Server angefügt werden sollen. Dieses Objekt sollte den Namen der Kopfzeilenschlüssel einem der folgenden Zuordnen:
    • Ein Ersetzungsverweis auf ein Geheimnis oder eine Variable in Ihrer Copilot Umgebung, wie zum Beispiel $COPILOT_MCP_API_KEY oder ${COPILOT_MCP_API_KEY}. Referenzierte Namen müssen mit COPILOT_MCP_ beginnen.
    • Ein Literalwert einer Zeichenkette.

Beachten Sie, dass alle string und string[] Felder, außer tools und type, die Ersetzung durch eine von Ihnen in Ihrer Copilot-Umgebung konfigurierte Variable oder ein Geheimnis unterstützen.

Variablenersetzung

Die folgenden Syntaxmuster werden für referenzierende Umgebungsvariablen unterstützt, die in Ihrer Copilot Umgebung konfiguriert sind:

SyntaxExample
$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.

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"],
      "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 Notizen 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

Das Microsoft MCP-Repository enthält den Azure MCP-Server, der es Copilot ermöglicht, Ihre Azure spezifischen Dateien und Azure Ressourcen in Ihrem Abonnement zu verstehen, wenn Codeänderungen vorgenommen werden.

Um Ihr Repository automatisch mit einer copilot-setup-steps.yml Datei zur Authentifizierung bei Azure zu konfigurieren und dabei Geheimnisse für die Authentifizierung hinzuzufügen, klonen Sie das Repository lokal, und führen Sie dann den Befehl der Azure Developer CLI im Stammverzeichnis des Repositorys azd cloud-agent config 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": ["*"]
     }
   }
 }

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": ["*"]
    }
  }
}

Beispiel: Azure DevOps

Der Azure DevOps MCP-Server erstellt eine nahtlose Verbindung zwischen Copilot und Ihren Azure DevOps-Diensten, einschließlich Arbeitsaufgaben, Pipelines oder Dokumentationen.

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

  1. Konfigurieren Sie OIDC in einer Microsoft Entra-Anwendung, die vertrauenswürdig ist GitHub. Weitere Informationen finden Sie unter Use the Azure Login action with OpenID Connect.

  2. Richten Sie 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.

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

  4. 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

    Diese Konfiguration stellt sicher, dass die azure/login-Aktion ausgeführt wird, wenn Copilot-Cloud-Agent ausgeführt wird.

  5. Konfigurieren Sie Geheimnisse für Ihre AZURE_CLIENT_ID und AZURE_TENANT_ID als Agent Secrets, entweder auf der Organisationsebene oder auf der Repositoryebene. Weitere Informationen findest du unter Konfigurieren von geheimen Schlüsseln und Variablen für Copilot Cloud-Agent.

  6. Konfigurieren Sie den Azure DevOps MCP-Server, indem Sie Ihrer MCP-Konfiguration ein ado-Objekt hinzufügen, indem Sie die definierten Tools spezifizieren, die Copilot-Cloud-Agent verwenden soll.

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

Beispiel: Atlassian

Der Atlassian MCP-Server gewährt 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"
      }
    }
  }
}

Wiederverwenden Ihrer MCP-Konfiguration von Visual Studio Code

Wenn Sie MCP-Server bereits in VS Code konfiguriert haben, können Sie eine ähnliche Konfiguration für Copilot-Cloud-Agent nutzen.

Je nachdem, wie VS Code sie konfiguriert ist, können Sie möglicherweise Ihre MCP-Einstellungen in der Datei Ihres Repositorys .vscode/mcp.json oder in der privaten settings.json Datei Ihres Computers finden.

Um die Konfiguration für Copilot-Cloud-Agent anzupassen, müssen Sie:

  1. Fügen Sie einen tools Schlüssel für jeden MCP-Server hinzu, um anzugeben, welche Tools für Copilot verfügbar sein werden.
  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 finden Sie in VS Codeden VS Code Dokumentationen.

Überprüfen einer MCP-Konfiguration

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

  1. Erstellen Sie ein Problem im Repository, und weisen Sie es dann zu Copilot.
  2. Warten Sie einige Sekunden, und Copilot wird eine 👀-Reaktion auf das Problem hinterlassen.
  3. Warten Sie einige weitere Sekunden, und Copilot wird einen Pull Request erstellen, der in der Timeline des Issues angezeigt wird.
  4. Klicken Sie auf die erstellte Pull-Anfrage in der Zeitleiste und warten Sie, bis ein Zeitleistenereignis "Copilot hat die Arbeit begonnen" angezeigt wird.
  5. Klicken Sie auf "Sitzung anzeigen" , um die Copilot-Cloud-Agent Protokolle zu öffnen.
  6. Klicken Sie im Protokollanzeiger oben rechts auf die Schaltfläche mit den Auslassungspunkten (...) und dann auf Copilot in der Randleiste.
  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 Ihre MCP-Server Abhängigkeiten erforderlich sind, die standardmäßig nicht auf dem GitHub Actions Runner installiert sind, z. B. uv und pipx, oder für die spezielle Setupschritte erforderlich sind, müssen Sie möglicherweise eine copilot-setup-steps.yml Actions-Workflowdatei erstellen, um sie zu installieren. Weitere Informationen findest du unter Konfigurieren der Entwicklungsumgebung.

Anpassen des integrierten MCP-Servers GitHub

Der GitHub MCP-Server ist standardmäßig aktiviert und verbindet sich mit GitHub durch einen speziell bereichsbezogenen Token, der lediglich einen schreibgeschützten Zugriff auf das aktuelle Repository bereitstellt.

Wenn Sie Copilot den Zugriff auf Daten außerhalb des aktuellen Repositories erlauben möchten, können Sie ihm einen personal access token mit breiterem Zugang gewähren.

  1. Erstellen Sie eine personal access token mit den entsprechenden Berechtigungen. Wir empfehlen die Verwendung eines fine-grained personal access token, mit dem Sie den Zugriff des Tokens auf schreibgeschützte Berechtigungen für bestimmte Repositories beschränken können. Weitere Informationen personal access tokensfinden Sie unter Verwalten deiner persönlichen Zugriffstoken.

  2. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

  3. Klicke unter dem Repositorynamen auf Settings. 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.

  4. Klicken Sie im Abschnitt "Code & Automatisierung" der Randleiste auf Copilot dann Cloudagent.

  5. 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"
       }
     }
   }
 }

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

  6. Klicke auf Speichern.

  7. Fügen Sie ein Geheimnis namens COPILOT_MCP_GITHUB_PERSONAL_ACCESS_TOKEN mit Ihrem personal access token als Wert hinzu. Sie können dies entweder auf Organisationsebene oder auf Repositoryebene konfigurieren. Weitere Informationen findest du unter Konfigurieren von geheimen Schlüsseln und Variablen für Copilot Cloud-Agent.

Informationen zur Verwendung des GitHub MCP-Servers in anderen Umgebungen finden Sie unter Verwenden des GitHub MCP-Servers in Ihrer IDE.

Nächste Schritte