Creare un server MCP minimo usando C# e pubblicarlo in NuGet

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

Annotazioni

Il Microsoft.McpServer.ProjectTemplates pacchetto modello è attualmente in fase di anteprima.

Prerequisiti

.NET 10.0 SDK
Visual Studio Code (facoltativo)
Estensione C# Dev Kit
Estensione Di GitHub Copilot per Visual Studio Code
account NuGet.org

.NET 10.0 SDK
Visual Studio Code (facoltativo)
Visual Studio (facoltativo)
GitHub Copilot / Estensione Di GitHub Copilot per Visual Studio Code
account NuGet.org

Creare il progetto

In una finestra del terminale installare il modello server MCP:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Annotazioni

.NET 10.0 SDK o una versione successiva è necessario per installare Microsoft.McpServer.ProjectTemplates.
Aprire Visual Studio e selezionare Crea un nuovo progetto nella finestra iniziale oppure selezionare File>Nuovo>progetto/soluzione dall'interno di Visual Studio.
Nella finestra Crea un nuovo progetto selezionare C# dall'elenco Linguaggio e intelligenza artificiale dall'elenco Tutti i tipi di progetto . Dopo aver applicato i filtri lingua e tipo di progetto, selezionare il modello App server MCP e quindi selezionare Avanti.
Nella finestra Configura il nuovo progetto immettere MyMcpServer nel campo Nome progetto . Quindi seleziona Avanti.
Nella finestra Informazioni aggiuntive è possibile configurare le opzioni seguenti:
- Framework: selezionare .NET Framework di destinazione.
- Tipo di trasporto server MCP: scegliere tra la creazione di un server MCP locale (stdio) o un server MCP remoto (http).
- Abilitare la pubblicazione nativa di AOT (Ahead-Of-Time): abilitare il server MCP in modo che sia indipendente e compilato in codice nativo. Per altre informazioni, vedere la guida alla distribuzione nativa di AOT.
- Abilitare la pubblicazione autonoma: abilitare la pubblicazione del server MCP come eseguibile autonomo. Per altre informazioni, vedere la sezione Distribuzione autonoma della guida alla pubblicazione di applicazioni .NET.
Scegliere le opzioni preferite o mantenere quelle predefinite e quindi selezionare Crea.

Visual Studio apre il nuovo progetto.
Aggiornare il file <PackageId> in modo che sia univoco su NuGet.org, ad esempio .csproj.

In una finestra del terminale installare il modello server MCP:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Annotazioni

.NET 10.0 SDK o versione successiva è necessario per installare Microsoft.McpServer.ProjectTemplates.
Apri Visual Studio Code.
Passare alla visualizzazione Esplora risorse e selezionare Crea progetto .NET. In alternativa, è possibile visualizzare il riquadro comandi usando CTRL+MAIUSC+P (Comando+MAIUSC+P in MacOS) e quindi digitare ".NET" per trovare e selezionare il comando .NET: Nuovo progetto .

Questa azione consente di visualizzare un elenco a discesa di progetti .NET.
Dopo aver selezionato il comando, usare la barra di ricerca nel riquadro comandi o scorrere verso il basso per individuare il modello app server MCP .
Selezionare il percorso in cui si vuole creare il nuovo progetto.
Assegnare un nome al nuovo progetto MyMCPServer. Premere Invio.
Selezionare il formato del file della soluzione (.sln o .slnx).
Selezionare Opzioni modello. Qui è possibile configurare le opzioni seguenti:
- Framework: selezionare .NET Framework di destinazione.
- Tipo di trasporto server MCP: scegliere tra la creazione di un server MCP locale (stdio) o un server MCP remoto (http).
- Abilitare la pubblicazione nativa di AOT (Ahead-Of-Time): abilitare il server MCP in modo che sia indipendente e compilato in codice nativo. Per altre informazioni, vedere la guida alla distribuzione nativa di AOT.
- Abilitare la pubblicazione autonoma: abilitare la pubblicazione del server MCP come eseguibile autonomo. Per altre informazioni, vedere la sezione Distribuzione autonoma della guida alla pubblicazione di applicazioni .NET.
Scegliere le opzioni preferite o mantenere quelle predefinite e quindi selezionare Crea progetto.

