Utilisation de serveurs MCP avec le SDK GitHub Copilot

Le sdk Copilot peut s'intégrer à des serveurs MCP (protocole de contexte de modèle) pour étendre les fonctionnalités de l'assistant à des outils externes. Les serveurs MCP s’exécutent en tant que processus distincts et exposent des outils (fonctions) que Copilot peuvent appeler pendant les conversations.

Dans cet article

Remarque

Il s’agit d’une fonctionnalité en constante évolution. Consultez le problème n° 36 pour une discussion en cours.

Qu’est-ce que MCP ?

Le protocole MCP (Model Context Protocol) est un standard ouvert pour connecter des assistants IA à des outils et sources de données externes. Les serveurs MCP peuvent :

  • Exécuter du code ou des scripts
  • Interroger des bases de données
  • Accéder aux systèmes de fichiers
  • Appeler des API externes
  • Et bien plus encore

Types de serveurs

Le Kit de développement logiciel (SDK) prend en charge deux types de serveurs MCP :

TypeDescriptionCas d’usage
Local/StdioS’exécute en tant que sous-processus, communique via stdin/stdoutOutils locaux, accès aux fichiers, scripts personnalisés
HTTP/SSEServeur distant accessible via HTTPServices partagés, outils hébergés dans le cloud

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

Configuration de l’outil

Vous pouvez contrôler les outils disponibles pour un serveur MCP à l’aide du tools champ.

Autoriser tous les outils

Permet "*" d’activer tous les outils fournis par le serveur MCP :

tools: ["*"]

Autoriser des outils spécifiques

Fournissez la liste des noms d’outils pour restreindre l’accès :

tools: ["bash", "edit"]

Seuls les outils répertoriés seront disponibles pour l’agent.

Désactiver tous les outils

Utilisez un tableau vide pour désactiver tous les outils :

tools: []

Notes

  • Le tools champ définit les outils autorisés.
  • Il n’existe pas de configuration distincte allow ou disallow : l’accès aux outils est contrôlé directement par cette liste.

Démarrage rapide : serveur MCP du système de fichiers

Voici un exemple de travail complet utilisant le serveur MCP officiel @modelcontextprotocol/server-filesystem :

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

Output:

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.

Conseil

Vous pouvez utiliser n’importe quel serveur MCP à partir du répertoire des serveurs MCP. Les options populaires incluent @modelcontextprotocol/server-github, @modelcontextprotocol/server-sqliteet @modelcontextprotocol/server-puppeteer.

Options de configuration

Serveur local/stdio

PropriétéTypeObligatoireDescription
type
"local" ou "stdio"NonType de serveur (par défaut en local)
commandstringYesCommande à exécuter
argsstring[]YesLes arguments de la commande
envobjectNonVariables d’environnement
cwdstringNonRépertoire de travail
toolsstring[]NonOutils à activer (["*"] pour tous, [] pour aucun)
timeoutnumberNonDélai d’expiration en millisecondes

Serveur distant (HTTP/SSE)

PropriétéTypeObligatoireDescription
type
"http" ou "sse"YesType de serveur
urlstringYesURL du serveur
headersobjectNonEn-têtes HTTP (par exemple, pour l’authentification)
toolsstring[]NonOutils à activer
timeoutnumberNonDélai d’expiration en millisecondes

Troubleshooting

Les outils ne s’affichent pas ou ne sont pas appelés

  1. Vérifier que le serveur MCP démarre correctement

    • Vérifiez que la commande et les arguments sont corrects
    • Vérifier que le processus du serveur ne se bloque pas au démarrage
    • Recherchez la sortie d’erreur dans stderr

  2. Vérifier la configuration de l’outil

    • Assurez-vous que tools est défini sur ["*"] ou répertorie les outils spécifiques dont vous avez besoin
    • Un tableau [] vide signifie qu’aucun outil n’est activé

  3. Vérifier la connectivité pour les serveurs distants

    • Vérifier que l’URL est accessible
    • Vérifier que les en-têtes d’authentification sont corrects

Problèmes courants

IssueSolution
« Serveur MCP introuvable »Vérifier que le chemin de commande est correct et exécutable
« Connexion refusée » (HTTP)Vérifiez l’URL et vérifiez que le serveur est en cours d’exécution
Erreurs « Délai d’expiration »Augmenter la valeur ou vérifier les performances du timeout serveur
Les outils fonctionnent, mais ne sont pas appelésAssurez-vous que votre invite nécessite clairement la fonctionnalité de l’outil

Pour obtenir des instructions détaillées sur le débogage, consultez autoTITLE.

Voir aussi