[Paso a Paso] MCP – Tu primer MCP en C#

Armá tu Primer Servidor MCP Local con C# SDK en VS Code

Lo que vamos a ver

¿Qué es MCP y por qué te tendría que importar?
Los componentes principales de MCP
El SDK de C# para MCP
Cómo construir un servidor MCP con una aplicación de consola en C#
Configuración del archivo mcp.json
Probar el servidor MCP usando VS Code y Copilot
API Convencional vs MCP: ¿Cuál es la diferencia real?

¿Qué es MCP?

MCP (Model Context Protocol) es un estándar abierto que define cómo las aplicaciones pueden exponer herramientas y contexto a los modelos de lenguaje grandes (LLMs), tipo GitHub Copilot, Claude o ChatGPT.

Si leíste esa definición y pensaste “Dale, pero ¿qué significa eso en la práctica?”, tranqui que no sos el único. Dejame explicártelo con un ejemplo del mundo real que seguro vas a entender al toque.

Ejemplo Real: Inversiones y IA

Imaginate que usás una plataforma de inversión para comprar y vender acciones. Desde la app del celu podés ver los precios en tiempo real y hacer tus operaciones basándote en cómo viene el mercado.

Ahora imaginate que querés que un asistente de IA, ponele ChatGPT o Copilot, te tire data tipo:

“¿Es buen momento para comprar acciones de MeLi?”
“Avisame cuando las acciones de YPF pasen los $200”

El problema: Los LLMs como ChatGPT están entrenados con datos estáticos y no tienen acceso en tiempo real a sistemas externos. No pueden decirte cuánto está una acción ahora ni hacer operaciones en tu cuenta, salvo que estén conectados a algo que sí pueda hacerlo.

Llenando el Vacío con MCP

Acá es donde entra MCP. Una plataforma de inversión podría darte un conjunto completo de endpoints de API que podés envolver en un Servidor MCP usando C#. Estos endpoints se llaman Tools (Herramientas) en la jerga de MCP.

Por ejemplo, podrías tener herramientas como:

obtener_portafolio() – Ver tus inversiones actuales
realizar_orden() – Comprar o vender acciones
obtener_precio_actual() – Consultar cuánto está una acción en este momento

Componentes de MCP

Ahora que viste el caso de uso y entendés la problematica , vamos a ver cómo MCP llena ese vacío. Te voy a desglosar los componentes clave de MCP usando la analogía de antes:

Componente	En nuestro ejemplo	Como funciona
MCP Server	Tu aplicación en C# que envuelve las APIs	El servidor que armás y exponés las herramientas
MCP Tools	Métodos tipo `obtener_portafolio`, `realizar_orden`	Las funciones específicas que el LLM puede invocar
MCP Client	Copilot o Claude	El LLM que descubre y usa las herramientas
MCP Host	Visual Studio Code	El entorno donde corre el cliente

Resumiendolo:

