Configuración de servidores MCP en GitHub Copilot: registro, lista de permitidos y config

Tu primer servidor MCP en GitHub Copilot se conecta en unos dos minutos. Lograr que el equipo de seguridad apruebe ese mismo servidor, aparezca en un registro y figure en una lista de permitidos ocupa el resto de la semana, a menos que sepas qué hace cada ajuste. Este artículo sigue las tres capas en orden: el archivo de configuración que escribe el desarrollador, el registro que consulta el equipo y la lista de permitidos que aplica el administrador. Cada ejemplo JSON coincide con la documentación actual de GitHub y VS Code, y cada limitación aparece señalada justo donde afecta.

💡 Versión corta: los desarrolladores escriben mcp.json, los equipos eligen servidores de un registro y los administradores aplican allowedMcpServers en managed-settings.json. Tres archivos, tres responsables, y un fallo en cualquiera de ellos hace que parezca que "Copilot no tiene herramientas".

Qué hace MCP dentro de Copilot

El Model Context Protocol (MCP) es el estándar abierto que permite a Copilot llamar a herramientas que viven fuera del editor: una consulta a una base de datos, la búsqueda de una incidencia en Sentry, una sesión de navegador o un gestor de tickets. Sin MCP, Copilot solo ve lo que te muestra el editor. Con MCP, el modo agente puede leer la incidencia que falla, consultar los datos que hay detrás y luego editar el código que causó el problema, todo en una misma conversación.

Cada servidor expone herramientas, y Copilot te pide aprobación antes de que el agente ejecute una. Los servidores locales se comunican por stdio, lo que significa que Copilot lanza un proceso en tu equipo. Los servidores remotos se comunican por HTTP en streaming o por el transporte SSE, más antiguo, lo que significa que Copilot se conecta a una URL. Esa diferencia, un comando frente a una URL, determina casi todas las decisiones de configuración que vienen después: qué campos JSON escribes, cómo funciona la autenticación y cómo puede una lista de permitidos identificar al servidor.

Qué clientes lo admiten

La configuración de MCP no es idéntica en todas las superficies de Copilot. El archivo y el formato cambian en cada una:

Archivos de configuración y dónde se guardan

Si colocas el archivo en el lugar equivocado, Copilot lo ignora sin mostrar ningún error evidente. Empieza por decidir quién debe tener el servidor.

Ámbito de espacio de trabajo frente a ámbito de usuario

.vscode/mcp.json vive en el repositorio, así que todos los que lo clonen reciben los mismos servidores. Por eso es el lugar adecuado para herramientas del proyecto, como un inspector de base de datos o un navegador Playwright. La configuración de tu perfil de usuario se aplica a todos los espacios de trabajo de tu equipo. Ábrela desde la paleta de comandos con MCP: Open User Configuration y guarda ahí las herramientas personales.

Una regla simple funciona: si un compañero se confundiría al no encontrar el servidor, guárdalo en el repositorio. Si solo lo usas tú, guárdalo en tu perfil.

Archivos portables para otros clientes

La referencia de configuración de MCP en VS Code también describe un formato portable: .mcp.json en la raíz del espacio de trabajo, o ~/.copilot/mcp-config.json para tu usuario. Úsalo cuando el mismo repositorio se abra desde más de un cliente de Copilot y quieras una sola definición en lugar de tres.

Cada entrada de servidor se construye con el mismo conjunto reducido de campos:

Existen dos extras solo en macOS y Linux: un objeto sandbox de nivel superior (reglas de sistema de archivos y de red) y un interruptor sandboxEnabled por servidor.

Escribe tu primer mcp.json

Puedes escribir el archivo a mano o ejecutar MCP: Add Server desde la paleta de comandos y dejar que VS Code genere la entrada. Vale la pena escribirlo a mano una vez, porque cualquier problema posterior se detecta mejor cuando sabes cómo es un archivo sano.

Un servidor local stdio

Esta entrada lanza el servidor MCP de Playwright mediante npx cada vez que Copilot lo necesita:

{
  "servers": {
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Copiar prompt

Guarda el archivo y VS Code mostrará las acciones Start, Stop y Restart encima de la entrada. Inícialo, abre Copilot Chat en modo agente y revisa el selector de herramientas: las herramientas del servidor deberían aparecer listadas y listas para activarse.

Un servidor HTTP remoto

Un servidor remoto necesita una URL en lugar de un comando. Este apunta al servidor MCP alojado de GitHub:

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

Copiar prompt

Si el servidor admite OAuth, VS Code abre un flujo de inicio de sesión la primera vez que se ejecuta una herramienta. Si espera un token estático, envíalo mediante headers, y nunca pegues el token en un archivo que vayas a confirmar.

Mantén los secretos fuera de la configuración

VS Code resuelve esto con variables de entrada. Declaras una entrada una vez, la marcas como contraseña y la referencias con ${input:id}:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "sentry-token",
      "description": "Sentry auth token",
      "password": true
    }
  ],
  "servers": {
    "sentry": {
      "type": "stdio",
      "command": "npx",
      "args": ["@sentry/mcp-server@latest"],
      "env": { "SENTRY_TOKEN": "${input:sentry-token}" }
    }
  }
}

