Démarrage rapide : Intégrer Azure MCP Server à GitHub Copilot SDK

Ce guide explique comment configurer le Kit de développement logiciel (SDK) GitHub Copilot pour utiliser les outils MCP (Model Context Protocol) Azure pour interagir avec les ressources Azure.

Azure MCP fournit un ensemble d’outils qui permettent aux assistants IA d’interagir directement avec les ressources Azure. Lorsqu’il est intégré au Kit de développement logiciel (SDK) Copilot, vous pouvez créer des applications qui tirent parti du langage naturel pour gérer les abonnements Azure, les groupes de ressources, les comptes de stockage, etc.

Prerequisites

GitHub Copilot CLI installé.
Node.js installé (pour l’exécution du serveur via npx).
Azure CLI installé et authentifié (az login).

Azure MCP Server s’authentifie auprès de Microsoft Entra ID à l’aide de la bibliothèque Azure Identity pour .NET. Le serveur prend en charge deux modes d’authentification :

Mode Broker : utilise l’authentification native de votre système d’exploitation (comme le Gestionnaire de comptes web Windows) avec InteractiveBrowserCredential.
Mode chaîne des informations d'identification : essaie plusieurs méthodes d’authentification successivement : variables d’environnement, Visual Studio Code, Visual Studio, Azure CLI, Azure PowerShell, Azure Developer CLI et authentification interactive par navigateur.

Connectez-vous à l’aide de l’une de ces méthodes :

Ouvrez la palette de commandes (Ctrl+Shift+P ou Cmd+Shift+P sur Mac).
Exécutez Azure : connectez-vous et suivez les invites.

az login

Connect-AzAccount

azd auth login

Une fois connecté, azure MCP Server peut authentifier et exécuter des opérations sur les services Azure en fonction de vos autorisations.

Exemple de configuration de serveur MCP Azure

Quel que soit le Kit de développement logiciel (SDK) de programmation que vous utilisez, le serveur Azure MCP doit être configuré dans le contexte de l’application pour que les outils soient disponibles. La configuration essentielle ressemble à ce qui suit :

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

Le tools: ["*"] paramètre est essentiel : il active tous les outils du serveur MCP pour la session.

Exemples d’intégration

Les exemples suivants montrent comment intégrer le Kit de développement logiciel (SDK) dans différents langages.

Note

Pour un démarrage plus rapide, vous pouvez installer Azure MCP Server globalement à l’aide de npm install -g @azure/mcp@latest.

Installation

Installez le package du Kit de développement logiciel (SDK) Python à l’aide de pip.

pip install github-copilot-sdk

Exemple de code

Le code suivant illustre un flux complet :

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())

Code précédent :

Initialise le client Copilot.
Configurez le serveur Azure MCP à l’aide de npx.
Crée une session avec le modèle GPT-4.1 et la diffusion en continu activées.
Gère les événements pour imprimer les réponses de l’Assistant et les journaux d’exécution des outils.
Envoie une invite pour répertorier les groupes de ressources Azure.

Installation

Installez le package Node.js SDK à l’aide de npm.

npm install @github/copilot-sdk

Le code suivant illustre un flux complet :

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);

Code précédent :

Initialise le client Copilot.
Configure le serveur Azure MCP à l’aide de npx.
Crée une session avec le modèle GPT-4.1 et la diffusion en continu activées.
Gère les événements pour afficher les réponses de l'assistant et les journaux d’exécution des outils.
Envoie une invite pour répertorier les groupes de ressources Azure.

Installation

Ajoutez le contenu du package NuGet à votre projet.

dotnet add package GitHub.Copilot.SDK

Exemple de code

Le code C# suivant illustre un flux complet :

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"
});

Code précédent :

Initialise le client Copilot.
Configure le serveur Azure MCP à l’aide de npx.
Crée une session avec le modèle GPT-4.1 et la diffusion en continu activées.
Gère les événements pour imprimer les réponses de l’assistant et les journaux d’exécution des outils.
Envoie une invite pour répertorier les groupes de ressources Azure.

Installation

Obtenez le package du Kit de développement logiciel (SDK) Go à l'aide de go get.

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

Exemple de code

Le code suivant illustre un flux complet :

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)
    }
}

Code précédent :

Initialise le client Copilot.
Configurez le serveur Azure MCP à l’aide de npx.
Crée une session avec le modèle GPT-4.1 et la diffusion en continu activées.
Gère les événements pour imprimer les réponses de l’assistant et les journaux d'exécution des outils.
Envoie une invite pour répertorier les groupes de ressources Azure.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-25

Partager via

Démarrage rapide : Intégrer Azure MCP Server à GitHub Copilot SDK

Prerequisites

Se connecter au serveur Azure MCP pour le développement local

Exemple de configuration de serveur MCP Azure

Exemples d’intégration

Installation

Exemple de code

Commentaires

Ressources supplémentaires