Vytvoření minimálního serveru MCP pomocí C# a publikování na NuGet

V tomto rychlém startu vytvoříte minimální server MCP (Model Context Protocol) pomocí sady C# SDK pro MCP, připojíte se k němu pomocí GitHub Copilotu a publikujete ho na NuGet (pouze přenos stdio). Servery MCP jsou služby, které zpřístupňují možnosti klientům prostřednictvím protokolu MCP (Model Context Protocol).

Poznámka:

Balíček Microsoft.McpServer.ProjectTemplates šablony je aktuálně ve verzi Preview.

Požadavky

.NET 10.0 SDK
Visual Studio Code (volitelné)
Rozšíření C# Dev Kit
Rozšíření GitHub Copilot pro Visual Studio Code
účet NuGet.org

.NET 10.0 SDK
Visual Studio Code (volitelné)
Visual Studio (volitelné)
GitHub Copilot / Rozšíření GitHub Copilot pro Visual Studio Code
účet NuGet.org

Vytvoření projektu

V okně terminálu nainstalujte šablonu serveru MCP:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Poznámka:

K instalaci Microsoft.McpServer.ProjectTemplates se vyžaduje sada .NET 10.0 SDK nebo novější verze.
Otevřete Visual Studio a v okně Start vyberte Vytvořit nový projekt (nebo v sadě Visual Studio vyberte Soubor>nový>projekt nebo řešení ).
V okně Vytvořit nový projekt vyberte jazyk C# ze seznamu Jazyků a AI ze seznamu Všechny typy projektů . Po použití filtrů jazyka a typu projektu vyberte šablonu aplikace serveru MCP a pak vyberte Další.
V okně Konfigurovat nový projekt zadejte MyMcpServer do pole Název projektu . Pak vyberte Další.
V okně Další informace můžete nakonfigurovat následující možnosti:
- Architektura: Vyberte cílový .NET Framework.
- Typ přenosu serveru MCP: Vyberte mezi vytvořením místního serveru (stdio) nebo vzdáleného serveru (http) MCP.
- Povolte nativní publikování AOT (Ahead-of-Time): Umožněte, aby byl server MCP samostatně obsažený a zkompilován do nativního kódu. Další informace najdete v průvodci nasazením nativní AOT.
- Povolte samostatné publikování: Povolte publikování serveru MCP jako samostatného spustitelného souboru. Další informace najdete v části Věnované vlastnímu nasazení v průvodci publikováním aplikací .NET.
Zvolte upřednostňované možnosti nebo ponechte výchozí možnosti a pak vyberte Vytvořit.

Visual Studio otevře nový projekt.
<PackageId> Aktualizujte soubor .csproj tak, aby byl jedinečný na NuGet.org, například <NuGet.org username>.SampleMcpServer.

V okně terminálu nainstalujte šablonu serveru MCP:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Poznámka:

K instalaci Microsoft.McpServer.ProjectTemplates se vyžaduje sada .NET 10.0 SDK nebo novější.
Otevřete Visual Studio Code.
Přejděte do zobrazení Průzkumníka a vyberte Vytvořit projekt .NET. Případně můžete vyvolat paletu příkazů pomocí kombinace kláves Ctrl+Shift+P (Command+Shift+P v macOS) a zadáním příkazu .NET najít a vybrat příkaz .NET: Nový projekt .

Tato akce vyvolá rozevírací seznam projektů .NET.
Po výběru příkazu vyhledejte šablonu aplikace serveru MCP pomocí panelu hledání na paletě příkazů nebo se posuňte dolů.
Vyberte umístění, kam chcete nový projekt vytvořit.
Zadejte název nového projektu MyMCPServer. Stiskněte klávesu Enter.
Vyberte formát souboru řešení (.sln nebo .slnx).
Vyberte Možnosti šablony. Tady můžete nakonfigurovat následující možnosti:
- Framework: Vyberte cílové rozhraní .NET Framework.
- Typ přenosu serveru MCP: Vyberte mezi vytvořením místního serveru (stdio) nebo vzdáleného serveru (http) MCP.
- Povolte nativní publikování AOT (Ahead-Of-Time): Umožněte, aby váš server MCP byl samostatně funkční a zkompilován do nativního kódu. Další informace najdete v průvodci nasazením nativní AOT.
- Povolte samostatné publikování: Povolte publikování serveru MCP jako samostatného spustitelného souboru. Další informace najdete v části Věnované vlastnímu nasazení v průvodci publikováním aplikací .NET.
Zvolte upřednostňované možnosti nebo ponechte výchozí možnosti a pak vyberte Vytvořit projekt.

