Schnellstart: Integrieren von Azure MCP-Server in GitHub Copilot SDK

In diesem Handbuch wird erläutert, wie Sie das GitHub Copilot SDK so konfigurieren, dass Azure Model Context Protocol (MCP)-Tools für die Interaktion mit Azure-Ressourcen verwendet werden.

Azure MCP bietet eine Reihe von Tools, mit denen KI-Assistenten direkt mit Azure-Ressourcen interagieren können. Wenn Sie mit dem Copilot SDK integriert sind, können Sie Anwendungen erstellen, die natürliche Sprache nutzen, um Azure-Abonnements, Ressourcengruppen, Speicherkonten und vieles mehr zu verwalten.

Voraussetzungen

• GitHub Copilot CLI installiert.
• Node.js installiert (zum Ausführen des Servers über npx).
• Azure CLI installiert und authentifiziert (az login).

Anmelden bei Azure MCP Server für die lokale Entwicklung

Azure MCP Server authentifiziert sich bei Microsoft Entra ID mithilfe der Azure Identity-Bibliothek für .NET. Der Server unterstützt zwei Authentifizierungsmodi:

• Brokermodus: Verwendet die systemeigene Authentifizierung Ihres Betriebssystems (z. B. Windows Web Account Manager) mit InteractiveBrowserCredential.
• Modus der Anmeldeinformationskette: Es wird versucht, mehrere Authentifizierungsmethoden in einer festgelegten Reihenfolge zu verwenden: Umgebungsvariablen, Visual Studio Code, Visual Studio, Azure CLI, Azure PowerShell, Azure Developer CLI und interaktive Browserauthentifizierung.

Melden Sie sich mit einer der folgenden Methoden an:

Visual Studio Code

1. Öffnen Sie die Befehlspalette (Ctrl+Shift+P oder Cmd+Shift+P auf dem Mac).
2. Führen Sie Azure aus: Melden Sie sich an , und folgen Sie den Anweisungen.

Visual Studio

1. Wechseln Sie zu "Datei > Kontoeinstellungen".
2. Wählen Sie "Konto hinzufügen " aus, und folgen Sie den Anweisungen.

Azure CLI

az login

Azure PowerShell

Connect-AzAccount

Azure Developer CLI

azd auth login

Nach der Anmeldung kann Azure MCP Server Vorgänge für Azure-Dienste basierend auf Ihren Berechtigungen authentifizieren und ausführen.

Azure MCP Server-Konfigurationsbeispiel

Unabhängig vom verwendeten Programmier-SDK muss der Azure MCP-Server im App-Kontext konfiguriert werden, damit Tools verfügbar sind. Die grundlegende Konfiguration sieht wie folgt aus:

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

Der tools: ["*"] Parameter ist unerlässlich – es ermöglicht alle Tools vom MCP-Server für die Sitzung.

Integrationsbeispiele

Die folgenden Beispiele zeigen, wie das SDK in verschiedene Sprachen integriert wird.

Hinweis

Für einen schnelleren Start können Sie den Azure MCP Server global installieren, indem Sie npm install -g @azure/mcp@latest verwenden.

Python

Installation

Installieren Sie das Python SDK-Paket mit pip.

pip install github-copilot-sdk

Beispielcode

Der folgende Code veranschaulicht einen vollständigen Fluss:

import asyncio
from copilot import CopilotClient
from copilot.generated.session_events import SessionEventType

async def main():
    # Initialize the Copilot client
    client = CopilotClient({
        "cli_args": [
            "--allow-all-tools",
            "--allow-all-paths",
        ]
    })

    await client.start()

    # Configure Azure MCP server in session config
    azure_mcp_config = {
        "azure-mcp": {
            "type": "local",
            "command": "npx",
            "args": ["-y", "@azure/mcp@latest", "server", "start"],
            "tools": ["*"],  # Enable all Azure MCP tools
        }
    }

    # Create session with MCP servers
    session = await client.create_session({
        "model": "gpt-4.1",  # Default model; BYOK can override
        "streaming": True,
        "mcp_servers": azure_mcp_config,
    })

    # Handle events
    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            if hasattr(event.data, 'delta_content') and event.data.delta_content:
                print(event.data.delta_content, end="", flush=True)
        elif event.type == SessionEventType.TOOL_EXECUTION_START:
            tool_name = getattr(event.data, 'tool_name', 'unknown')
            print(f"\n[TOOL: {tool_name}]")

    session.on(handle_event)

    # Send prompt
    await session.send_and_wait({
        "prompt": "List all resource groups in my Azure subscription"
    })

    await client.stop()

if __name__ == "__main__":
    asyncio.run(main())

Der vorherige Code:

• Initialisiert den Copilot-Client.
• Konfiguriert den Azure MCP-Server mithilfe von npx.
• Erstellt eine Sitzung mit dem GPT-4.1-Modell und aktiviertem Streaming.
• Behandelt Ereignisse zum Drucken von Assistentenantworten und Toolausführungsprotokollen.
• Sendet eine Aufforderung zum Auflisten von Azure-Ressourcengruppen.

Node.js / TypeScript

Installation

Installieren Sie das Node.js SDK-Paket mithilfe von npm.

npm install @github/copilot-sdk

Der folgende Code veranschaulicht einen vollständigen Fluss:

import { CopilotClient } from '@github/copilot-sdk';
import type { MCPLocalServerConfig } from '@github/copilot-sdk';

