# Crea tu primer Servidor MCP (remoto) con .NET Web API

Un [**Model Context Protocol (MCP)**](https://modelcontextprotocol.io/) es un protocolo que permite a los desarrolladores crear herramientas para interactuar con **asistentes de IA** y de esa forma extender sus capacidades.

Crear un servidor [**MCP**](https://modelcontextprotocol.io/) no es tan complicado, pero es fundamental entender su concepto y funcionamiento antes de continuar. Así, te resultará más sencillo comprender todos los pasos que seguiremos a continuación para alcanzar ese primer objetivo con claridad y precisión.

## Configuración inicial del proyecto

Primero, debes de crear un nuevo proyecto Web API y agregar las dependencias necesarias. En mi caso, lo haré usando la terminal con `dotnet` CLI, pero también puedes hacerlo desde [Visual Studio](https://visualstudio.microsoft.com/).

> Ten en cuenta que también puedes usar un proyecto existente.

Enseguida te dejare los comandos para inicializar el proyecto e instalar la dependencia oficial de MCP para .NET disponible mediante la terminal:

```bash
# crea el proyecto Web API
dotnet new webapi -n McpWebApi
# ingresamos al directorio del proyecto e instalamos la dependencia oficial de MCP par .NET
cd McpWebApi
dotnet add package ModelContextProtocol.AspNetCore --prerelease
```

### Configuración del servidor MCP

En este punto integraremos `ModelContextProtocol.AspNetCore`, para ello modifica el archivo principal `Program.cs`. Ahí es donde registrarás los servicios así como el **mapper** para obtener las herramientas o tools que crees.

A continuación te dejo el ejemplo de como debería quedar:

```csharp
var builder = WebApplication.CreateBuilder(args);

// Agregamos los servicios necesarios para MCP
builder.Services.AddMcpServer()
    .WithHttpTransport()
    .WithToolsFromAssembly();

// Código existente...

var app = builder.Build();

// Mapeamos el MCP en la aplicación
app.MapMcp();

// Código existente...

app.Run();
```

## Crea tu primera tool (herramienta) de MCP

Antes de comenzar, crea una carpeta llamada `Tools` dentro del proyecto para tener en un lugar organizado todas tus herramientas.

```bash
mkdir Tools
```

### Implementando nuestro tool: Hello World!

Dentro de la carpeta `Tools`, crea el archivo `WelcomeTool.cs` con el siguiente contenido:

```csharp
using System.ComponentModel;
using ModelContextProtocol.Server;

namespace McpWebApi.Tools;

[McpServerToolType]
public static class WelcomeTool
{
    [McpServerTool, Description("Returns a welcome message with the provided name.")]
    public static string SayWelcomeMessage(String name)
    {
        return $"Welcome to MCP, {name}!";
    }
}
```

**Puntos importantes:**

* `[McpServerToolType]`: Marca la clase como contenedora de herramientas **MCP**. Ten en cuenta que este atributo servirá como guía para obtener todas las **Server Tools** mediante el mapper configurado con `app.MapMcp()`.
    
* `[McpServerTool]`: Identifica el método como una herramienta o tool disponible.
    
* `Description`: Proporciona contexto sobre qué hace la herramienta.
    

> Como puedes observar, crear un tool es similar a crear un controlador en un proyecto de .NET. Seguramente debe de parecerte familiar.

### Ejecutando el servidor

Con todo configurado, ejecuta el proyecto con el siguiente comando:

```bash
dotnet run
```

Luego de eso, verifica en la consola la url de tu servidor, en mi caso es [`http://localhost:5038`](http://localhost:5038).

> Si usas Visual Studio, lo más probable es que la URL se abra automáticamente en tu navegador.

## Configuración de VS Code para usar tu MCP

### Configuración del servidor MCP

Para que [**VS Code**](https://code.visualstudio.com/) reconozca tu **servidor MCP**, necesitaremos crear un archivo de configuración. Para ello creamos la carpeta `.vscode` y el dentro el archivo `mcp.json` de la siguiente manera:

```json
{
    "servers": {
        "my-first-mcp-server": {
            "url": "http://localhost:5038",
            "type": "http"
        }
    },
    "inputs": []
}
```

**Detalles de la configuración:**

* `my-first-mcp-server`: Nombre identificador de tu servidor (puedes modificarlo a tu gusto).
    
* `url`: Es la dirección donde estará corriendo nuestro servidor MCP.
    
* `type`: Especifica que usaremos HTTP con [SSE](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events) en este caso.
    

También puedes usar el comando `> MCP: Add Server` en VS Code (como alternativa):

1. Abre la paleta de comandos (Cmd/Ctrl + Shift + P)
    
2. Busca "MCP: Add Server"
    
3. Sigue las instrucciones para configurar tu servidor, será mucho más fácil posiblemente.
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1752896620750/ca5a5da4-3b2a-440d-816b-6da7cdcea6c5.png align="center")

## Prueba tu MCP con GitHub Copilot Chat

### Iniciando el servidor MCP

Una vez que tengas el archivo `mcp.json` configurado, **asegúrate de que tu proyecto .NET esté corriendo.** Para hacerlo, debes de ir de nuevo al archivo JSON y te aparecerá el estado del servidor MCP así como la opción de iniciar en el caso de que no lo esté.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1752896917931/bb67b978-e01b-4b22-beea-b3362a8517ae.png align="center")

Alternativamente, puedes ir a la sección de extensiones → MCP SERVERS → busca tu servidor y haz clic en "Start Server".

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1752896941393/98d90417-8776-49a7-a913-3fe9e84485e5.png align="center")

### Configurando Github Copilot Chat

### Probamos la funcionalidad de nuestros tools

Primero envía el siguiente mensaje en el chat de Copilot:

```plaintext
Envía un mensaje de bienvenida para Frank
```

Como es la primera vez, se te pedirá permiso para ejecutar la herramienta:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1752897144229/a2f6f527-4b17-4bc3-a4ee-85ae67d7de5e.png align="left")

Y una vez que aceptes, si todo está bien configurado, te responderá algo como:

```plaintext
Welcome to MCP, Frank!
```

Ejemplo de mi resultado:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1752897207474/42d87314-19fb-42dc-9311-e843f5c4f970.png align="center")

