Skapa en minimal MCP-server med C# och publicera till NuGet

I den här snabbstarten skapar du en minimal MCP-server (Model Context Protocol) med C# SDK för MCP, ansluter till den med GitHub Copilot och publicerar den till NuGet (endast stdio-transport). MCP-servrar är tjänster som exponerar funktioner för klienter via Model Context Protocol (MCP).

Anmärkning

Mallpaketet Microsoft.McpServer.ProjectTemplates är för närvarande i förhandsversion.

Förutsättningar

.NET 10.0 SDK
Visual Studio Code (valfritt)
C# Dev Kit-tillägg
GitHub Copilot-tillägg för Visual Studio Code
NuGet.org konto

.NET 10.0 SDK
Visual Studio Code (valfritt)
Visual Studio (valfritt)
GitHub Copilot / GitHub Copilot-tillägg för Visual Studio Code
NuGet.org konto

Skapa projektet

Installera MCP Server-mallen i ett terminalfönster:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Anmärkning

.NET 10.0 SDK eller en senare version krävs för att installera Microsoft.McpServer.ProjectTemplates.
Öppna Visual Studio och välj Skapa ett nytt projekt i startfönstret (eller välj Fil>nytt>projekt/lösning inifrån Visual Studio).
I fönstret Skapa ett nytt projekt väljer du C# i listan Språk och AI i listan Alla projekttyper . När du har tillämpat filter för språk och projekttyp väljer du mallen MCP Server-app och väljer sedan Nästa.
I fönstret Konfigurera ditt nya projekt anger du MyMcpServer i fältet Projektnamn . Välj sedan Nästa.
I fönstret Ytterligare information kan du konfigurera följande alternativ:
- Ramverk: Välj .NET-målramverket.
- MCP-servertransporttyp: Välj mellan att skapa en lokal (stdio) eller en fjärransluten (http) MCP-server.
- Aktivera intern AOT-publicering (Ahead-Of-Time): Aktivera din MCP-server så att den är fristående och kompilerad till naturlig kod. Mer information finns i distributionsguiden för intern AOT.
- Aktivera fristående publicering: Aktivera din MCP-server så att den kan publiceras som en självständig körbar fil. Mer information finns i avsnittet Fristående distribution i publiceringsguiden för .NET-program.
Välj önskade alternativ eller behåll standardalternativen och välj sedan Skapa.

Visual Studio öppnar det nya projektet.
Uppdatera <PackageId> i .csproj-filen så att den är unik på NuGet.org, till exempel <NuGet.org username>.SampleMcpServer.

Installera MCP Server-mallen i ett terminalfönster:
```
dotnet new install Microsoft.McpServer.ProjectTemplates
```
Anmärkning

.NET 10.0 SDK eller senare krävs för att installera Microsoft.McpServer.ProjectTemplates.
Öppna Visual Studio Code.
Gå till Utforskarvyn och välj Skapa .NET-projekt. Du kan också ta upp kommandopaletten med hjälp av Ctrl+Skift+P (Kommando+Skift+P på MacOS) och sedan skriva ".NET" för att hitta och välja kommandot .NET: New Project .

Den här åtgärden skapar en listruta med .NET-projekt.
När du har valt kommandot använder du sökfältet i kommandopaletten eller bläddrar nedåt för att hitta mallen MCP Server-app .
Välj den plats där du vill att det nya projektet ska skapas.
Ge ditt nya projekt ett namn, MyMCPServer. Tryck på Retur.
Välj ditt lösningsfilformat (.sln eller .slnx).
Välj Mallalternativ. Här kan du konfigurera följande alternativ:
- Ramverk: Välj .NET-målramverket.
- MCP-servertransporttyp: Välj mellan att skapa en lokal (stdio) eller en fjärransluten (http) MCP-server.
- Aktivera inbyggd AOT-publicering (Ahead-Of-Time): Aktivera din MCP-server så att den är fristående och kompilerad till nativ kod. Mer information finns i distributionsguiden för intern AOT.
- Aktivera fristående publicering: Aktivera MCP-servern för att publiceras som en fristående körbar fil. Mer information finns i avsnittet Fristående distribution i publiceringsguiden för .NET-program.
Välj önskade alternativ eller behåll standardalternativen och välj sedan Skapa projekt.

