Creare e connettersi a un server MCP minimo con .NET

2025-05-28

In questa guida introduttiva si crea un server MCP (Model Context Protocol) minimo usando C# SDK per MCP e ci si connette usando GitHub Copilot. I server MCP sono servizi che espongono funzionalità ai client tramite il protocollo MCP (Model Context Protocol).

Prerequisiti

.NET 8.0 SDK o versione successiva
Visual Studio Code
Estensione Di GitHub Copilot per Visual Studio Code

Creare il progetto

In una finestra del terminale passare alla directory in cui si vuole creare l'app e creare una nuova app console con il dotnet new comando :
```
dotnet new console -n MinimalMcpServer
```
Naviga nella directory MinimalMcpServer:
```
cd MinimalMcpServer
```
Aggiungere i pacchetti NuGet seguenti all'app:
```
dotnet add package ModelContextProtocol --prerelease
dotnet add package Microsoft.Extensions.Hosting
```
- Il pacchetto ModelContextProtocol è l'SDK C# ufficiale per l'uso del protocollo di contesto del modello.
- Il pacchetto Microsoft.Extensions.Hosting fornisce i servizi generici .NET HostBuilder e i servizi per la gestione dei log e l'iniezione delle dipendenze.

Aggiungere il codice dell'app

Sostituire il contenuto di Program.cs con il codice seguente per implementare un server MCP minimo che espone semplici strumenti echo. Il modello di intelligenza artificiale richiama questi strumenti in base alle esigenze per generare risposte alle richieste degli utenti.

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

// Create a generic host builder for
// dependency injection, logging, and configuration.
var builder = Host.CreateApplicationBuilder(args);

// Configure logging for better integration with MCP clients.
builder.Logging.AddConsole(consoleLogOptions =>
{
consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
});

// Register the MCP server and configure it to use stdio transport.
// Scan the assembly for tool definitions.
builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();

// Build and run the host. This starts the MCP server.
await builder.Build().RunAsync();

// Define a static class to hold MCP tools.
[McpServerToolType]
public static class EchoTool
{
    // Expose a tool that echoes the input message back to the client.
    [McpServerTool, Description("Echoes the message back to the client.")]
    public static string Echo(string message) => $"Hello from C#: {message}";

    // Expose a tool that returns the input message in reverse.
    [McpServerTool, Description("Echoes in reverse the message sent by the client.")]
    public static string ReverseEcho(string message) => new string(message.Reverse().ToArray());
}

Il codice precedente:

Crea un generatore host generico per inserimento delle dipendenze, registrazione e configurazione.
Configura la registrazione per una migliore integrazione con i client MCP.
Registra il server MCP, lo configura per l'uso del trasporto stdio e analizza l'assembly per individuare le definizioni degli strumenti.
Compila ed esegue l'host, che avvia il server MCP.
Definisce una classe statica per contenere due strumenti MCP che restituiscono i valori al client.

Configurare il server MCP in Visual Studio Code

Configurare GitHub Copilot per Visual Studio Code per l'uso del server MCP personalizzato:

Se non è già stato fatto, aprire la cartella del progetto in Visual Studio Code.
Creare una .vscode cartella nella radice del progetto.

Aggiungere un mcp.json file nella .vscode cartella con il contenuto seguente:

{
  "inputs": [],
  "servers": {
    "MinimalMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "${workspaceFolder}/MinimalMcpServer.csproj"
      ]
    }
  }
}

Salva il file.

Testare il server MCP

Aprire GitHub Copilot in Visual Studio Code e passare alla modalità agente.
Selezionare l'icona Seleziona strumenti per verificare che MinimalMcpServer sia disponibile con entrambi gli strumenti elencati.
Immettere un prompt per eseguire lo strumento ReverseEcho :
```
Reverse the following: "Hello, minimal MCP server!"
```
GitHub Copilot richiede l'autorizzazione per eseguire lo strumento ReverseEcho per il prompt. Selezionare Continua o usare la freccia per selezionare un comportamento più specifico:
- La sessione corrente esegue sempre l'operazione nella sessione attuale in Modalità Agente di GitHub Copilot.
- L'area di lavoro corrente esegue sempre il comando per l'area di lavoro corrente di Visual Studio Code.
- Consenti sempre imposta l'operazione per essere eseguita sempre per qualsiasi sessione in Modalità Agente di GitHub Copilot o per qualsiasi workspace di Visual Studio Code.
Verificare che il server risponda con il messaggio ricevuto:
```
!revres PCM laminim ,olleH
```

Creare un client MCP minimo Introduzione all'intelligenza artificiale .NET e al protocollo del contesto del modello

Condividi tramite