VS Code apre il nuovo progetto.
Aggiornare il file <PackageId> in modo che sia univoco su NuGet.org, ad esempio .csproj.

Creare una nuova app server MCP con il dotnet new mcpserver comando :
```
dotnet new mcpserver -n SampleMcpServer
```
Per impostazione predefinita, questo comando crea un pacchetto di strumenti autonomo destinato a tutte le piattaforme più comuni supportate da .NET. Per visualizzare altre opzioni, usare dotnet new mcpserver --help.

L'uso del dotnet new mcpserver --help comando offre diverse opzioni di modello che è possibile aggiungere durante la creazione di un nuovo server MCP:
- Framework: selezionare .NET Framework di destinazione.
- Tipo di trasporto server MCP: scegliere tra la creazione di un server MCP locale (stdio) o un server MCP remoto (http).
- Abilitare la pubblicazione nativa di AOT (Ahead-Of-Time): abilitare il server MCP in modo che sia indipendente e compilato in codice nativo. Per altre informazioni, vedere la guida alla distribuzione nativa di AOT.
- Abilitare la pubblicazione autonoma: abilitare la pubblicazione del server MCP come eseguibile autonomo. Per altre informazioni, vedere la sezione Distribuzione autonoma della guida alla pubblicazione di applicazioni .NET.
Naviga nella directory SampleMcpServer:
```
cd SampleMcpServer
```
Compilare il progetto:
```
dotnet build
```
Aggiornare il file <PackageId> in modo che sia univoco su NuGet.org, ad esempio .csproj.

Presentazione del progetto MCP Server

La creazione del progetto server MCP tramite il modello offre i file principali seguenti:

Program.cs: file che definisce l'applicazione come server MCP e registra servizi MCP, ad esempio il tipo di trasporto e gli strumenti MCP.
- Se si sceglie l'opzione di trasporto stdio (predefinita) in durante la creazione del progetto, questo file verrà configurato per definire il server MCP come locale ,ovvero .withStdioServerTransport().
- Se si sceglie l'opzione di trasporto HTTP , questo file verrà configurato in modo da includere definizioni specifiche del trasporto remoto, .withHttpServerTransport()ovvero , MapMcp().
RandomNumberTools.cs: classe che definisce un esempio di strumento server MCP che restituisce un numero casuale tra i valori min/max specificati dall'utente.
[Solo trasporto HTTP][MCPServerName].http: file che definisce l'indirizzo host predefinito per un server MCP HTTP e JSON-RPC comunicazione.
server.json: file che definisce come e dove viene pubblicato il server MCP.

Struttura del progetto MCP Server (stdio)

Configurare il server MCP

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

In Visual Studio selezionare l'icona di GitHub Copilot nell'angolo in alto a destra e selezionare Apri finestra chat.
Nella finestra Chat di GitHub Copilot fare clic sull'icona Seleziona Strumenti e quindi sull'icona con il segno più nell'angolo in alto a destra.
Nella finestra di dialogo Aggiungi server MCP personalizzato immettere le informazioni seguenti:
- Destinazione: scegliere l'ambito in cui è configurato il server MCP:
  - Soluzione: il server MCP è disponibile solo nella soluzione attiva.
  - Globale: il server MCP è disponibile in tutte le soluzioni.
- ID server: nome univoco/identificatore per il server MCP.
- Tipo: tipo di trasporto del server MCP (stdio o HTTP).
- Comando (solo trasporto Stdio): il comando per eseguire il server stdio MCP (cioè dotnet run --project [relative path to .csproj file])
- URL (solo trasporto HTTP): indirizzo del server MCP HTTP
- Variabili di ambiente (facoltativo)
Seleziona Salva. Un .mcp.json file verrà aggiunto alla destinazione specificata.

Trasporto Stdio .mcp.json

