Cómo usar servidores MCP en Visual Studio paso a paso

Si trabajas con GitHub Copilot y Visual Studio, probablemente hayas oído hablar del Protocolo de contexto de modelo, o MCP, pero quizá aún no tengas claro cómo sacarle todo el partido dentro del IDE. MCP es el estándar que permite a los agentes de IA hablar con herramientas externas como repositorios, bases de datos o servicios de Azure sin tener que crear integraciones a medida cada vez.

En este artículo vamos a ver con calma cómo usar servidores MCP en Visual Studio, cómo se configuran, dónde se declaran, qué papel juegan los archivos .mcp.json y mcp.json, y cómo se integran con el modo de agente de GitHub Copilot. También verás ejemplos prácticos con los servidores MCP de GitHub, Azure DevOps, Azure MCP Server, servidores SQL y hasta cómo controlar el uso de MCP a nivel de organización.

Qué es MCP y por qué importa en Visual Studio

El Protocolo de contexto de modelo es un estándar abierto que define cómo un cliente de IA (como GitHub Copilot en Visual Studio) se conecta a herramientas y servicios externos y se comunica con ellos. En lugar de que cada extensión invente su propia forma de integrarse, MCP unifica el formato de mensajes, la forma de descubrir herramientas y el modo de invocarlas.

En la práctica, esto significa que Visual Studio actúa como cliente MCP y se conecta a uno o varios servidores MCP. Cada servidor MCP expone una colección de herramientas bien definidas: desde operaciones sobre el sistema de archivos hasta gestión de repositorios, trabajo con Azure DevOps, consultas SQL o acceso a servicios web especializados.

Para GitHub Copilot, MCP supone una mejora enorme del modo de agente. En lugar de limitarse a generar código, el agente puede usar estas herramientas MCP para ejecutar acciones reales: crear o revisar pull requests, listar incidencias, interactuar con recursos de Azure, lanzar consultas sobre bases de datos, etc., todo ello desde el propio flujo de trabajo de codificación.

La gran ventaja es que, al estar estandarizado, no necesitas una integración específica por cada herramienta: basta con añadir un nuevo servidor MCP a la configuración y el agente puede empezar a utilizar sus herramientas, siempre que tú le des permiso para ello.

Requisitos previos para usar servidores MCP en Visual Studio

Antes de meterte en harina, necesitas cumplir unos requisitos mínimos a nivel de entorno para que Visual Studio pueda trabajar con MCP y con el modo de agente de Copilot.

Por un lado, hace falta contar con Visual Studio 2026 o Visual Studio 2022 a partir de la versión 17.14, idealmente con la versión de mantenimiento más reciente instalada, porque es donde se van incorporando las últimas capacidades relacionadas con MCP. Sin esta base, muchas de las opciones que vas a ver simplemente no aparecerán.

Además, debes tener GitHub Copilot habilitado en Visual Studio y acceso al modo de agente. En entornos empresariales, este punto depende de la configuración de políticas que haya definido el administrador en el panel de GitHub Copilot (especialmente en suscripciones Business o Enterprise).

En algunos casos concretos, como cuando quieras trabajar con Azure MCP Server o con servidores MCP que se apoyen en la CLI de Azure, necesitarás tener instalado .NET adecuado, las herramientas de Azure (CLI tradicional o Developer CLI) y permisos suficientes en la suscripción de Azure con la que vayas a operar.

Búsqueda y elección de servidores MCP compatibles

Una vez que tu entorno está preparado, el siguiente paso es localizar qué servidores MCP quieres conectar a Visual Studio. El ecosistema está creciendo muy rápido, así que conviene conocer las fuentes oficiales.

El punto de referencia principal es el registro o repositorio oficial de servidores MCP. Ahí encontrarás servidores mantenidos por los propios proveedores (GitHub, Azure, etc.) y también contribuciones de la comunidad. Verás servidores especializados en acceso a archivos, gestión de repositorios, bases de datos SQL, servicios web, integraciones con herramientas de diseño como Figma, sistemas de testing como Playwright, entre otros.

