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. I server MCP sono servizi che espongono funzionalità ai client tramite il protocollo MCP (Model Context Protocol).

Annotazioni

L'esperienza Microsoft.Extensions.AI.Templates è attualmente in anteprima. Il modello usa la libreria ModelContextProtocol e lo schema del Registro di sistema server.json MCP, entrambi in anteprima.

Prerequisiti

.NET 10.0 SDK (anteprima 6 o superiore)
Visual Studio Code
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.Extensions.AI.Templates
```
Annotazioni

.NET 10.0 SDK (Anteprima 6 o versione successiva) è necessario per installare Microsoft.Extensions.AI.Templates.
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.
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.

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:
```
{
  "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 GitHub Copilot in Visual Studio Code e passare alla modalità agente.
Selezionare l'icona Seleziona strumenti per verificare che SampleMcpServer 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 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 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 2025-10-21