VS Code öppnar det nya projektet.
Uppdatera <PackageId> i .csproj-filen så att den är unik på NuGet.org, till exempel <NuGet.org username>.SampleMcpServer.

Skapa en ny MCP-serverapp med dotnet new mcpserver kommandot :
```
dotnet new mcpserver -n SampleMcpServer
```
Som standard skapar det här kommandot ett fristående verktygspaket som riktar sig till alla de vanligaste plattformarna som .NET stöds på. Om du vill se fler alternativ använder du dotnet new mcpserver --help.

Med kommandot dotnet new mcpserver --help får du flera mallalternativ som du kan lägga till när du skapar en ny MCP-server:
- Ramverk: Välj .NET-målramverket.
- MCP-servertransporttyp: Välj mellan att skapa en lokal (stdio) eller en fjärransluten (http) MCP-server.
- Aktivera inbyggd AOT-publicering (Ahead-Of-Time): Aktivera din MCP-server så att den är fristående och kompilerad till nativ kod. Mer information finns i distributionsguiden för intern AOT.
- Aktivera fristående publicering: Aktivera MCP-servern för att publiceras som en fristående körbar fil. Mer information finns i avsnittet Fristående distribution i publiceringsguiden för .NET-program.
Gå till SampleMcpServer katalogen:
```
cd SampleMcpServer
```
Bygg projektet:
```
dotnet build
```
Uppdatera <PackageId> i .csproj-filen så att den är unik på NuGet.org, till exempel <NuGet.org username>.SampleMcpServer.

Gå igenom MCP Server-projektet

När du skapar mcp-serverprojektet via mallen får du följande huvudfiler:

Program.cs: En fil som definierar programmet som en MCP-server och registrerar MCP-tjänster som transporttyp och MCP-verktyg.
- Om du väljer alternativet (standard) stdio transport i när du skapar projektet, konfigureras den här filen för att definiera MCP-servern som en lokal (det vill: .withStdioServerTransport()).
- Om du väljer http-transportalternativet konfigureras den här filen så att den innehåller fjärrtransportspecifika definitioner (d.ex .withHttpServerTransport(). , MapMcp()).
RandomNumberTools.cs: En klass som definierar ett exempel på ett MCP-serververktyg som returnerar ett slumpmässigt tal mellan användardefinierade min/max-värden.
[Endast HTTP-transport][MCPServerName].http: En fil som definierar den förvalda värdadressen för en HTTP MCP-server och JSON-RPC-kommunikation.
server.json: En fil som definierar hur och var din MCP-server publiceras.

MCP Server-projektstruktur (stdio)

Konfigurera MCP-servern

Konfigurera GitHub Copilot för Visual Studio för att använda din anpassade MCP-server.

I Visual Studio väljer du Ikonen GitHub Copilot i det övre högra hörnet och väljer Öppna chattfönster.
I GitHub Copilot Chat-fönstret klickar du på ikonen Välj verktygsnyckel följt av plusikonen i det övre högra hörnet.
I dialogrutan Lägg till anpassad MCP-server anger du följande information:
- Mål: Välj omfånget för var MCP-servern har konfigurerats:
  - Lösning – MCP-servern är endast tillgänglig i den aktiva lösningen.
  - Global – MCP-servern är tillgänglig för alla lösningar.
- Server-ID: Det unika namnet/identifieraren för MCP-servern.
- Typ: Transporttypen för MCP-servern (stdio eller HTTP).
- Kommando (endast Stdio-transport): Kommandot för att köra din stdio MCP-server (det vill: dotnet run --project [relative path to .csproj file])
- URL (endast HTTP-transport): Adressen till HTTP MCP-servern
- Miljövariabler (valfritt)
Välj Spara. En .mcp.json fil kommer att läggas till på den angivna platsen.

Stdio Transport .mcp.json

Lägg till den relativa sökvägen till .csproj-filen under fältet "args".

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

HTTP-transport .mcp.json

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

Konfigurera GitHub Copilot för Visual Studio Code för att använda din anpassade MCP-server, antingen via VS Code-kommandopaletten eller manuellt.

Konfiguration av kommandopaletten

Öppna kommandopaletten med Ctrl+Skift+P (Kommando+Skift+P på macOS). Sök "mcp" för att hitta MCP: Add Server kommandot.
Välj den typ av MCP-server som ska läggas till (vanligtvis den transporttyp som du valde när projektet skapades).
Om du lägger till en stdio MCP-server anger du ett kommando och valfria argument. I det här exemplet använder du dotnet run --project.