VS Code otevře nový projekt.
<PackageId> Aktualizujte soubor .csproj tak, aby byl jedinečný na NuGet.org, například <NuGet.org username>.SampleMcpServer.

Pomocí příkazu vytvořte novou serverovou aplikaci dotnet new mcpserver MCP:
```
dotnet new mcpserver -n SampleMcpServer
```
Ve výchozím nastavení tento příkaz vytvoří samostatný balíček nástrojů, který cílí na všechny nejběžnější platformy, na které se podporuje .NET. Pokud chcete zobrazit další možnosti, použijte dotnet new mcpserver --help.

dotnet new mcpserver --help Pomocí příkazu získáte několik možností šablony, které můžete přidat při vytváření nového serveru MCP:
- Architektura: Vyberte cílové .NET Framework.
- Typ přenosu serveru MCP: Vyberte mezi vytvořením místního serveru (stdio) nebo vzdáleného serveru (http) MCP.
- Povolte nativní publikování AOT (Ahead-Of-Time): Povolte, aby byl server MCP samostatnou aplikací a zkompilován do nativního kódu. Další informace najdete v průvodci nasazením nativní AOT.
- Povolte samostatné publikování: Povolte publikování serveru MCP jako samostatného spustitelného souboru. Další informace najdete v části Věnované vlastnímu nasazení v průvodci publikováním aplikací .NET.
Přejděte do SampleMcpServer adresáře:
```
cd SampleMcpServer
```
Sestavení projektu:
```
dotnet build
```
<PackageId> Aktualizujte soubor .csproj tak, aby byl jedinečný na NuGet.org, například <NuGet.org username>.SampleMcpServer.

Prohlídka projektu serveru MCP

Vytvoření projektu serveru MCP prostřednictvím šablony vám poskytne následující hlavní soubory:

Program.cs: Soubor definující aplikaci jako server MCP a registraci služeb MCP, jako je typ přenosu a nástroje MCP.
- Při vytváření projektu zvolíte možnost přenosu stdio (výchozí), bude tento soubor nakonfigurován tak, aby definoval server MCP jako místní server (to znamená .withStdioServerTransport()).
- Volba možnosti přenosu HTTP nakonfiguruje tento soubor tak, aby zahrnoval definice specifické pro vzdálený přenos (to znamená , .withHttpServerTransport(), MapMcp()).
RandomNumberTools.cs: Třída definující ukázkový nástroj serveru MCP, který vrací náhodné číslo mezi uživatelsky zadanými minimálními a maximálními hodnotami.
[Pouze přenos HTTP][MCPServerName].http: Soubor definující výchozí adresu hostitele pro server HTTP MCP a JSON-RPC komunikaci.
server.json: Soubor definující způsob a umístění publikování serveru MCP.

Struktura projektu serveru MCP (stdio)

Konfigurace serveru MCP

Nakonfigurujte GitHub Copilot pro Visual Studio tak, aby používal váš vlastní server MCP.

V sadě Visual Studio vyberte ikonu GitHub Copilot v pravém horním rohu a vyberte Otevřít okno chatu.
V okně GitHub Copilot Chat klikněte na ikonu klíče Vybrat nástroje a poté na ikonu plus v pravém horním rohu.
V dialogovém okně Přidat vlastní server MCP zadejte následující informace:
- Cíl: Zvolte obor, ve kterém je nakonfigurovaný server MCP:
  - Řešení – Server MCP je k dispozici pouze v rámci aktivního řešení.
  - Globální – Server MCP je k dispozici ve všech řešeních.
- ID serveru: Jedinečný název nebo identifikátor serveru MCP.
- Typ: Typ přenosu serveru MCP (stdio nebo HTTP).
- Command (pouze přenos Stdio): Příkaz ke spuštění MCP serveru stdio (tj. dotnet run --project [relative path to .csproj file])
- Adresa URL (pouze přenos HTTP):: Adresa vašeho serveru HTTP MCP
- Proměnné prostředí (volitelné)
Vyberte Uložit. Do .mcp.json zadaného cíle se přidá soubor.

Stdio Transport .mcp.json

Do pole "args" přidejte relativní cestu k .csproj souboru.

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

Přenos HTTP .mcp.json

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

Nakonfigurujte GitHub Copilot pro Visual Studio Code tak, aby používal váš vlastní server MCP, a to buď prostřednictvím palety příkazů VS Code, nebo ručně.

Konfigurace palety příkazů

Otevřete paletu příkazů pomocí Ctrl+Shift+P (Command+Shift+P v macOS). Vyhledejte "mcp" a najděte příkaz MCP: Add Server.
Vyberte typ serveru MCP, který chcete přidat (obvykle typ přenosu, který jste vybrali při vytváření projektu).
Pokud přidáváte server STDIO MCP, zadejte příkaz a volitelné argumenty. V tomto příkladu použijte dotnet run --project.

