Tworzenie minimalnego serwera MCP przy użyciu języka C# i publikowanie w programie NuGet

W tym przewodniku szybkiego startu utworzysz minimalny serwer protokołu Model Context Protocol (MCP) przy użyciu zestawu SDK języka C# dla MCP, połączysz się z nim przy użyciu narzędzia GitHub Copilot i opublikujesz go w repozytorium NuGet. Serwery MCP to usługi, które uwidaczniają możliwości klientom za pośrednictwem protokołu MCP (Model Context Protocol).

Wymagania wstępne

• .NET 10.0 SDK (wersja zapoznawcza 6 lub nowsza)
• Visual Studio Code
• Rozszerzenie GitHub Copilot dla programu Visual Studio Code
• konto NuGet.org

Tworzenie projektu

1. W oknie terminalu zainstaluj szablon serwera MCP:

   dotnet new install Microsoft.McpServer.ProjectTemplates
   

   Uwaga / Notatka

   Do zainstalowania Microsoft.McpServer.ProjectTemplatesprogramu wymagany jest zestaw .NET 10.0 SDK (wersja zapoznawcza 6 lub nowsza).

2. Utwórz nową aplikację serwera MCP za dotnet new mcpserver pomocą polecenia :

   dotnet new mcpserver -n SampleMcpServer
   

   Domyślnie to polecenie tworzy samodzielny pakiet narzędzi przeznaczony dla wszystkich najbardziej typowych platform obsługiwanych przez platformę .NET. Aby wyświetlić więcej opcji, użyj polecenia dotnet new mcpserver --help.

3. Przejdź do SampleMcpServer katalogu:

   cd SampleMcpServer
   

4. Skompiluj projekt:

   dotnet build
   

5. Zaktualizuj <PackageId> w pliku .csproj, aby było unikatowe na NuGet.org, na przykład <NuGet.org username>.SampleMcpServer.

Konfigurowanie serwera MCP w programie Visual Studio Code

Skonfiguruj narzędzie GitHub Copilot dla programu Visual Studio Code do korzystania z niestandardowego serwera MCP:

1. Jeśli jeszcze tego nie zrobiono, otwórz folder projektu w programie Visual Studio Code.

2. Utwórz folder .vscode w katalogu głównym projektu.

3. mcp.json Dodaj plik w folderze .vscode z następującą zawartością:

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

   Uwaga / Notatka

   Program VS Code wykonuje serwery MCP z katalogu głównego obszaru roboczego. Symbol <relative-path-to-project-file> zastępczy powinien wskazywać plik projektu .NET. Na przykład wartość dla tej aplikacji SampleMcpServer byłaby SampleMcpServer.csproj.

4. Zapisz plik.

Testowanie serwera MCP

Szablon serwera MCP zawiera narzędzie o nazwie get_random_number , którego można użyć do testowania i jako punktu wyjścia do programowania.

1. Otwórz narzędzie GitHub Copilot w programie Visual Studio Code i przełącz się do trybu agenta.

2. Wybierz ikonę Select tools, aby sprawdzić, czy serwer SampleMcpServer jest dostępny z wyświetlonym przykładowym narzędziem.

   

3. Wprowadź monit o uruchomienie narzędzia get_random_number :

   Give me a random number between 1 and 100.
   

4. GitHub Copilot prosi o pozwolenie na uruchomienie narzędzia get_random_number dla twojego polecenia. Wybierz pozycję Kontynuuj lub użyj strzałki, aby wybrać bardziej szczegółowe zachowanie:

   • Bieżąca sesja zawsze wykonuje operację w trybie agenta Copilot GitHub.
   • Bieżący obszar roboczy zawsze uruchamia polecenie dla bieżącego obszaru roboczego programu Visual Studio Code.
   • Zawsze zezwalaj ustawia operację na zawsze działającą w każdej sesji trybu agenta Copilot usługi GitHub lub w dowolnym obszarze roboczym Visual Studio Code.

5. Sprawdź, czy serwer odpowiada losową liczbą:

   Your random number is 42.
   

Dodawanie danych wejściowych i opcji konfiguracji

W tym przykładzie rozszerzysz serwer MCP tak, aby używał wartości konfiguracji ustawionej w zmiennej środowiskowej. Konfiguracja potrzebna do działania Twojego serwera MCP może obejmować klucz API, punkt końcowy do połączenia lub ścieżkę katalogu lokalnego.

1. Dodaj kolejną metodę narzędzia po metodzie GetRandomNumber w Tools/RandomNumberTools.cs. Zaktualizuj kod narzędzia, aby używał zmiennej środowiskowej.

   [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]}.";
   }
   

2. Zaktualizuj .vscode/mcp.json, aby ustawić zmienną środowiskową WEATHER_CHOICES do testowania.

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

3. Spróbuj użyć innego monitu za pomocą narzędzia Copilot w programie VS Code, na przykład:

   What is the weather in Redmond, Washington?
   

   Program VS Code powinien zwrócić losowy opis pogody.