Aggiungi il percorso relativo al .csproj file nel campo "args".

{
  "inputs": [],
  "servers": {
    "MyMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<relative-path-to-project-file>"
      ]
    }
  }
}

Trasporto HTTP .mcp.json

{
 "inputs": [],
  "servers": {
    "MyMCPServer": {
      "url": "http://localhost:6278",
      "type": "http",
      "headers": {}
    }
  }
}

Configurare GitHub Copilot per Visual Studio Code per usare il server MCP personalizzato, tramite il riquadro comandi di VS Code o manualmente.

Configurazione del riquadro comandi

Aprire il riquadro comandi usando CTRL+MAIUSC+P (comando+MAIUSC+P in macOS). Cercare "mcp" per individuare il MCP: Add Server comando.
Selezionare il tipo di server MCP da aggiungere (in genere il tipo di trasporto selezionato durante la creazione del progetto).
Se si aggiunge un server MCP stdio , immettere un comando e argomenti facoltativi. Per questo esempio, usare dotnet run --project.

Se si aggiunge un server MCP HTTP , immettere l'indirizzo localhost o Web.
Immettere un ID server univoco (ad esempio: "MyMCPServer").
Selezionare una destinazione di configurazione:
- Globale: rendere disponibile il server MCP in tutte le aree di lavoro. Il file generato mcp.json verrà visualizzato nella configurazione utente globale.
- Area di lavoro: rendere disponibile il server MCP solo dall'interno dell'area di lavoro corrente. Il file generato mcp.json apparirà nella cartella .vscode all'interno della tua area di lavoro.
Dopo aver completato i passaggi precedenti, verrà creato un .mcp.json file nel percorso specificato dalla destinazione di configurazione.

Trasporto Stdio mcp.json

Aggiungi il percorso relativo al .csproj file nel campo "args".

{
  "servers": {
    "MyMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<relative-path-to-project-file>"
      ]
    }
  }
}

Trasporto HTTP mcp.json

{
  "servers": {
    "MyMCPServer": {
      "url": "http://localhost:6278",
      "type": "http"
    }
  },
  "inputs": []
}

Configurazione manuale

Creare una .vscode cartella nella radice del progetto.
Aggiungere un mcp.json file nella .vscode cartella con il contenuto seguente:
```
{
  "servers": {
    "SampleMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<relative-path-to-project-file>"
      ]
    }
  }
}
```
Annotazioni

VS Code esegue i server MCP dalla radice dell'area di lavoro. Il <relative-path-to-project-file> segnaposto deve puntare al file di progetto .NET. Ad esempio, il valore per questa app SampleMcpServer sarà SampleMcpServer.csproj.
Salva il file.

Testare il server MCP

Il modello di server MCP include uno strumento denominato get_random_number che è possibile usare per i test e come punto di partenza per lo sviluppo.

Aprire la chat di GitHub Copilot in Visual Studio e passare alla modalità Agente .
Selezionare l'icona Seleziona strumenti per verificare che MyMCPServer sia disponibile con lo strumento di esempio elencato.
Immettere un prompt per eseguire lo strumento get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot richiede l'autorizzazione per eseguire lo strumento get_random_number per il tuo 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.
- La soluzione corrente esegue sempre il comando per la soluzione di Visual Studio corrente.
- Consenti sempre imposta l'operazione per essere eseguita sempre durante qualsiasi sessione della modalità agente di GitHub Copilot.
Verificare che il server risponda con un numero casuale:
```
Your random number is 42.
```

Il modello di server MCP include uno strumento denominato get_random_number che è possibile usare per i test e come punto di partenza per lo sviluppo.

Aprire la chat di GitHub Copilot in VS Code e passare alla modalità agente .
Selezionare l'icona Seleziona strumenti per verificare che MyMCPServer sia disponibile con lo strumento di esempio elencato.
Immettere un prompt per eseguire lo strumento get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot richiede l'autorizzazione per eseguire lo strumento get_random_number per il tuo 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 di VS Code corrente.
- Consenti sempre imposta l'operazione per essere eseguita sempre in qualsiasi sessione della modalità agente di GitHub Copilot.
Verificare che il server risponda con un numero casuale:
```
Your random number is 42.
```