Om du lägger till en HTTP MCP-server anger du localhost eller webbadress.
Ange ett unikt server-ID (exempel: "MyMCPServer").
Välj ett konfigurationsmål:
- Global: Gör MCP-servern tillgänglig på alla arbetsytor. Den genererade mcp.json filen visas under din globala användarkonfiguration.
- Arbetsyta: Gör MCP-servern endast tillgänglig från den aktuella arbetsytan. Den genererade mcp.json filen visas under .vscode mappen på din arbetsyta.
När du har slutfört föregående steg skapas en .mcp.json fil på den plats som anges av konfigurationsmålet.

Stdio Transport mcp.json

Lägg till den relativa sökvägen till .csproj-filen under fältet "args".

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

HTTP-transport mcp.json

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

Manuell konfiguration

Skapa en .vscode mapp i roten av projektet.
Lägg till en mcp.json fil i .vscode mappen med följande innehåll:
```
{
  "servers": {
    "SampleMcpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<relative-path-to-project-file>"
      ]
    }
  }
}
```
Anmärkning

VS Code kör MCP-servrar från arbetsytans rot. Platshållaren <relative-path-to-project-file> ska peka på .NET-projektfilen. Till exempel skulle värdet för den här SampleMcpServer-appen vara SampleMcpServer.csproj.
Spara filen.

Testa MCP-servern

MCP-servermallen innehåller ett verktyg som heter get_random_number du kan använda för testning och som utgångspunkt för utveckling.

Öppna GitHub Copilot-chatten i Visual Studio och växla till agentläge .
Välj ikonen Välj verktyg för att kontrollera att MyMCPServer är tillgänglig med exempelverktyget i listan.
Ange en uppmaning om att köra verktyget get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot begär behörighet att köra verktyget get_random_number för din fråga. Välj Fortsätt eller använd pilen för att välja ett mer specifikt beteende:
- Den aktuella sessionen kör alltid åtgärden i den aktuella GitHub Copilot-agentlägessessionen.
- Den aktuella lösningen kör alltid kommandot för den aktuella VS-lösningen.
- Tillåt alltid att åtgärden alltid körs för alla GitHub Copilot-agentlägessessioner.
Kontrollera att servern svarar med ett slumptal:
```
Your random number is 42.
```

MCP-servermallen innehåller ett verktyg som heter get_random_number du kan använda för testning och som utgångspunkt för utveckling.

Öppna GitHub Copilot-chatten i VS Code och växla till agentläge .
Välj ikonen Välj verktyg för att kontrollera att MyMCPServer är tillgänglig med exempelverktyget i listan.
Ange en uppmaning om att köra verktyget get_random_number :
```
Give me a random number between 1 and 100.
```
GitHub Copilot begär behörighet att köra verktyget get_random_number för din fråga. Välj Fortsätt eller använd pilen för att välja ett mer specifikt beteende:
- Den aktuella sessionen kör alltid åtgärden i den aktuella GitHub Copilot-agentlägessessionen.
- Den aktuella arbetsytan kör alltid kommandot för den aktuella VS Code-arbetsytan.
- Tillåt alltid att åtgärden alltid körs för alla GitHub Copilot-agentlägessessioner.
Kontrollera att servern svarar med ett slumptal:
```
Your random number is 42.
```

Lägga till indata och konfigurationsalternativ

I det här exemplet förbättrar du MCP-servern så att den använder ett konfigurationsvärde som anges i en miljövariabel. Det kan vara konfiguration som krävs för att mcp-servern ska fungera, till exempel en API-nyckel, en slutpunkt att ansluta till eller en lokal katalogsökväg.

Lägg till en annan verktygsmetod efter GetRandomNumber -metoden i Tools/RandomNumberTools.cs. Uppdatera verktygskoden så att den använder en miljövariabel.

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

.vscode/mcp.json Uppdatera för att ange WEATHER_CHOICES miljövariabeln för testning.

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

Prova en annan fråga med Copilot i VS Code, till exempel:
```
What is the weather in Redmond, Washington?
```
VS Code bör returnera en slumpmässig väderbeskrivning.