4. Zaktualizuj .mcp/server.json, aby zadeklarować dane wejściowe zmiennej środowiskowej. Schemat server.json pliku jest definiowany przez projekt rejestru MCP i jest używany przez NuGet.org do generowania konfiguracji MCP programu VS Code.

   • Użyj właściwości environmentVariables do deklarowania zmiennych środowiskowych używanych przez aplikację, które zostaną ustawione przez klienta za pomocą serwera MCP (na przykład programu VS Code).

   • Użyj właściwości packageArguments do zdefiniowania argumentów CLI, które zostaną przekazane do twojej aplikacji. Aby uzyskać więcej przykładów, zobacz projekt rejestru 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"
     }
   }
   

   Jedynymi informacjami używanymi przez NuGet.org w obiekcie server.json jest pierwszy packages element tablicy z wartością zgodną registryTypez wartością nuget . Inne właściwości top-level oprócz właściwości packages są obecnie nieużywane i są przeznaczone dla centralnego rejestru MCP, który ma się pojawić. Możesz pozostawić wartości zastępcze do momentu, gdy rejestr MCP będzie aktywny i gotowy do akceptowania wpisów serwera MCP.

Przed przejściem do przodu możesz ponownie przetestować serwer MCP .

Pakowanie i publikowanie do NuGet

1. Spakuj projekt:

   dotnet pack -c Release
   

   To polecenie tworzy jeden pakiet narzędzi i kilka pakietów specyficznych dla platformy na podstawie listy w <RuntimeIdentifiers> przy użyciu SampleMcpServer.csproj.

2. Opublikuj pakiety w usłudze NuGet:

   dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://api.nuget.org/v3/index.json
   

   Pamiętaj, aby opublikować wszystkie .nupkg pliki, aby upewnić się, że każda obsługiwana platforma może uruchomić serwer MCP.

   Jeśli chcesz przetestować przepływ publikowania przed opublikowaniem na NuGet.org, możesz zarejestrować konto w zintegrowanym środowisku NuGet Gallery: https://int.nugettest.org. Polecenie push należy zmodyfikować na:

   dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://apiint.nugettest.org/v3/index.json
   

Aby uzyskać więcej informacji, zobacz Publikowanie pakietu.

Odnajdywanie serwerów MCP na NuGet.org

1. Wyszukaj pakiet serwera MCP na NuGet.org (lub int.nugettest.org , jeśli opublikowano w środowisku integracji) i wybierz go z listy.

   

2. Wyświetl szczegóły pakietu i skopiuj kod JSON z karty "Serwer MCP".

   

3. mcp.json W pliku w folderze .vscode dodaj skopiowany kod JSON, który wygląda następująco:

   {
     "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}"
         }
       }
     }
   }
   

   Jeżeli opublikowałeś(-aś) w środowisku integracyjnym galerii NuGet, musisz dodać "--add-source", "https://apiint.nugettest.org/v3/index.json" na końcu tablicy "args".

4. Zapisz plik.

5. W GitHub Copilot wybierz ikonę Wybierz narzędzia, aby sprawdzić, czy SampleMcpServer jest dostępny wraz z wymienionymi narzędziami.

6. Wprowadź monit o uruchomienie nowego narzędzia get_city_weather :

   What is the weather in Redmond?
   

7. Jeśli dodano dane wejściowe do serwera MCP (na przykład WEATHER_CHOICES), zostanie wyświetlony monit o podanie wartości.

8. Sprawdź, czy serwer odpowiada na losową pogodę:

   The weather in Redmond is balmy.
   

Typowe problemy

Nie można odnaleźć polecenia "dnx" potrzebnego do uruchomienia narzędzia SampleMcpServer

Jeśli program VS Code wyświetli ten błąd podczas uruchamiania serwera MCP, musisz zainstalować zgodną wersję zestawu .NET SDK.

Polecenie dnx jest dostarczane jako część zestawu .NET SDK, począwszy od wersji 10. Zainstaluj zestaw .NET 10 SDK , aby rozwiązać ten problem.

GitHub Copilot nie korzysta z twojego narzędzia (odpowiedź jest udostępniana bez wywoływania twojego narzędzia)

Ogólnie rzecz biorąc, agent sztucznej inteligencji, taki jak GitHub Copilot, jest informowany, że ma pewne narzędzia dostępne przez aplikację kliencką, taką jak VS Code. Niektóre narzędzia, takie jak przykładowe narzędzie do liczb losowych, mogą nie być używane przez agenta sztucznej inteligencji, ponieważ ma on wbudowaną podobną funkcjonalność.

Jeśli narzędzie nie jest używane, sprawdź następujące kwestie:

1. Sprawdź, czy narzędzie jest wyświetlane na liście narzędzi, które program VS Code włączył. Zobacz zrzut ekranu przedstawiający testowanie serwera MCP , aby dowiedzieć się, jak to sprawdzić.
2. Jawnie odwołuj się do nazwy narzędzia w wierszu polecenia. W programie VS Code możesz odwoływać się do narzędzia według nazwy. Na przykład Using #get_random_weather, what is the weather in Redmond?.
3. Sprawdź, czy serwer MCP jest w stanie się uruchomić. Możesz to sprawdzić, klikając przycisk "Uruchom" widoczny nad konfiguracją serwera MCP w ustawieniach użytkownika lub obszaru roboczego programu VS Code.

Treści powiązane

• Zacznij korzystać z .NET AI i protokołu kontekstu modelu
• Przykłady protokołu kontekstowego modelu .NET
• Tworzenie minimalnego klienta MCP
• Opublikuj pakiet
• Znajdowanie i ocenianie pakietów NuGet dla projektu
• Co nowego na platformie .NET 10