Como MCP es todavía relativamente nuevo, la lista de servidores está en constante expansión. Lo habitual es que consultes el repositorio del servidor en GitHub para revisar la configuración recomendada, los parámetros de conexión y las capacidades que expone cada herramienta MCP.

Además, GitHub está impulsando el uso de registros MCP gestionados, donde las organizaciones pueden publicar y controlar qué servidores están autorizados para sus usuarios. Esto se integra con las políticas de Copilot, lo que te permite restringir la instalación de servidores MCP a los declarados en uno o varios registros aprobados.

Formas de agregar un servidor MCP en Visual Studio

Visual Studio ofrece varias maneras de añadir servidores MCP a tu entorno, para adaptarse tanto a escenarios sencillos como a configuraciones más avanzadas controladas por archivos JSON.

La forma más directa, cuando está disponible, consiste en instalar el servidor MCP directamente desde la web. A partir de la versión de mantenimiento más reciente de Visual Studio 17.14, verás botones de instalación tipo “Install” en las páginas de algunos servidores MCP. Con un clic, el servidor se instala y queda asociado a tu instancia de Visual Studio sin que tengas que editar archivos a mano.

Otra opción cómoda es añadir un servidor desde la propia ventana de chat de Copilot. En el selector de herramientas del chat, encontrarás un botón de añadir (el clásico icono verde con el símbolo +). Al pulsarlo, Visual Studio te pedirá el nombre del servidor y los datos de conexión: puede ser una URL HTTP para transporte vía SSE o la orden y argumentos para transporte stdio.

Si tu organización trabaja con el registro de servidores MCP de GitHub, también puedes ir al menú Extensions > MCP Registries… dentro de Visual Studio. Desde ese administrador verás los servidores publicados en el registro configurado; solo tienes que seleccionar el que quieras y pulsar en “Install” para activarlo en tu IDE.

Para configuraciones más finas o compartidas con el equipo, la vía más flexible es editar el archivo de configuración MCP en formato JSON, que puede llamarse .mcp.json o mcp.json según la ubicación. Ahí es donde declaras los servidores, su tipo de transporte, los comandos de arranque, variables de entorno, etc.

Configuración de servidores MCP con .mcp.json

La forma más robusta de gestionar servidores MCP en Visual Studio es a través de archivos de configuración JSON. Estos archivos describen de manera estructurada qué servidores hay disponibles, cómo se inician y qué transporte utilizan.

Un ejemplo muy habitual es configurar el servidor MCP de GitHub en la raíz de una solución. Para ello, puedes crear un archivo en <SOLUTIONDIR>\.mcp.json o en %USERPROFILE%\.mcp.json, y usar Visual Studio para editarlo, de modo que tengas ayuda de esquema y validación de sintaxis.

En el archivo añadirías una estructura con una sección servers que contenga un objeto por cada servidor. Por ejemplo, para GitHub podrías incluir un servidor llamado «github» con una URL remota similar a https://api.githubcopilot.com/mcp/. A partir de ahí, Visual Studio detecta el servidor, se encarga del protocolo de enlace inicial y la consulta de sus herramientas.

Una vez guardado el archivo, verás sobre la definición del servidor en el editor un CodeLens de “Autenticación requerida”. Al pulsar en esa indicación, se abre el flujo de inicio de sesión con tu cuenta de GitHub para autorizar el acceso del servidor MCP. Es importante asegurarse de que CodeLens está habilitado en Herramientas > Opciones > Editor de texto > CodeLens para poder usar esta comodidad.

Tras la autenticación, puedes ir al chat de Copilot, cambiar el modo a Agent en la lista desplegable de la parte inferior, y seleccionar las herramientas del servidor MCP que quieras utilizar (por ejemplo, una herramienta de “Enumerar problemas”). Cuando lances un mensaje como “Enumera los issues asignados a mí en GitHub”, Copilot te pedirá permiso para usar la herramienta correspondiente.

Dónde colocar los archivos mcp.json para la detección automática

Visual Studio realiza una búsqueda automática de archivos de configuración MCP en distintas ubicaciones, lo que te permite tener configuraciones globales para el usuario, específicas por solución o incluso compartidas con otros editores como VS Code o Cursor.