Uppdatera .mcp/server.json för att deklarera din miljövariabel indata. Filschemat server.json definieras av MCP Registry-projektet och används av NuGet.org för att generera VS Code MCP-konfiguration.

Använd egenskapen environmentVariables för att deklarera miljövariabler som används av din app som ska anges av klienten med hjälp av MCP-servern (till exempel VS Code).
Använd egenskapen packageArguments för att definiera CLI-argument som skickas till din app. Fler exempel finns i MCP Registry-projektet.

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

Den enda information som används av NuGet.org i server.json är det första packages matrisobjektet med värdet registryType som matchar nuget. De andra toppnivåegenskaperna, förutom packages-egenskapen, är för närvarande oanvända och är avsedda för det kommande centrala MCP-registret. Du kan lämna platshållarvärdena tills MCP-registret är aktivt och redo att acceptera MCP-serverinlägg.

Du kan testa MCP-servern igen innan du går vidare.

Packa och publicera till NuGet

Packa projektet:
```
dotnet pack -c Release
```
Det här kommandot genererar ett verktygspaket och flera plattformsspecifika paket baserat på <RuntimeIdentifiers> listan i SampleMcpServer.csproj.
Publicera paketen till NuGet:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://api.nuget.org/v3/index.json
```
Se till att publicera alla .nupkg filer för att säkerställa att alla plattformar som stöds kan köra MCP-servern.

Om du vill testa publiceringsflödet innan du publicerar till NuGet.org kan du registrera ett konto i NuGet Gallery-integreringsmiljön: https://int.nugettest.org. Kommandot push skulle ändras till:
```
dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://apiint.nugettest.org/v3/index.json
```

Mer information finns i Publicera ett paket.

Identifiera MCP-servrar på NuGet.org

Sök efter MCP-serverpaketet på NuGet.org (eller int.nugettest.org om du publicerade till integrationsmiljön) och välj det i listan.
Visa paketinformationen och kopiera JSON från fliken "MCP Server".

mcp.json I filen i .vscode mappen lägger du till den kopierade JSON som ser ut så här:

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

Om du har publicerat i NuGet Gallery-integreringsmiljön måste du lägga "--add-source", "https://apiint.nugettest.org/v3/index.json" till i slutet av matrisen "args" .

Spara filen.
I GitHub Copilot väljer du ikonen Välj verktyg för att kontrollera att SampleMcpServer är tillgänglig med de verktyg som visas.
Ange en uppmaning om att köra det nya get_city_weather verktyget:
```
What is the weather in Redmond?
```
Om du har lagt till indata till MCP-servern (till exempel WEATHER_CHOICES) uppmanas du att ange värden.
Kontrollera att servern svarar med slumpmässigt väder:
```
The weather in Redmond is balmy.
```

Vanliga problem

Kommandot "dnx" som behövdes för att köra SampleMcpServer hittades inte

Om VS Code visar det här felet när du startar MCP-servern måste du installera en kompatibel version av .NET SDK.

En skärmbild som visar det saknade dnx-kommandot i VS Code.

Kommandot dnx levereras som en del av .NET SDK, från och med version 10. Installera .NET 10 SDK för att lösa problemet.

GitHub Copilot använder inte verktyget (ett svar tillhandahålls utan att du anropar verktyget)

Generellt sett informeras en AI-agent som GitHub Copilot om att den har vissa verktyg som är tillgängliga av klientprogrammet, till exempel VS Code. Vissa verktyg, till exempel exempel slumpmässigt nummerverktyg, kanske inte utnyttjas av AI-agenten eftersom det har liknande funktioner inbyggda.

Om verktyget inte används kontrollerar du följande:

Kontrollera att verktyget visas i listan över verktyg som VS Code har aktiverat. Se skärmbilden i Testa MCP-servern för att se hur du kontrollerar detta.
Referera uttryckligen till namnet på verktyget i din fråga. I VS Code kan du referera till verktyget med namn. Till exempel Using #get_random_weather, what is the weather in Redmond?.
Kontrollera att MCP-servern kan starta. Du kan kontrollera detta genom att klicka på knappen "Start" som visas ovanför MCP-serverkonfigurationen i VS Code-användar- eller arbetsyteinställningarna.

En skärmbild som visar en MCP-server i VS Code-konfigurationen som har startats.

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-01-22