async function main() {
  // Initialize the Copilot client
  const client = new CopilotClient({
    cliArgs: [
      '--allow-all-tools',
      '--allow-all-paths',
    ]
  });

  await client.start();

  // Configure Azure MCP server in session config
  const azureMcpConfig: Record<string, MCPLocalServerConfig> = {
    'azure-mcp': {
      type: 'local',
      command: 'npx',
      args: ['-y', '@azure/mcp@latest', 'server', 'start'],
      tools: ['*'],  // Enable all Azure MCP tools
    }
  };

  // Create session with MCP servers
  const session = await client.createSession({
    model: 'gpt-4.1',  // Default model; BYOK can override
    streaming: true,
    mcpServers: azureMcpConfig,
  });

  // Handle events
  session.on((event) => {
    if (event.type === 'assistant.message_delta') {
      if (event.data?.deltaContent) {
        process.stdout.write(event.data.deltaContent);
      }
    } else if (event.type === 'tool.execution_start') {
      const toolName = event.data?.toolName || 'unknown';
      console.log(`\n[TOOL: ${toolName}]`);
    }
  });

  // Send prompt
  await session.sendAndWait({
    prompt: 'List all resource groups in my Azure subscription 16caa5c4-46f1-4bfd-8c1b-a99f1efc8845'
  });

  await client.stop();
}

main().catch(console.error);

Der vorherige Code:

• Initialisiert den Copilot-Client.
• Konfiguriert den Azure MCP-Server mithilfe von npx.
• Erstellt eine Sitzung mit dem GPT-4.1-Modell und aktiviertem Streaming.
• Behandelt Ereignisse zum Ausdrucken von Antworten des Assistenten und Toolausführungsprotokollen.
• Sendet eine Aufforderung zum Auflisten von Azure-Ressourcengruppen.

.NET

Installation

Fügen Sie dem Projekt den Inhalt des NuGet-Pakets hinzu.

dotnet add package GitHub.Copilot.SDK

Beispielcode

Der folgende C#-Code veranschaulicht einen vollständigen Fluss:

using GitHub.Copilot.SDK;

// Initialize the Copilot client
await using var client = new CopilotClient(new CopilotClientOptions
{
    CliArgs = new[] { "--allow-all-tools", "--allow-all-paths" }
});

await client.StartAsync();

// Configure Azure MCP server in session config
var mcpServers = new Dictionary<string, object>
{
    ["azure-mcp"] = new McpLocalServerConfig
    {
        Type = "local",
        Command = "npx",
        Args = ["-y", "@azure/mcp@latest", "server", "start"],
        Tools = ["*"]  // Enable all Azure MCP tools
    }
};

// Create session with MCP servers
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-4.1",  // Default model; BYOK can override
    Streaming = true,
    McpServers = mcpServers
});

// Handle events
session.On(evt =>
{
    if (evt is AssistantMessageDeltaEvent delta)
    {
        if (!string.IsNullOrEmpty(delta.Data.DeltaContent))
        {
            Console.Write(delta.Data.DeltaContent);
        }
    }
    else if (evt is ToolExecutionStartEvent toolStart)
    {
        Console.WriteLine($"\n[TOOL: {toolStart.Data.ToolName}]");
    }
});

// Send prompt
await session.SendAndWaitAsync(new MessageOptions
{
    Prompt = "List all resource groups in my Azure subscription"
});

Der vorherige Code:

• Initialisiert den Copilot-Client.
• Konfiguriert den Azure MCP-Server mithilfe von npx.
• Erstellt eine Sitzung mit dem GPT-4.1-Modell und aktiviertem Streaming.
• Behandelt Ereignisse zum Drucken von Assistentenantworten und Toolausführungsprotokollen.
• Sendet eine Aufforderung zum Auflisten von Azure-Ressourcengruppen.

Los geht's

Installation

Das Go SDK-Paket mit go get abrufen.

go get github.com/github/copilot-sdk/go

Beispielcode

Der folgende Code veranschaulicht einen vollständigen Fluss:

package main

import (
    "context"
    "fmt"
    "log"

    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()

    // Initialize the Copilot client
    client, err := copilot.NewClient(copilot.ClientOptions{
        CLIArgs: []string{
            "--allow-all-tools",
            "--allow-all-paths",
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop(ctx)

    // Configure Azure MCP server in session config
    azureMcpConfig := map[string]copilot.MCPServerConfig{
        "azure-mcp": {
            Type:    "local",
            Command: "npx",
            Args:    []string{"-y", "@azure/mcp@latest", "server", "start"},
            Tools:   []string{"*"}, // Enable all Azure MCP tools
        },
    }

    // Create session with MCP servers
    session, err := client.CreateSession(ctx, copilot.SessionConfig{
        Model:      "gpt-4.1",  // Default model; BYOK can override
        Streaming:  true,
        MCPServers: azureMcpConfig,
    })
    if err != nil {
        log.Fatal(err)
    }

    // Handle events
    session.OnEvent(func(event copilot.SessionEvent) {
        switch event.Type {
        case copilot.AssistantMessageDelta:
            if event.Data.DeltaContent != "" {
                fmt.Print(event.Data.DeltaContent)
            }
        case copilot.ToolExecutionStart:
            fmt.Printf("\n[TOOL: %s]\n", event.Data.ToolName)
        }
    })

    // Send prompt
    err = session.SendAndWait(ctx, copilot.Message{
        Prompt: "List all resource groups in my Azure subscription",
    })
    if err != nil {
        log.Fatal(err)
    }
}

Der vorherige Code:

• Initialisiert den Copilot-Client.
• Konfiguriert den Azure MCP-Server mithilfe von npx.
• Erstellt eine Sitzung mit dem GPT-4.1-Modell und aktiviertem Streaming.
• Behandelt Ereignisse zum Drucken von Assistentenantworten und Toolausführungsprotokollen.
• Sendet eine Aufforderung zum Auflisten von Azure-Ressourcengruppen.