En primer lugar, se consulta %USERPROFILE%\.mcp.json, que actúa como configuración global de servidores MCP para un usuario. Todo servidor declarado ahí estará disponible en cualquier solución que abras con Visual Studio.

Después se revisa <SOLUTIONDIR>\.vs\mcp.json, que es una configuración específica para una solución concreta y para un usuario concreto. Es útil cuando quieres que ciertos servidores solo se carguen al abrir una solución determinada sin afectar al resto.

La siguiente ubicación clave es <SOLUTIONDIR>\.mcp.json, que suele emplearse cuando quieres que la configuración de MCP viaje con el repositorio y se controle en el sistema de control de código fuente (por ejemplo, en Git). Así todo el equipo puede compartir la misma definición de servidores.

También se contemplan rutas orientadas a otros editores, como <SOLUTIONDIR>\.vscode\mcp.json o <SOLUTIONDIR>\.cursor\mcp.json. Estos archivos suelen estar ligados al repositorio o a la carpeta de trabajo, pero en muchos casos se excluyen del control de versiones para mantenerlos locales.

Conviene tener presente que algunas de estas rutas exigen el nombre .mcp.json y otras mcp.json sin el punto inicial, así que es importante respetar exactamente el nombre requerido en cada carpeta para que Visual Studio y otros entornos detecten el archivo correctamente.

Formato de configuración y edición de servidores MCP

Los archivos de configuración MCP siguen la especificación del propio protocolo, lo cual garantiza que los distintos clientes (Visual Studio, VS Code, etc.) puedan interpretarlos sin ambigüedades.

En esencia, cada archivo contiene un objeto principal con una propiedad servers. Dentro, se define una matriz u objeto de servidores, donde cada servidor incluye, como mínimo, un nombre, el tipo de transporte y la forma de conexión. Esta conexión puede ser remota, mediante una URL y credenciales, o local, mediante un comando que se lancen por stdio.

En los servidores locales es muy común invocar herramientas a través de gestores de paquetes. Por ejemplo, puedes usar un comando del tipo npx -y @azure/mcp@latest server start para iniciar Azure MCP Server, o utilizar docker run con una imagen que implemente un servidor MCP concreto. Visual Studio respeta exactamente el comando que declares, lo que te permite fijar versiones o añadir flags a tu gusto.

Cuando ya tengas un archivo mcp.json en el repositorio y quieras que aparezca en el Explorador de soluciones, puedes agregarlo a los elementos de solución para editarlo cómodamente desde el IDE. Cada vez que guardes el archivo con sintaxis válida, el agente de GitHub Copilot se reiniciará y recargará la lista de servidores configurados, aplicando los cambios al vuelo.

Esta forma declarativa de gestionar servidores te da un control muy fino sobre el entorno MCP, permitiéndote reproducir la misma configuración en diferentes máquinas y compartirla con el resto del equipo de desarrollo.

Ciclo de vida de las herramientas MCP dentro de Visual Studio

Una vez que Visual Studio detecta la presencia de un servidor MCP, se pone en marcha un ciclo de vida bien definido para las herramientas que ese servidor expone. Esta secuencia garantiza seguridad y coherencia cada vez que se añaden, modifican o retiran servidores.

Lo primero que hace Visual Studio al encontrar un servidor es inicializarlo mediante un protocolo de enlace, en el que consulta la lista de herramientas disponibles. A continuación, el cliente se suscribe al evento notifications/tools/list_changed definido por MCP, de forma que pueda reaccionar cuando el servidor añada o modifique herramientas.

Siempre que se dispare ese evento, Visual Studio restablece cualquier autorización previa concedida a esas herramientas (para evitar ataques del tipo “rug-pull”, donde una herramienta cambia de comportamiento a mitad de partida), vuelve a solicitar la lista de herramientas, ajusta su número y actualiza la interfaz en tiempo real.

Cuando el servidor queda habilitado, el agente de Copilot expone todas las herramientas en la interfaz, pero las deja deshabilitadas por defecto. Es el usuario quien debe ir activando manualmente las herramientas que desea permitir, para mantener un control explícito sobre qué capacidades pueden ejecutarse.

