Verwenden von MCP-Servern mit dem GitHub Copilot SDK

Hinweis

Dies ist ein sich entwickelndes Feature. Siehe Problem Nr. 36 zur laufenden Diskussion.

Was ist MCP?

Model Context Protocol (MCP) ist ein offener Standard zum Verbinden von KI-Assistenten mit externen Tools und Datenquellen. MCP-Server können:

Ausführen von Code oder Skripts
Abfragedatenbanken
Auf Dateisysteme zugreifen
Aufrufen externer APIs
Und vieles mehr

Servertypen

Das SDK unterstützt zwei Arten von MCP-Servern:

Typ	Description	Anwendungsfall
Local/Stdio	Wird als Teilprozess ausgeführt, kommuniziert über stdin/stdout	Lokale Tools, Dateizugriff, benutzerdefinierte Skripts
HTTP/SSE	Remoteserver, auf den über HTTP zugegriffen wird	Gemeinsame Dienste, in der Cloud gehostete Tools

Configuration

Node.js / TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({
    model: "gpt-5",
    mcpServers: {
        // Local MCP server (stdio)
        "my-local-server": {
            type: "local",
            command: "node",
            args: ["./mcp-server.js"],
            env: { DEBUG: "true" },
            cwd: "./servers",
            tools: ["*"],  // "*" = all tools, [] = none, or list specific tools
            timeout: 30000,
        },
        // Remote MCP server (HTTP)
        "github": {
            type: "http",
            url: "https://api.githubcopilot.com/mcp/",
            headers: { "Authorization": "Bearer ${TOKEN}" },
            tools: ["*"],
        },
    },
});

Python

import asyncio
from copilot import CopilotClient
from copilot.session import PermissionHandler

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-5", mcp_servers={
        # Local MCP server (stdio)
        "my-local-server": {
            "type": "local",
            "command": "python",
            "args": ["./mcp_server.py"],
            "env": {"DEBUG": "true"},
            "cwd": "./servers",
            "tools": ["*"],
            "timeout": 30000,
        },
        # Remote MCP server (HTTP)
        "github": {
            "type": "http",
            "url": "https://api.githubcopilot.com/mcp/",
            "headers": {"Authorization": "Bearer ${TOKEN}"},
            "tools": ["*"],
        },
    })

    response = await session.send_and_wait("List my recent GitHub notifications")
    print(response.data.content)

    await client.stop()

asyncio.run(main())

Go

package main

import (
    "context"
    "log"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, err := client.CreateSession(ctx, &copilot.SessionConfig{
        Model: "gpt-5",
        MCPServers: map[string]copilot.MCPServerConfig{
            "my-local-server": copilot.MCPStdioServerConfig{
                Command: "node",
                Args:    []string{"./mcp-server.js"},
                Tools:   []string{"*"},
            },
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    defer session.Disconnect()

    // Use the session...
}

.NET

using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-5",
    McpServers = new Dictionary<string, McpServerConfig>
    {
        ["my-local-server"] = new McpStdioServerConfig
        {
            Command = "node",
            Args = new List<string> { "./mcp-server.js" },
            Tools = new List<string> { "*" },
        },
    },
});

Deaktivieren konfigurierter Server pro Sitzung

Legen Sie disabledMcpServers auf genaue MCP-Servernamen fest, die nicht in einer Sitzung ausgeführt werden dürfen. Die Einstellung ist auf die individuelle Erstellungs- oder Fortsetzungsanforderung festgelegt; es ändert keine globalen MCP-Einstellungen oder die Serverkonfiguration.

const session = await client.createSession({
    mcpServers: {
        filesystem: { type: "local", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "."] },
        github: { type: "http", url: "https://api.githubcopilot.com/mcp/" },
    },
    disabledMcpServers: ["github"],
});

SDK	Konfigurationseigenschaft
Node.js	`disabledMcpServers`
Python	`disabled_mcp_servers`
Go	`DisabledMCPServers`
.NET	`DisabledMcpServers`
Java	`setDisabledMcpServers(...)`
Rust	`with_disabled_mcp_servers(...)`

Bei der Sitzungserstellung und beim Fortsetzen nach einem Kaltstart werden deaktivierte Server nicht gestartet, und die Laufzeitumgebung stößt deren Authentifizierung nicht an. Ein Fortsetzen im residenten Modus kann einen Server, den die Laufzeitumgebung bereits gestartet hat, nicht rückgängig machen. Namen werden exakt abgeglichen.

Werkzeugkonfiguration

Mithilfe des tools Felds können Sie steuern, welche Tools für einen MCP-Server verfügbar sind.

Alle Werkzeuge zulassen

Verwenden Sie "*", um alle vom MCP-Server bereitgestellten Tools zu aktivieren:

tools: ["*"]

Bestimmte Tools zulassen

Stellen Sie eine Liste der Toolnamen bereit, um den Zugriff einzuschränken:

tools: ["bash", "edit"]