Aggiungere input e opzioni di configurazione

In questo esempio si migliora il server MCP per usare un valore di configurazione impostato in una variabile di ambiente. Questa potrebbe essere la configurazione necessaria per il funzionamento del server MCP, ad esempio una chiave API, un endpoint a cui connettersi o un percorso di directory locale.

Aggiungere un altro metodo dello strumento dopo il GetRandomNumber metodo in Tools/RandomNumberTools.cs. Aggiornare il codice dello strumento per usare una variabile di ambiente.

[McpServerTool]
[Description("Describes random weather in the provided city.")]
public string GetCityWeather(
    [Description("Name of the city to return weather for")] string city)
{
    // Read the environment variable during tool execution.
    // Alternatively, this could be read during startup and passed via IOptions dependency injection
    var weather = Environment.GetEnvironmentVariable("WEATHER_CHOICES");
    if (string.IsNullOrWhiteSpace(weather))
    {
        weather = "balmy,rainy,stormy";
    }

    var weatherChoices = weather.Split(",");
    var selectedWeatherIndex =  Random.Shared.Next(0, weatherChoices.Length);

    return $"The weather in {city} is {weatherChoices[selectedWeatherIndex]}.";
}

Aggiornare il .vscode/mcp.json per impostare la variabile di ambiente WEATHER_CHOICES per il test.

{
   "servers": {
     "SampleMcpServer": {
       "type": "stdio",
       "command": "dotnet",
       "args": [
         "run",
         "--project",
         "<relative-path-to-project-file>"
       ],
       "env": {
          "WEATHER_CHOICES": "sunny,humid,freezing"
       }
     }
   }
 }

Provare un altro prompt con Copilot in VS Code, ad esempio:
```
What is the weather in Redmond, Washington?
```
VS Code deve restituire una descrizione meteo casuale.

Aggiorna il .mcp/server.json per dichiarare l'input della variabile di ambiente. Lo server.json schema del file è definito dal progetto McP Registry e viene usato da NuGet.org per generare la configurazione MCP di VS Code.

Usare la environmentVariables proprietà per dichiarare le variabili di ambiente usate dall'app che verranno impostate dal client usando il server MCP, ad esempio VS Code.
Usare la proprietà packageArguments per definire gli argomenti CLI che verranno passati all'applicazione. Per altri esempi, vedere il progetto registro MCP.

{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-10-17/server.schema.json",
  "description": "<your description here>",
  "name": "io.github.<your GitHub username here>/<your repo name>",
  "version": "<your package version here>",
  "packages": [
    {
      "registryType": "nuget",
      "registryBaseUrl": "https://api.nuget.org",
      "identifier": "<your package ID here>",
      "version": "<your package version here>",
      "transport": {
        "type": "stdio"
      },
      "packageArguments": [],
      "environmentVariables": [
        {
          "name": "WEATHER_CHOICES",
          "value": "{weather_choices}",
          "variables": {
            "weather_choices": {
              "description": "Comma separated list of weather descriptions to randomly select.",
              "isRequired": true,
              "isSecret": false
            }
          }
        }
      ]
    }
  ],
  "repository": {
    "url": "https://github.com/<your GitHub username here>/<your repo name>",
    "source": "github"
  }
}

Le uniche informazioni utilizzate da NuGet.org nel server.json sono il primo elemento dell'array packages con il valore registryType corrispondente a nuget. Le altre proprietà di primo livello, ad eccezione della packages proprietà, sono attualmente non utilizzate e sono destinate al prossimo Registro MCP centrale. È possibile lasciare i valori segnaposto fino a quando il Registro MCP non è operativo e in grado di accettare le voci del server MCP.

È possibile testare di nuovo il server MCP prima di procedere.

Comprimere e pubblicare in NuGet