Si decides eliminar un servidor MCP de la configuración, Visual Studio detendrá de inmediato el proceso asociado y retirará todas sus herramientas de la interfaz. De forma análoga, si editas la definición de un servidor (por ejemplo, cambiando el comando, la URL o las variables de entorno), el IDE finaliza el proceso actual, lo reinicia con la nueva configuración y vuelve a realizar las consultas de herramientas necesarias.

Gestión de aprobaciones y seguridad de herramientas

Cada vez que el agente de Copilot invoca una herramienta MCP, Visual Studio introduce una capa de confirmación explícita para asegurarse de que eres consciente de lo que va a hacer la herramienta. Esto es especialmente importante porque muchas de ellas pueden modificar archivos locales o datos remotos.

Tras una call de herramienta, en el panel de chat verás un control desplegable para permitir o confirmar futuras ejecuciones. Puedes decidir que la herramienta se apruebe solo en esa ocasión, que se autoapruebe durante toda la sesión actual, que sea válida para la solución activa, o incluso que quede autorizada para todas las invocaciones futuras en tu entorno.

Si en algún momento quieres resetear todas las decisiones de confirmación, puedes hacerlo desde el cuadro de diálogo de Opciones de Visual Studio, en la sección GitHub > Copilot > Herramientas. Desde ahí se vacía el historial de permisos y, a partir de ese momento, Copilot volverá a pedirte confirmación cuando utilice cada herramienta.

En paralelo, Visual Studio soporta autenticación para servidores MCP remotos mediante cualquier proveedor de OAuth, siempre y cuando el servidor se adhiera a la especificación de autorización de MCP. Esto se suma a la integración tradicional con la cadena de claves del IDE. Para gestionar la autenticación de un servidor concreto, puedes usar de nuevo CodeLens sobre el archivo .mcp.json, seleccionando la opción de administrar autenticación y completando el login en la ventana del navegador.

Este diseño de permisos granulares y autenticación unificada minimiza el riesgo de uso indebido de herramientas MCP, al tiempo que mantiene una experiencia bastante fluida cuando ya has otorgado los permisos adecuados.

Listas permitidas de servidores MCP a nivel de organización

En entornos empresariales, no basta con que el desarrollador quiera usar un servidor MCP; también hay que respetar las políticas de seguridad y cumplimiento de la organización. Aquí entran en juego las listas de permitidos (allow lists) gestionadas desde GitHub.

Cuando se activa una lista de permitidos para MCP en la organización, solo se pueden usar servidores MCP aprobados. Si intentas conectar con un servidor que no esté en esa lista, Visual Studio muestra un mensaje de error indicando que la directiva corporativa no permite el uso de ese servidor.

En ese caso, la única salida es contactar con el administrador de la organización para solicitar que añada el servidor al registro permitido o, al menos, que confirme qué servidores MCP están autorizados. Esto es clave cuando tu empresa quiere evitar que datos sensibles se filtren a servicios externos no controlados.

Estas políticas permiten a los administradores controlar qué servidores pueden procesar información confidencial, mantener el cumplimiento normativo en torno al tratamiento de datos y centralizar las decisiones sobre qué integraciones de IA se autorizan en los equipos de desarrollo.

En la práctica, muchas organizaciones que usan GitHub Copilot Enterprise comienzan configurando una política que desactiva completamente MCP para todos los usuarios, y luego dan pasos graduales para habilitar servidores seleccionados a través de un registro MCP privado, autoalojado o basado en servicios como Azure API Center, aunque la documentación todavía requiere cierto conocimiento previo sobre registros MCP.

Uso de instrucciones, plantillas y recursos MCP

Además de herramientas, los servidores MCP pueden proporcionar instrucciones predefinidas y recursos estructurados para que los modelos de lenguaje trabajen con más contexto y menos fricción.

Las instrucciones MCP son básicamente plantillas de mensajes reutilizables para tareas recurrentes. En el chat de Copilot puedes usar el botón “+ Agregar referencia”, elegir la categoría de “Indicaciones > indicaciones del MCP”, y seleccionar una instrucción ofrecida por el servidor. Algunas incluyen argumentos personalizables que puedes completar antes de insertarlas en la conversación.