Pokud přidáváte server HTTP MCP, zadejte adresu localhost nebo webovou adresu.
Zadejte jedinečné ID serveru (například MyMCPServer).
Vyberte cíl konfigurace:
- Globální: Zpřístupnění serveru MCP ve všech pracovních prostorech Vygenerovaný mcp.json soubor se zobrazí v rámci globální konfigurace uživatele.
- Pracovní prostor: Zpřístupnit server MCP pouze z aktuálního pracovního prostoru. Vygenerovaný mcp.json soubor se zobrazí pod složkou .vscode v pracovním prostoru.
Po dokončení předchozích kroků se soubor .mcp.json vytvoří v umístění určeném cílem konfigurace.

Stdio Transport mcp.json

Do pole "args" přidejte relativní cestu k .csproj souboru.

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

Přenos HTTP mcp.json

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

Ruční konfigurace

Vytvořte .vscode složku v kořenovém adresáři projektu.
mcp.json Do složky přidejte soubor .vscode s následujícím obsahem:
```
{
  "servers": {
    "SampleMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<relative-path-to-project-file>"
      ]
    }
  }
}
```
Poznámka:

VS Code spouští servery MCP z kořenového adresáře pracovního prostoru. Zástupný <relative-path-to-project-file> symbol by měl odkazovat na soubor projektu .NET. Například hodnota pro tuto aplikaci SampleMcpServer by byla SampleMcpServer.csproj.
Uložte soubor.

Otestování serveru MCP

Šablona serveru MCP obsahuje nástroj get_random_number, který můžete použít pro testování a jako počáteční bod pro vývoj.

Otevřete chat GitHub Copilot v sadě Visual Studio a přepněte do režimu agenta .
Výběrem ikony Vybrat nástroje ověřte, že je váš MyMCPServer dostupný s ukázkovým nástrojem uvedeným v seznamu.
Zadejte výzvu ke spuštění nástroje get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot požaduje oprávnění ke spuštění nástroje get_random_number pro vaši výzvu. Vyberte Pokračovat nebo pomocí šipky vyberte konkrétnější chování:
- Aktuální relace vždy provádí operaci v aktuální relaci režimu GitHub Copilot Agent.
- Aktuální řešení vždy spustí příkaz pro aktuální řešení VS.
- Vždy povolte nastaví operaci tak, aby vždy běžela pro libovolnou relaci režimu agenta GitHub Copilot.
Ověřte, že server reaguje náhodným číslem:
```
Your random number is 42.
```

Šablona serveru MCP obsahuje nástroj get_random_number, který můžete použít pro testování a jako počáteční bod pro vývoj.

Otevřete chat GitHub Copilot v editoru VS Code a přepněte do režimu agenta .
Výběrem ikony Vybrat nástroje ověřte, že je váš MyMCPServer dostupný s ukázkovým nástrojem uvedeným v seznamu.
Zadejte výzvu ke spuštění nástroje get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot požaduje oprávnění ke spuštění nástroje get_random_number pro vaši výzvu. Vyberte Pokračovat nebo pomocí šipky vyberte konkrétnější chování:
- Aktuální relace vždy provádí operaci v aktuální relaci režimu GitHub Copilot Agent.
- Aktuální pracovní prostor vždy spustí příkaz pro aktuální pracovní prostor VS Code.
- Vždy povolte nastaví operaci tak, aby vždy běžela pro každou relaci režimu agenta GitHub Copilot.
Ověřte, že server reaguje náhodným číslem:
```
Your random number is 42.
```

Přidání vstupů a možností konfigurace

V tomto příkladu vylepšíte server MCP tak, aby používal konfigurační hodnotu nastavenou v proměnné prostředí. Tato konfigurace může být nutná pro fungování serveru MCP, jako je klíč rozhraní API, koncový bod pro připojení nebo cesta k místnímu adresáři.

Přidejte další metodu nástroje za metodu GetRandomNumber v souboru Tools/RandomNumberTools.cs. Aktualizujte kód nástroje tak, aby používal proměnnou prostředí.

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

Aktualizujte .vscode/mcp.json pro nastavení proměnné prostředí WEATHER_CHOICES pro účely testování.

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

Zkuste v editoru VS Code použít další výzvu s příkazem Copilot, například:
```
What is the weather in Redmond, Washington?
```
VS Code by měl vrátit náhodný popis počasí.