MCP Server: La app que construís en C# que define y expone las herramientas.
MCP Tools: Las funciones (métodos de C#) que definís y decorás con atributos especiales.
MCP Client: El LLM (como Copilot) que descubre y llama a las herramientas.
MCP Host: El entorno donde corre el cliente, tipo Visual Studio Code.

SDK de C# para MCP

El SDK oficial de C# para Model Context Protocol te permite que aplicaciones, servicios y bibliotecas .NET implementen e interactúen con clientes y servidores MCP.

Podés consultar la documentación oficial del API para más detalles.

Ahora que tenés una idea clara de qué es MCP y cómo funcionan sus componentes, vamos a construir algo posta.

Construyendo un Servidor MCP con C#

En esta sección vamos a armar un servidor MCP usando una simple aplicación de consola en C#. Vamos a definir tres métodos (herramientas) y ver cómo pueden ser descubiertos e invocados por Copilot, con VS Code haciendo de host.

Lo que necesitás tener

Visual Studio Code instalado
.NET SDK instalado (7.0 o superior)
Extensión de C# para VS Code
GitHub Copilot (con licencia activa)

Arrancamos

1. Crear un nuevo proyecto de consola en C#

Abrí VS Code y creá un nuevo proyecto de consola:

dotnet new console -n MiServidorMCP
cd MiServidorMCP

2. Agregar los paquetes NuGet que necesitamos

Vas a tener que instalar dos paquetes:

dotnet add package ModelContextProtocol --prerelease
dotnet add package Microsoft.Extensions.Hosting

Una vez instalados, deberías ver los paquetes en tu archivo .csproj.

3. Implementar el código del servidor

Reemplazá el contenido de Program.cs con este código:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol;
using ModelContextProtocol.Server;
using System.ComponentModel;

var builder = Host.CreateDefaultBuilder(args)
    .ConfigureServices((context, services) =>
    {
        services.AddMcpServer();
    });  

builder.Services.AddMcpServer().WithStdioTransport().WithToolsFromAssembly();
await host.RunAsync();

[McpServerToolType]

public static class MisHerramientas
{
    [McpServerTool, Description("Repite el mensaje que envíes.")]
    public static string Echo(string message)
    {
        return message;
    }

    [McpServerTool, Description("Cuenta el número de palabras en el mensaje de entrada.")]
    public static int ContarPalabras(string mensaje)
    {
        if (string.IsNullOrWhiteSpace(mensaje))
            return 0;

        return mensaje.Split(new[] { ' ', '\t', '\n' }, 
               StringSplitOptions.RemoveEmptyEntries).Length;
    }

    [McpServerTool, Description("Devuelve información sobre una fecha específica (formato: yyyy-MM-dd).")]
    public static string InfoFecha(string fechaString)
    {
        if (!DateTime.TryParse(fechaString, out DateTime fecha))
            return "Formato de fecha inválido. Por favor usa yyyy-MM-dd.";

        string diaSemana = fecha.ToString("dddd", 
                          new System.Globalization.CultureInfo("es-ES"));
        bool esFinDeSemana = (fecha.DayOfWeek == DayOfWeek.Saturday || 
                              fecha.DayOfWeek == DayOfWeek.Sunday);

        return $"Día: {diaSemana}, Es fin de semana: {esFinDeSemana}";
    }
}

Puntos Clave del Código

El atributo [McpServerTool]: Este atributo marca un método como una herramienta MCP que puede ser descubierta e invocada por el cliente MCP (Copilot).

El atributo [Description]: Esta descripción es importante. Ayuda al host MCP (Copilot en VS Code) a entender qué hace cada herramienta. Esta descripción guía a la IA para elegir el método más relevante basándose en lo que le pedís en lenguaje natural.

4. Compilar el proyecto

Asegurate de que el proyecto compile sin errores:

dotnet build

Con esto ya tenemos armado nuestro Servidor MCP. Ahora necesitamos mapearlo a nuestro Host MCP (Copilot).

Configurar el archivo mcp.json

Para que VS Code y Copilot reconozcan tu servidor MCP, tenés que crear y configurar un archivo llamado mcp.json.

Cómo configurarlo

1. Crear la estructura de carpetas

Desde el explorador de proyecto en VS Code, creá una carpeta .vscode en la raíz de tu proyecto si no existe.

2. Crear el archivo mcp.json

Dentro de la carpeta .vscode, creá un archivo llamado mcp.json con este contenido:

{
  "servers": {
    "MiServidorMCP": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "RUTA_COMPLETA_A_TU_PROYECTO/MiServidorMCP.csproj"
      ]
    }
  }
}

Importante:

Reemplazá RUTA_COMPLETA_A_TU_PROYECTO con la ruta absoluta a tu archivo .csproj
Usá barras diagonales / en la ruta, incluso en Windows
Ejemplo: "C:/Proyectos/MiServidorMCP/MiServidorMCP.csproj"

3. Entendiendo la configuración

type: "stdio": Especifica que usamos entrada/salida estándar para la comunicación, que es el método requerido para servidores MCP basados en consola de C#.
command: "dotnet": El comando para ejecutar tu aplicación.
args: Los argumentos que le pasamos al comando, incluyendo la ruta a tu proyecto.

4. Reiniciar el servidor

Una vez que guardaste el archivo mcp.json, deberías ver un link “Restart” en la parte superior del archivo. Hacé clic para iniciar tu servidor MCP.

Si configuraste todo bien, vas a ver:

Estado: “Running” (Corriendo)
Una lista de 3 herramientas (las tres funciones que definimos: Echo, ContarPalabras, InfoFecha)

Probar el Servidor MCP con Copilot

Ahora viene la parte divertida: ¡probar nuestro servidor!

Configurar Copilot en Modo Agent

1. Abrir el panel de Copilot Chat

