Uso de servidores MCP con el SDK de GitHub Copilot

Nota:

Esta es una característica en evolución. Consulte la issue n.º 36 para seguir la discusión en curso.

¿Qué es MCP?

El Protocolo de contexto de modelo (MCP) es un estándar abierto para conectar asistentes de IA a herramientas externas y orígenes de datos. Los servidores MCP pueden:

Ejecutar código o secuencias de comandos
Consulta de bases de datos
Acceso a sistemas de archivos
Llamar a las API externas
Y mucho más

Tipos de servidor

El SDK admite dos tipos de servidores MCP:

Tipo	Description	Caso de uso
Local/Stdio	Se ejecuta como un subproceso, se comunica a través de stdin/stdout.	Herramientas locales, acceso a archivos, scripts personalizados
HTTP/SSE	Servidor remoto al que se accede a través de HTTP	Servicios compartidos, herramientas hospedadas en la nube

Configuración

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

Herramienta de configuración

Puede controlar qué herramientas están disponibles para un servidor MCP mediante el tools campo .

Permitir el acceso a todas las herramientas

Use "*" para habilitar todas las herramientas proporcionadas por el servidor MCP:

tools: ["*"]

Permitir herramientas específicas

Proporcione una lista de nombres de herramientas para restringir el acceso:

tools: ["bash", "edit"]

Solo las herramientas enumeradas estarán disponibles para el agente.

Deshabilitar todas las herramientas

Use una matriz vacía para deshabilitar todas las herramientas:

tools: []

Notes

El tools campo define qué herramientas se permiten.
No existe una configuración independiente de allow o disallow; el acceso de las herramientas se controla directamente mediante esta lista.

Inicio rápido: servidor MCP del sistema de archivos

Este es un ejemplo de trabajo completo mediante el servidor MCP oficial @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.

Sugerencia

Puede usar cualquier servidor MCP desde el directorio de servidores MCP. Entre las opciones populares se incluyen @modelcontextprotocol/server-github, @modelcontextprotocol/server-sqlitey @modelcontextprotocol/server-puppeteer.

Opciones de configuración

Servidor local/stdio

Propiedad	Tipo	Obligatorio	Description
`type`
`"local"` o `"stdio"`	No	Tipo de servidor (el valor predeterminado es local)
`command`	`string`	Yes	Comando para ejecutar
`args`	`string[]`	Yes	Argumentos de comandos
`env`	`object`	No	Variables de entorno
`cwd`	`string`	No	Directorio de trabajo
`tools`	`string[]`	No	Herramientas para habilitar (`["*"]` para todos, `[]` para ninguno)
`timeout`	`number`	No	Tiempo de espera en milisegundos

Servidor remoto (HTTP/SSE)

Propiedad	Tipo	Obligatorio	Description
`type`
`"http"` o `"sse"`	Yes	Tipo de servidor
`url`	`string`	Yes	Dirección URL del servidor
`headers`	`object`	No	Encabezados HTTP (por ejemplo, para la autenticación)
`tools`	`string[]`	No	Herramientas para habilitar
`timeout`	`number`	No	Tiempo de espera en milisegundos

Solución de problemas

Herramientas que no se muestran o no se invocan

Comprobación de que el servidor MCP se inicia correctamente
- Compruebe que el comando y los argumentos son correctos
- Asegúrese de que el proceso del servidor no se bloquea al iniciarse
- Busque la salida de error en stderr
Comprobación de la configuración de la herramienta
- Asegúrese de que tools está establecido en ["*"] o enumera las herramientas específicas que necesita.
- Una matriz [] vacía significa que no hay ninguna herramienta habilitada
Comprobación de la conectividad para servidores remotos
- Asegúrese de que la dirección URL es accesible
- Comprobación de que los encabezados de autenticación son correctos

Problemas comunes

Issue	Solución
"No se encontró el servidor MCP"	Comprobación de que la ruta de acceso del comando es correcta y ejecutable
"Conexión rechazada" (HTTP)	Compruebe la dirección URL y asegúrese de que el servidor se está ejecutando
Errores de tiempo de espera	Aumenta el valor de `timeout` o comprueba el rendimiento del servidor
Las herramientas funcionan pero no son llamadas	Asegúrese de que el mensaje requiere claramente la funcionalidad de la herramienta.

Para obtener instrucciones detalladas sobre la depuración, consulte Guía de depuración del servidor MCP.

Especificación del protocolo de contexto de modelo
Directorio de servidores MCP : servidores MCP de la comunidad
servidor MCP de GitHub: servidor MCP oficial de GitHub
Crea tu primera aplicación con tecnología Copilot : conceptos básicos del SDK y herramientas personalizadas
Guía de depuración - depuración de todo el SDK

Consulte también

Guía de depuración del servidor MCP : solución de problemas detallada de MCP
Problema n.º 9 : pregunta de uso de herramientas de MCP original
Problema n.º 36 : problema de seguimiento de documentación de MCP

Uso de servidores MCP con el SDK de GitHub Copilot

En este artículo