Nur die aufgeführten Tools sind für den Agent verfügbar.

Alle Tools deaktivieren

Verwenden Sie ein leeres Array, um alle Tools zu deaktivieren:

tools: []

Notes

Das tools Feld definiert, welche Tools zulässig sind.
Es gibt keine separate allow Konfiguration oder disallow Konfiguration– der Toolzugriff wird direkt über diese Liste gesteuert.

Schnellstart: Dateisystem-MCP-Server

Hier ist ein vollständiges Arbeitsbeispiel mit dem offiziellen @modelcontextprotocol/server-filesystem MCP-Server:

import { CopilotClient } from "@github/copilot-sdk";

async function main() {
    const client = new CopilotClient();

    // Create session with filesystem MCP server
    const session = await client.createSession({
        mcpServers: {
            filesystem: {
                type: "local",
                command: "npx",
                args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
                tools: ["*"],
            },
        },
    });

    console.log("Session created:", session.sessionId);

    // The model can now use filesystem tools
    const result = await session.sendAndWait({
        prompt: "List the files in the allowed directory",
    });

    console.log("Response:", result?.data?.content);

    await session.disconnect();
    await client.stop();
}

main();

Ausgabe:

Session created: 18b3482b-bcba-40ba-9f02-ad2ac949a59a
Response: The allowed directory is `/tmp`, which contains various files
and subdirectories including temporary system files, log files, and
directories for different applications.

Tipp

Sie können jeden MCP-Server aus dem MCP-Serververzeichnis verwenden. Zu den beliebten Optionen gehören @modelcontextprotocol/server-github, @modelcontextprotocol/server-sqliteund @modelcontextprotocol/server-puppeteer.

Konfigurationsoptionen

Lokaler/stdio-Server

Eigentum	Typ	Erforderlich	Description
`type`
`"local"` oder `"stdio"`	No	Servertyp (Standardmäßig lokal)
`command`	`string`	Yes	Auszuführende Befehl
`args`	`string[]`	Yes	Befehlsargumente
`env`	`object`	No	Umgebungsvariablen
`cwd`	`string`	No	Arbeitsverzeichnis
`tools`	`string[]`	No	Zu aktivierende Tools (`["*"]` für alle, `[]` für keine)
`timeout`	`number`	No	Timeout in Millisekunden

Remoteserver (HTTP/SSE)

Eigentum	Typ	Erforderlich	Description
`type`
`"http"` oder `"sse"`	Yes	Servertyp
`url`	`string`	Yes	Server-URL
`headers`	`object`	No	HTTP-Header (z. B. für Authentifizierung)
`tools`	`string[]`	No	Zu aktivierende Tools
`timeout`	`number`	No	Timeout in Millisekunden

Problembehandlung

Tools werden nicht angezeigt oder nicht aufgerufen

Überprüfen, ob der MCP-Server ordnungsgemäß gestartet wird
- Überprüfen Sie, ob der Befehl und die Argumente korrekt sind.
- Sicherstellen, dass der Serverprozess beim Start nicht abstürzt
- Suchen Sie in stderr nach Fehlerausgaben
Überprüfen der Toolkonfiguration
- Stellen Sie sicher, dass tools auf ["*"] festgelegt ist oder die spezifischen Tools auflistet, die Sie benötigen.
- Ein leeres Array [] bedeutet, dass keine Tools aktiviert sind.
Überprüfen der Konnektivität für Remoteserver
- Sicherstellen, dass auf die URL zugegriffen werden kann
- Überprüfen, ob Authentifizierungsheader korrekt sind

Häufig auftretende Probleme

Issue	Lösung
"MCP-Server nicht gefunden"	Überprüfen, ob der Befehlspfad korrekt und ausführbar ist
"Verbindung verweigert" (HTTP)	Überprüfen Sie die URL, und stellen Sie sicher, dass der Server ausgeführt wird.
Timeout-Fehler	Erhöhen Sie den `timeout` Wert oder überprüfen Sie die Serverleistung.
Tools funktionieren, werden aber nicht aufgerufen	Stellen Sie sicher, dass Ihre Eingabeaufforderung die Funktionalität des Tools eindeutig erfordert.

Ausführliche Anleitungen zum Debuggen finden Sie unter MCP-Serverdebugginghandbuch.

Model Context Protocol - Spezifikation
MCP-Serververzeichnis – MCP-Server der Community
GitHub MCP Server - Offizieller GitHub MCP-Server
Erstellen Sie Ihre erste Copilot-gestützte App – SDK-Grundlagen und benutzerdefinierte Tools
Debughandbuch – SDK-weites Debuggen

Siehe auch

MCP-Serverdebugginghandbuch – Detaillierte MCP-Problembehandlung
Problem Nr. 9 – Ursprüngliche MCP-Tools– Verwendungsfrage
Problem Nr. 36 – MCP-Dokumentation zur Nachverfolgung des Problems

Verwenden von MCP-Servern mit dem GitHub Copilot SDK

In diesem Artikel