Presioná Ctrl+Shift+I (o Cmd+Shift+I en Mac) para abrir el panel de Copilot Chat.

2. Cambiar a modo Agent

En la parte superior del panel de chat, cambiá el modo de “Chat” a “Agent”.

¿Por qué Agent? Cuando cambiás Copilot Chat al modo Agent en VS Code, se convierte en un cliente MCP. En este modo, Copilot usa la configuración de mcp.json y puede descubrir e invocar tus herramientas MCP.

3. Verificar la detección de herramientas

Copilot va a detectar automáticamente el archivo mcp.json y leer las herramientas disponibles. Deberías ver un indicador de que las herramientas están disponibles.

Probando las Herramientas

Prueba 1: ContarPalabras

Escribí en el chat de Copilot:

¿Cuántas palabras hay en esta frase: "Estoy probando mi primer servidor MCP en VS Code"?

Lo que debería pasar:

Copilot va a identificar automáticamente que tiene que usar la herramienta ContarPalabras
Te va a mostrar que va a ejecutar esa herramienta
Después de confirmar, te va a devolver: “La frase contiene 10 palabras.”

Prueba 2: InfoFecha

Escribí en el chat:

¿Qué día de la semana es el 2025-12-25? ¿Es fin de semana?

Lo que debería pasar:

Copilot va a reconocer que tiene que usar la herramienta InfoFecha
Va a invocar el método con la fecha que le pasaste
Te va a responder algo tipo: “Día: jueves, Es fin de semana: False”

Prueba 3: Echo

Escribí:

Repite este mensaje: "MCP es increíble"

Lo que debería pasar:

Copilot va a usar la herramienta Echo
Te va a devolver exactamente: “MCP es increíble”

API Convencional vs MCP: La Posta

Según mi entendimiento actual de MCP, acá te dejo una comparación simple entre usar API convencional y el enfoque MCP:

Enfoque API Tradicional

Si tenés 10 endpoints diferentes de API, depende de vos (el desarrollador):

Decidir qué endpoint llamar
Cuándo llamarlo
Qué parámetros pasarle
Gestionar toda la lógica de decisión

Ejemplo:

// El desarrollador tiene que elegir manualmente
if (usuario.quiere.contarPalabras) {
    var resultado = api.ContarPalabras(texto);
} else if (usuario.quiere.infoFecha) {
    var resultado = api.InfoFecha(fecha);
}

Enfoque MCP

Con MCP, como viste en nuestro ejemplo:

El servidor MCP expone herramientas (métodos decorados)
El cliente Copilot decide automáticamente qué herramienta invocar basándose en lo que le pedís en lenguaje natural
Copilot mantiene el contexto de la conversación

Ventajas:

Interfaz en lenguaje natural: Los usuarios pueden interactuar con tu API usando frases normales
Selección inteligente de herramientas: El LLM elige automáticamente la herramienta correcta
Contexto conversacional: El asistente se acuerda de interacciones previas
Menos código cliente: No necesitás escribir lógica compleja de selección de endpoints

Ejemplo con MCP:

Usuario: "¿Cuántas palabras tiene este texto?"
Copilot: [Detecta intención -> Invoca ContarPalabras -> Devuelve resultado]

Casos de Uso Prácticos

MCP es especialmente útil para:

Herramientas de productividad: Acceso a calendarios, mails, tareas
APIs de datos: Consulta de bases de datos, servicios externos
Automatización: Ejecutar scripts, deploys, operaciones de DevOps
Servicios empresariales: Integración con sistemas internos (CRM, ERP)
IoT y domótica: Control de dispositivos inteligentes

Conclusión

¡Felicitaciones, loco! Armaste tu primer servidor MCP usando C#. Ahora entendés:

Qué es MCP y por qué es útil
Los componentes principales de la arquitectura MCP
Cómo crear un servidor MCP con C# y .NET
Cómo configurar VS Code para usar tu servidor
Cómo probar tus herramientas con Copilot
Las ventajas de MCP sobre las APIs tradicionales

Próximos Pasos

Ahora que dominás los fundamentos, podés:

Agregar más herramientas complejas a tu servidor
Integrar APIs reales (bases de datos, servicios web)
Implementar herramientas con estado que mantengan datos entre llamadas
Explorar recursos avanzados como prompts y recursos MCP
Crear servidores MCP para tus propias aplicaciones empresariales