Un ejemplo típico es el servidor MCP de GitHub, que ofrece mensajes preparados para analizar pull requests, generar mensajes de confirmación de commits o revisar cambios de código. Esto acelera el flujo de trabajo porque no tienes que redactar desde cero cada prompt complejo.

Los recursos MCP, por su parte, proporcionan contexto rico al modelo: pueden ser archivos de código, esquemas de base de datos, datos de negocio o información específica de una aplicación. Cada recurso va identificado por un URI único y se puede referenciar en el chat de Copilot usando un hashtag (#) seguido de ese URI.

Cuando se trata de plantillas de recursos con argumentos, puedes volver a usar el diálogo de “+ Agregar referencia”, pero esta vez en la sección de “Recursos de MCP”. Ahí eliges el recurso, rellenas los parámetros necesarios (por ejemplo, un identificador de elemento de trabajo o un nombre de componente), y lo insertas en la conversación para que Copilot lo use como contexto.

Ejemplos reales incluyen el servidor MCP de Azure DevOps, que expone recursos como elementos de trabajo, información de sprints o datos de capacidad de equipo para tareas de planificación, o el servidor MCP de Figma, que facilita el acceso a componentes de diseño, guías de estilo y especificaciones de maquetación.

Muestreo MCP y llamadas LLM delegadas

Otra capacidad interesante del protocolo es el muestreo o sampling, que permite que un servidor MCP realice llamadas a modelos de lenguaje en tu nombre para ejecutar flujos de trabajo de varios pasos más complejos.

Cuando un servidor soporta muestreo y Copilot detecta que necesita una operación de este tipo, se mostrará un cuadro de diálogo de confirmación antes de continuar. Ahí puedes revisar los detalles, comprender qué va a hacer exactamente el servidor y aprobar o denegar la acción.

Este enfoque mantiene un equilibrio entre automatización y control: el servidor se encarga de orquestar las llamadas LLM y las operaciones intermedias, mientras que tú mantienes la última palabra sobre qué se ejecuta realmente en tu entorno.

Por ejemplo, el servidor MCP de Playwright puede usar muestreo para generar escenarios de prueba a partir del DOM de una aplicación web y de los flujos de usuario observados. El servidor analiza la estructura de la página, propone casos de test y los materializa en scripts de automatización, todo ello coordinado a través de MCP.

Azure MCP Server: integración con recursos de Azure

Azure MCP Server es uno de los casos de uso más potentes de MCP, porque estandariza el acceso a recursos de Azure desde aplicaciones de IA como GitHub Copilot, tanto en Visual Studio como en Visual Studio Code.

Este servidor se distribuye en distintos formatos, incluyendo paquete NuGet y paquete NPM, y se puede utilizar desde Visual Studio o VS Code. En ambos casos, necesitas estar autenticado en Azure con una cuenta válida y con permisos adecuados sobre la suscripción donde residen los recursos que quieras manipular.

La forma típica de autenticarse localmente en Azure es usar la CLI de Azure. Con un simple az login abres el flujo de inicio de sesión en el navegador. Luego puedes comprobar la cuenta y la suscripción activa con az account show. Es esencial que el usuario disponga de los roles necesarios (por ejemplo, Colaborador, Lector, Colaborador de cuenta de almacenamiento, etc.), porque Azure MCP Server respetará estrictamente esas asignaciones.

Para empezar a probar el servidor desde el modo de agente de Copilot, puedes lanzar un mensaje tipo “Enumera mis grupos de recursos de Azure”. Copilot solicitará que inicies sesión en Azure (si aún no lo has hecho), te pedirá permiso para ejecutar la operación concreta y, una vez aprobado, devolverá la lista de grupos de recursos con su nombre y región.

A partir de ahí, puedes seguir explorando con mensajes como “Lista todas las cuentas de almacenamiento de mi suscripción” o “Obtén las tablas disponibles en mis cuentas de almacenamiento”. Cada operación volverá a pasar por el flujo de confirmación de herramientas, a menos que decidas permitirla siempre, para esa sesión o para ese área de trabajo.

Ejemplo de servidor MCP SQL con Data API Builder

Otro ejemplo muy ilustrativo del uso de MCP es el servidor SQL basado en Data API Builder (DAB), que te permite exponer una base de datos SQL Server como servidor MCP y consultarla desde VS Code y GitHub Copilot.

Para este escenario necesitas tener instalado .NET 9 o superior y acceso a una instancia de SQL Server 2016 o posterior, bien sea una edición Developer, Express, LocalDB o un contenedor Docker. Con estas herramientas listas, puedes instalar la CLI de Data API Builder con los comandos dotnet new tool-manifest, dotnet tool install microsoft.dataapibuilder y dotnet tool restore.

El flujo típico arranca creando una base de datos de ejemplo, por ejemplo ProductsDb con una tabla Products, y poblarla con unos cuantos registros. A continuación, configuras un archivo .env con la cadena de conexión (MSSQL_CONNECTION_STRING) y ejecutas dab init para inicializar el servidor, seguido de dab add Products para exponer la tabla como entidad, con permisos de lectura anónimos y una descripción amigable.

Si quieres ir un paso más allá, puedes usar dab update para añadir descripciones por campo (Id, Name, Inventory, Price, Cost), marcando la clave primaria y explicando qué representa cada columna. Esto mejora el contexto que recibirá Copilot cuando haga consultas a través del servidor MCP.

SQL MCP Server admite transporte HTTP (iniciando dab start en un terminal y conectando a un endpoint tipo http://localhost:5000/mcp) o transporte stdio, donde VS Code administra directamente el proceso sin abrir puertos. En ambos casos, la definición del servidor se declara en un .vscode/mcp.json, indicando el nombre, tipo de transporte y URL o comando.

Una vez conectado, las entidades como Products se exponen como herramientas MCP del estilo describe_entities o read_records, y puedes probarlas desde Copilot Chat con prompts como “¿Qué productos tienen un inventario inferior a 30?”. El servidor MCP se encarga de traducir la petición a consultas SQL y devolver un resultado estructurado.

Experiencias avanzadas: creación de servidores MCP personalizados

Más allá de consumir servidores existentes, MCP está diseñado para que puedas crear tus propios servidores a medida y compartirlos con el resto del equipo. Hay ejemplos completos en entornos como Visual Studio Code, donde se muestra cómo generar servidores con lenguajes como Python.

Un caso real consiste en construir un servidor MCP que recopile datos de paquetes PyPI, ayudado por GitHub Copilot. El flujo suele incluir la configuración de un entorno de Python, la generación de un script que consulta la API de PyPI, la conversión de ese script en una herramienta MCP formal, y finalmente el registro del servidor mediante un archivo mcp.json en VS Code.

En sesiones prácticas se ve cómo se usa el modo de agente de Copilot para asistir en cada fase del desarrollo del servidor, desde la redacción del esquema JSON hasta la definición de las descripciones de herramientas que mejor ayudan al modelo a entender qué hace cada operación.

También se tratan aspectos como la optimización de las descripciones de herramientas para que el modelo las elija correctamente, y las formas de compartir el servidor MCP con otros desarrolladores, ya sea publicándolo en un repositorio público, en un registro privado o distribuyendo una plantilla de configuración lista para usar.

Todo esto demuestra que MCP no es solo un estándar de consumo de herramientas, sino también una plataforma para construir ecosistemas de extensiones de IA más transparentes, reutilizables y fáciles de gobernar.

Al final, entender cómo usar servidores MCP en Visual Studio -desde la búsqueda y configuración en archivos .mcp.json, pasando por la autenticación OAuth, las aprobaciones de herramientas, las listas permitidas de organización, hasta ejemplos concretos como Azure MCP Server o servidores SQL con Data API Builder- te da una base sólida para integrar la inteligencia artificial de forma controlada en tu flujo de trabajo diario y abrir la puerta a soluciones cada vez más potentes sin perder el control sobre la seguridad ni la experiencia de desarrollo.