Aktualizujte .mcp/server.json, abyste deklarovali vstup vaší proměnné prostředí. Schéma server.json souborů je definováno projektem registru MCP a používá NuGet.org ke generování konfigurace VS Code MCP.

environmentVariables Pomocí vlastnosti deklarujte proměnné prostředí používané vaší aplikací, které klient nastaví pomocí serveru MCP (například VS Code).
packageArguments Pomocí vlastnosti definujte argumenty rozhraní příkazového řádku, které se předají vaší aplikaci. Další příklady najdete v projektu registru 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"
  }
}

Jedinečná informace používaná NuGet.org je v server.json, a to první položka pole packages, která má hodnotu registryType odpovídající nuget. Ostatní vlastnosti nejvyšší úrovně kromě packages vlastnosti jsou aktuálně nepoužívané a jsou určeny pro nadcházející centrální registr MCP. Zástupné hodnoty můžete ponechat, dokud nebude registr MCP aktivní a připravený přijmout položky serveru MCP.

Server MCP můžete otestovat znovu, než se posunete dál.

Balení a publikování do NuGetu

Zabalte projekt:
```
dotnet pack -c Release
```
Tento příkaz vytvoří jeden balíček nástrojů a několik balíčků specifických pro platformu <RuntimeIdentifiers> na základě seznamu v SampleMcpServer.csproj.
Publikování balíčků do NuGetu:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://api.nuget.org/v3/index.json
```
Nezapomeňte publikovat všechny .nupkg soubory, abyste zajistili, že každá podporovaná platforma může spustit server MCP.

Pokud chcete otestovat tok publikování před publikováním do NuGet.org, můžete zaregistrovat účet v prostředí integrace galerie NuGet: https://int.nugettest.org. Příkaz push by se změnil na:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://apiint.nugettest.org/v3/index.json
```

Další informace najdete v tématu Publikování balíčku.

Zjišťování serverů MCP na NuGet.org

Vyhledejte balíček serveru MCP na NuGet.org (nebo int.nugettest.org , pokud jste publikovali v prostředí integrace) a vyberte ho ze seznamu.
Zobrazte podrobnosti balíčku a zkopírujte JSON z karty Server MCP.

mcp.json Do souboru ve .vscode složce přidejte zkopírovaný JSON, který vypadá takto:

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

Pokud jste publikovali do integračního prostředí galerie NuGet, musíte na konec pole "--add-source", "https://apiint.nugettest.org/v3/index.json" přidat "args".

Uložte soubor.
V GitHub Copilotu vyberte ikonu Vybrat nástroje a ověřte, že je váš SampleMcpServer dostupný v uvedených nástrojích.
Zadejte výzvu ke spuštění nového nástroje get_city_weather :
```
What is the weather in Redmond?
```
Pokud jste přidali vstupy na server MCP (například WEATHER_CHOICES), zobrazí se výzva k zadání hodnot.
Ověřte, že server reaguje náhodným počasím:
```
The weather in Redmond is balmy.
```

Běžné problémy

Příkaz dnx potřebný ke spuštění SampleMcpServer nebyl nalezen.

Pokud VS Code při spuštění serveru MCP zobrazí tuto chybu, musíte nainstalovat kompatibilní verzi sady .NET SDK.

Snímek obrazovky znázorňující chybějící příkaz dnx ve VS Code

Příkaz dnx se dodává jako součást sady .NET SDK počínaje verzí 10. Pokud chcete tento problém vyřešit, nainstalujte sadu .NET 10 SDK.

GitHub Copilot váš nástroj nepoužívá (odpověď se zobrazí bez vyvolání vašeho nástroje).

Obecně řečeno, agent AI, jako je GitHub Copilot, je informován, že má k dispozici některé nástroje klientské aplikace, jako je VS Code. Některé nástroje, jako je nástroj pro náhodné číslo vzorku, nemusí agent umělé inteligence využívat, protože má podobnou integrovanou funkci.

Pokud se váš nástroj nepoužívá, zkontrolujte následující:

Ověřte, že se váš nástroj zobrazí v seznamu nástrojů, které nástroj VS Code povolil. Podívejte se na snímek obrazovky v části Test serveru MCP, jak to zkontrolovat.
Explicitně odkazujte na název nástroje ve výzvě. Ve VS Code můžete na nástroj odkazovat podle názvu. Například: Using #get_random_weather, what is the weather in Redmond?.
Ověřte, že se server MCP může spustit. Můžete to zkontrolovat kliknutím na tlačítko Start zobrazené nad konfigurací serveru MCP v nastavení uživatele nebo pracovního prostoru VS Code.

Snímek obrazovky znázorňující server MCP v konfiguraci VS Code, která je spuštěná

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-04