Copiar prompt

VS Code pide el valor la primera vez que se inicia el servidor, así que el repositorio solo contiene el marcador de posición. Las entradas tienen tres tipos: promptString para texto escrito, pickString para una lista desplegable y command para un valor que se obtiene al ejecutar un comando. Cada entrada necesita un type, un id y un description.

💡 Un .vscode/mcp.json confirmado con un token pegado es la filtración de MCP más habitual. Si usas envFile, añade ese archivo a .gitignore en el mismo commit.

Busca servidores en el registro

Escribir a mano el JSON de cada servidor se vuelve tedioso muy rápido. El registro existe para que no tengas que hacerlo.

El registro MCP de GitHub

github.com/mcp reúne servidores de la comunidad que conectan modelos con archivos, APIs y bases de datos. En el momento de escribir esto muestra 375 servidores, desde Markitdown de Microsoft hasta Stripe y Figma, cada uno con un botón Install. Instalar añade una entrada a tu configuración, así que léela antes de iniciar el servidor: revisa el comando, el nombre del paquete y la URL.

VS Code también muestra servidores MCP dentro del editor. Escribe @mcp en el cuadro de búsqueda de la vista Extensiones para explorarlos, instala uno y VS Code añadirá la entrada a tu configuración de usuario o de espacio de trabajo. Trata cada entrada del registro como un punto de partida, no como una revisión de seguridad.

Crea tu propio registro

Las organizaciones pueden alojar su propio registro MCP y apuntar Copilot hacia él. Si lo construyes sobre Azure API Center, introduce la URL base con esta forma:

https://SERVICE-NAME.data.REGION.azure-apicenter.ms/workspaces/WORKSPACE-NAME

No añadas un sufijo de ruta como /v0.1/servers. Copilot añade la ruta de MCP v0.1 por sí mismo, y un sufijo hace que el registro falle. Los propietarios de Enterprise configuran la URL en AI controls y luego en MCP. Los propietarios de la organización la configuran en Copilot y luego en Policies.

Restringe los servidores con listas de permitidos

Los administradores tienen dos formas de decidir qué servidores pueden ejecutar los desarrolladores. No son equivalentes, así que elige con criterio.

La propia documentación de GitHub describe la configuración gestionada como el método más seguro y disponible de forma general, y califica la política de registro como no recomendada.

El método de configuración gestionada

Añade allowedMcpServers, deniedMcpServers o ambos a copilot/managed-settings.json en el repositorio .github-private de tu organización, y luego confirma los cambios en la rama predeterminada:

{
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverCommand": ["npx", "@playwright/mcp@latest"] }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://untrusted.example/*" }
  ]
}

Copiar prompt

Hay tres tipos de coincidencia:

• serverUrl coincide con servidores HTTP y SSE remotos, admite comodines * y normaliza las URL para evitar elusiones.
• serverCommand coincide con un servidor stdio local por su comando y argumentos exactos.
• serverName coincide con la etiqueta que el usuario escribió en su configuración. Es una conveniencia, no un límite de seguridad.

Cómo funciona la coincidencia

Copilot evalúa un servidor en un orden fijo:

1. Los valores predeterminados integrados siempre están permitidos.
2. La lista de denegados bloquea cualquier coincidencia.
3. Si existe una lista de permitidos, el servidor debe coincidir con una entrada o queda bloqueado.
4. Cualquier ${VARIABLE} sin resolver en la configuración bloquea el servidor.

Sin ninguna lista de permitidos, un servidor se ejecuta a menos que esté denegado o contenga una variable sin resolver. Cuando se aplican varias fuentes managed-settings.json, todos los ajustes actúan a la vez y una regla de denegación de cualquier fuente bloquea el servidor. Puedes marcar ajustes como overridable para que un equipo personalice su propia capa.

💡 La coincidencia de comandos es exacta. Si permites ["npx", "@playwright/mcp@latest"], un desarrollador que ejecute npx -y @playwright/mcp@latest no coincidirá, porque los argumentos son distintos. Publica la entrada exacta que quieres que la gente copie.

La política solo de registro

¿Sigues en la vía de vista previa? Activa la política MCP servers in Copilot, introduce la URL de tu registro y después configura Restrict MCP access to registry servers en Registry only. El cambio se aplica de inmediato. Como coincide por nombre o ID, trátala como una barrera para errores involuntarios y pasa los entornos de alto riesgo a la configuración gestionada. Los pasos completos están en la documentación de acceso a MCP de GitHub.

Configuración del agente en la nube y de la CLI

El agente en la nube de Copilot (antes agente de programación) se ejecuta en la infraestructura de GitHub, así que no puede leer tu .vscode/mcp.json local. Tiene su propia configuración, y ahí es donde se cometen la mayoría de los errores de copiar y pegar.

Abre el repositorio, ve a Settings, elige Copilot en Code & automation y edita el cuadro MCP configuration:

{
  "mcpServers": {
    "sentry": {
      "type": "local",
      "command": "npx",
      "args": ["@sentry/mcp-server@latest"],
      "tools": ["list_issues"],
      "env": { "SENTRY_TOKEN": "$COPILOT_MCP_SENTRY_TOKEN" }
    }
  }
}

Copiar prompt

Cinco reglas lo diferencian del formato de VS Code:

• El campo de nivel superior es mcpServers, no servers.
• type acepta local, stdio, http o sse.
• tools es obligatorio. Usa ["*"] para todo, o enumera nombres de herramientas para vigilar de cerca lo que puede hacer el agente.
• Los secretos deben añadirse como secretos o variables del agente cuyos nombres empiecen por COPILOT_MCP_, y la configuración debe referenciar exactamente esos nombres.
• Solo se admiten herramientas, y los servidores remotos no pueden usar OAuth.

Los servidores MCP de GitHub y Playwright ya están activados en todos los repositorios, así que solo añades lo que falta. Lee la documentación de MCP del agente en la nube antes de añadir nada que escriba datos.

Copilot CLI. La CLI lee ~/.copilot/mcp-config.json. Dentro de una sesión interactiva, /mcp add te guía para añadir un servidor sin editar JSON a mano. Las listas de permitidos de la configuración gestionada también se aplican aquí, así que un servidor que funciona en VS Code pero está bloqueado en la terminal suele indicar una discrepancia de políticas, no una instalación rota.

Corrige los errores comunes rápido

La mayoría de los fallos se reducen a cinco causas. Compara tu síntoma con la tabla antes de reinstalar nada.

El servidor arranca, pero sin herramientas

Ejecuta MCP: List Servers, selecciona el servidor y abre su salida. Un fallo al iniciarse suele mostrar un entorno de ejecución que falta (Node o Python no están en la ruta) o un nombre de paquete incorrecto. Si el proceso está en buen estado, abre el selector de herramientas en modo agente y confirma que las herramientas están activadas.

Bloqueado por política

Un servidor bloqueado casi siempre tiene una de tres causas: existe una lista de permitidos y ninguna entrada coincide, se aplica una regla de denegación de otra fuente managed-settings.json, o la configuración contiene un ${VARIABLE} sin resolver. Como las políticas se cierran ante fallos, un archivo de ajustes mal formado bloquea los servidores en lugar de dejarlos pasar. Pregunta al administrador qué fuente lo bloqueó antes de editar tu propia configuración.

Fragmentos pegados de otros clientes. Un fragmento copiado de la documentación de otro cliente MCP casi siempre usa mcpServers. Lo pegas en .vscode/mcp.json y no carga nada, sin ningún aviso. Renombra el campo, añade type de forma explícita y pasa los secretos a entradas mientras lo haces.

Pon PicassoIA a trabajar

Un segundo par de ojos detecta los errores simples: un nombre de campo incorrecto, una lista tools que falta, un argumento que rompe una coincidencia exacta. Puedes conseguirlo en un minuto.

Usa Claude Sonnet 5 en PicassoIA

Claude Sonnet 5 lee configuraciones, razona sobre problemas de varios pasos y acepta imágenes, así que encaja bien en este trabajo. Esta es una forma repetible de usarlo:

1. Abre la página de Claude Sonnet 5 en PicassoIA.
2. En System Prompt, define el rol una sola vez: "Revisas configuraciones de MCP para GitHub Copilot. Comprueba el campo de nivel superior, el tipo de transporte, la lista de herramientas, el manejo de secretos y las entradas de la lista de permitidos con coincidencia exacta."
3. Pega tu mcp.json o managed-settings.json en Prompt. Sustituye antes cada token real por un marcador de posición.
4. Fija Effort en high para la lógica de la lista de permitidos. El valor predeterminado low sirve para revisar erratas y responde en segundos.
5. Deja Max Tokens en 8192, que basta de sobra para una revisión completa.
6. Adjunta una captura del error en el campo Image si tienes una, ya que el modelo lee imágenes.
7. Ejecútalo, aplica las correcciones una a una y reinicia el servidor después de cada una.

Para una segunda opinión, envía el mismo prompt a GPT 5.6 Sol, Gemini 3.1 Pro o Kimi K2.6 y compara en qué no coinciden. Las discrepancias suelen señalar la línea que merece la pena revisar tú mismo.

Crea después tus propias imágenes

Implantar esto en un equipo implica una página de wiki, una diapositiva para la revisión de seguridad y una imagen de cabecera que no parezca un clip art genérico. PicassoIA genera todo ello a partir de un prompt de texto. Prueba Qwen Image 3 para escenas fotorrealistas, Seedream 5 Pro para una salida nítida en 2K, o GPT Image 2.5 Flare cuando necesites un borrador rápido. Describe la escena, elige una relación de aspecto 16:9 e itera hasta que encaje en tu documento. Abre PicassoIA, escribe tu primer prompt y comprueba cómo queda tu próxima entrada de implantación con una imagen de cabecera real.