Y felicidades 🥳, de esta forma habrás creado tu primera tool (herramienta) de MCP.

## Herramientas avanzadas con servicios asíncronos

También debes de tener en cuenta que para otros casos, sí puedes crear herramientas que interactúen con **servicios externos** y de forma **asíncrona**. Por ejemplo, si quieres buscar canciones en Deezer, puedes crear una herramienta que use un servicio para interactuar con la [API de Deezer](https://developers.deezer.com/api).

Enseguida de dejaré un ejemplo que probé y si funciona a la perfección:

```csharp
using System.ComponentModel;
using McpWebApi.Extensions;
using McpWebApi.Services;
using ModelContextProtocol.Server;

namespace McpWebApi.Tools;

[McpServerToolType]
public class DeezerTool(
    IDeezerService deezerService
)
{
    [McpServerTool, Description("Search for tracks on Deezer")]
    public async Task<string> SearchDeezerTrack(string query)
    {
        var result = await deezerService.SearchTrackAsync(query);
        return result.ToMcpJson();
    }
}
```

### Manejo de tipos de retorno

**Importante**: Las tools de MCP por lo menos mediante la librería que estamos usando, solo pueden retornar un `string`. Por lo tanto, si necesitas retornar un objeto o un modelo, debes de convertirlo a JSON.

En mi caso como puedes ver, cree una extensión para serializar objetos a JSON de forma sencilla, te dejaré el código de la extensión que usé:

```csharp
using System.Text.Json;

namespace McpWebApi.Extensions;

public static class JsonExtensions
{
    private static readonly JsonSerializerOptions PrettyOptions = new()
    {
        WriteIndented = true,
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        PropertyNameCaseInsensitive = true,
        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
    };

    public static string ToMcpJson<T>(this T obj)
    {
        return JsonSerializer.Serialize(obj, PrettyOptions);
    }
}
```

## Conclusión

Crear un servidor MCP con .NET y Web API (remoto) no es tan complicado como parece. Con unos pocos pasos, puedes tener un servidor corriendo y listo con todas las tools que necesites.

Eso sí, en mi caso, usé VS Code porque quería un enfoque más orientado al desarrollo multiplataforma, no limitado a Windows, como ocurriría si usara Visual Studio.

Eso sería todo, puedes dejar un comentario si tienes alguna duda. Hasta luego.