Impacchettare il progetto
```
dotnet pack -c Release
```
Questo comando produce un pacchetto di strumenti e diversi pacchetti specifici della piattaforma in base all'elenco <RuntimeIdentifiers> in SampleMcpServer.csproj.
Pubblicare i pacchetti in NuGet:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://api.nuget.org/v3/index.json
```
Assicurarsi di pubblicare tutti i .nupkg file per assicurarsi che ogni piattaforma supportata possa eseguire il server MCP.

Se si vuole testare il flusso di pubblicazione prima della pubblicazione in NuGet.org, è possibile registrare un account nell'ambiente di integrazione della raccolta NuGet: https://int.nugettest.org. Il push comando verrà modificato in:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://apiint.nugettest.org/v3/index.json
```

Per altre informazioni, vedere Pubblicare un pacchetto.

Individuare i server MCP su NuGet.org

Cercare il pacchetto del server MCP in NuGet.org (o int.nugettest.org se è stato pubblicato nell'ambiente di integrazione) e selezionarlo dall'elenco.
Visualizzare i dettagli del pacchetto e copiare il codice JSON dalla scheda "MCP Server".

Nel tuo file mcp.json nella cartella .vscode, aggiungi il codice JSON copiato, simile al seguente:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "weather_choices",
      "description": "Comma separated list of weather descriptions to randomly select.",
      "password": false
    }
  ],
  "servers": {
    "Contoso.SampleMcpServer": {
      "type": "stdio",
      "command": "dnx",
      "args": ["Contoso.SampleMcpServer@0.0.1-beta", "--yes"],
      "env": {
        "WEATHER_CHOICES": "${input:weather_choices}"
      }
    }
  }
}

Se è stato pubblicato nell'ambiente di integrazione di NuGet Gallery, è necessario aggiungere "--add-source", "https://apiint.nugettest.org/v3/index.json" alla fine della "args" matrice.

Salva il file.
In GitHub Copilot selezionare l'icona Seleziona strumenti per verificare che SampleMcpServer sia disponibile con gli strumenti elencati.
Immettere un prompt per eseguire il nuovo strumento get_city_weather :
```
What is the weather in Redmond?
```
Se sono stati aggiunti input al server MCP , ad esempio WEATHER_CHOICES, verrà richiesto di fornire valori.
Verificare che il server risponda con il meteo casuale:
```
The weather in Redmond is balmy.
```

Problemi comuni

Impossibile trovare il comando "dnx" necessario per eseguire SampleMcpServer

Se VS Code mostra questo errore quando si avvia il server MCP, è necessario installare una versione compatibile di .NET SDK.

Screenshot che mostra il comando dnx mancante in VS Code.

Il dnx comando viene fornito come parte di .NET SDK, a partire dalla versione 10. Installare .NET 10 SDK per risolvere questo problema.

GitHub Copilot non usa lo strumento (viene fornita una risposta senza richiamare lo strumento)

In generale, un agente di intelligenza artificiale come GitHub Copilot è informato che dispone di alcuni strumenti disponibili dall'applicazione client, ad esempio VS Code. Alcuni strumenti, come ad esempio lo strumento di esempio per numeri casuali, potrebbero non essere utilizzati dall'agente di intelligenza artificiale perché dispone di funzionalità simili integrate.

Se lo strumento non viene usato, verificare quanto segue:

Verifica che il tuo strumento sia visualizzato nell'elenco degli strumenti abilitati da Visual Studio Code. Vedere lo screenshot in Testare il server MCP per informazioni su come verificarlo.
Fare riferimento in modo esplicito al nome dello strumento nel prompt. In VS Code è possibile fare riferimento allo strumento in base al nome. Ad esempio: Using #get_random_weather, what is the weather in Redmond?.
Verificare che il server MCP sia in grado di avviare. È possibile verificarlo facendo clic sul pulsante "Avvia" visibile sopra la configurazione del server MCP nelle impostazioni utente o area di lavoro di VS Code.

Screenshot che mostra un server MCP nella configurazione di VS Code avviata.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-01-22