Partager via

Créer un serveur MCP minimal à l’aide de C# et publier sur NuGet

Dans ce guide de démarrage rapide, vous allez créer un serveur MCP (Model Context Protocol) minimal à l’aide du Kit de développement logiciel (SDK) C# pour MCP, vous y connecter à l’aide de GitHub Copilot et le publier sur NuGet. Les serveurs MCP sont des services qui exposent des fonctionnalités aux clients via le protocole MCP (Model Context Protocol).

Remarque

Le Microsoft.McpServer.ProjectTemplates package de modèle est actuellement en préversion.

Conditions préalables

Créer le projet

  1. Dans une fenêtre de terminal, installez le modèle de serveur MCP :

    dotnet new install Microsoft.McpServer.ProjectTemplates

    Remarque

    Le SDK .NET 10.0 (préversion 6 ou ultérieure) est nécessaire pour installer Microsoft.McpServer.ProjectTemplates.

  2. Créez une application serveur MCP avec la dotnet new mcpserver commande :

    dotnet new mcpserver -n SampleMcpServer

    Par défaut, cette commande crée un package d’outils autonome ciblant toutes les plateformes les plus courantes sur lesquelles .NET est pris en charge. Pour afficher d’autres options, utilisez dotnet new mcpserver --help.

  3. Accédez au SampleMcpServer répertoire :

    cd SampleMcpServer

  4. Construisez le projet :

    dotnet build

  5. Mettez à jour le <PackageId> dans le fichier .csproj pour qu'il soit unique sur NuGet.org, par exemple <NuGet.org username>.SampleMcpServer.

Configurer le serveur MCP dans Visual Studio Code

Configurez GitHub Copilot pour Visual Studio Code pour utiliser votre serveur MCP personnalisé :

  1. Si ce n’est déjà fait, ouvrez votre dossier de projet dans Visual Studio Code.

  2. Créez un .vscode dossier à la racine de votre projet.

  3. Ajoutez un mcp.json fichier dans le .vscode dossier avec le contenu suivant :

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

    Remarque

    VS Code exécute des serveurs MCP à partir de la racine de l’espace de travail. L’espace <relative-path-to-project-file> réservé doit pointer vers votre fichier projet .NET. Par exemple, la valeur de cette application SampleMcpServer serait SampleMcpServer.csproj.

  4. Enregistrez le fichier.

Tester le serveur MCP

Le modèle de serveur MCP inclut un outil appelé get_random_number que vous pouvez utiliser pour les tests et comme point de départ pour le développement.

  1. Ouvrez GitHub Copilot dans Visual Studio Code et basculez en mode agent.

  2. Sélectionnez l’icône Sélectionner des outils pour vérifier que votre SampleMcpServer est disponible avec l’exemple d’outil répertorié.

    Capture d’écran montrant les outils MCP disponibles.

  3. Entrez une invite pour exécuter l’outil get_random_number :

    Give me a random number between 1 and 100.

  4. GitHub Copilot demande la permission d’exécuter l’outil get_random_number pour votre commande. Sélectionnez Continuer ou utiliser la flèche pour sélectionner un comportement plus spécifique :

    • La session active exécute toujours l’opération dans la session en mode Agent Copilot GitHub actuelle.
    • L’espace de travail actuel exécute toujours la commande de l’espace de travail Visual Studio Code actuel.
    • Toujours autoriser configure l'opération pour qu'elle soit toujours exécutée pour toute session en mode Agent Copilot GitHub ou tout espace de travail Visual Studio Code.

  5. Vérifiez que le serveur répond avec un nombre aléatoire :

    Your random number is 42.

Ajouter des entrées et des options de configuration

Dans cet exemple, vous améliorez le serveur MCP pour utiliser un jeu de valeurs de configuration dans une variable d’environnement. Il peut s’agir d’une configuration nécessaire pour le fonctionnement de votre serveur MCP, comme une clé API, un point de terminaison auquel se connecter ou un chemin d’accès au répertoire local.

  1. Ajoutez une autre méthode d’outil après la GetRandomNumber méthode dans Tools/RandomNumberTools.cs. Mettez à jour le code de l’outil pour utiliser une variable d’environnement.

    [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. Mettez à jour la .vscode/mcp.json pour définir la variable d’environnement WEATHER_CHOICES pour le test.

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

  3. Testez une autre commande avec Copilot dans VS Code, tel que :

    What is the weather in Redmond, Washington?

    VS Code doit retourner une description météorologique aléatoire.

  4. Mettez à jour l’élément .mcp/server.json afin de déclarer votre entrée de variable d’environnement. Le server.json schéma de fichier est défini par le projet de Registre MCP et est utilisé par NuGet.org pour générer la configuration VS Code MCP.

    • Utilisez la environmentVariables propriété pour déclarer des variables d’environnement utilisées par votre application qui seront définies par le client à l’aide du serveur MCP (par exemple, VS Code).

    • Utilisez la packageArguments propriété pour définir des arguments CLI qui seront transmis à votre application. Pour plus d’exemples, consultez le projet de Registre 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"
  }
}

    Les seules informations utilisées par NuGet.org dans le server.json est le premier élément de tableau packages avec la valeur registryType correspondant à nuget. Les propriétés de premier niveau, à l'exception de la propriété packages, sont actuellement inutilisées et elles sont prévues pour le futur Registre central MCP. Vous pouvez laisser les valeurs de remplacement jusqu’à ce que le registre MCP soit actif et prêt à accepter les entrées du serveur MCP.

Vous pouvez tester à nouveau votre serveur MCP avant de passer à l’avant.

Emballer et publier sur NuGet

  1. Packez le projet :

    dotnet pack -c Release

    Cette commande produit un package d’outils et plusieurs packages spécifiques à la plateforme en fonction de la <RuntimeIdentifiers> liste dans SampleMcpServer.csproj.

  2. Publiez les packages sur NuGet :

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

    Veillez à publier tous les .nupkg fichiers pour vous assurer que chaque plateforme prise en charge peut exécuter le serveur MCP.

    Si vous souhaitez tester le flux de publication avant de publier sur NuGet.org, vous pouvez inscrire un compte dans l’environnement d’intégration de la galerie NuGet : https://int.nugettest.org. La push commande est modifiée pour :

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

Pour plus d’informations, consultez Publier un package.

Découvrir des serveurs MCP sur NuGet.org

  1. Recherchez votre package de serveur MCP sur NuGet.org (ou int.nugettest.org si vous avez publié dans l’environnement d’intégration) et sélectionnez-le dans la liste.

    Capture d’écran montrant une recherche de serveurs MCP sur NuGet.org.

  2. Affichez les détails du package et copiez le JSON à partir de l’onglet « Serveur MCP ».

    Capture d’écran montrant un serveur MCP spécifique affiché sur NuGet.org.

  3. Dans votre mcp.json fichier dans le .vscode dossier, ajoutez le json copié, qui ressemble à ceci :

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

    Si vous avez publié dans l’environnement d’intégration de la galerie NuGet, vous devez ajouter "--add-source", "https://apiint.nugettest.org/v3/index.json" à la fin du "args" tableau.

  4. Enregistrez le fichier.

  5. Dans GitHub Copilot, sélectionnez l’icône Sélectionner des outils pour vérifier que votre SampleMcpServer est disponible avec les outils répertoriés.

  6. Entrez une invite pour exécuter le nouvel outil get_city_weather :

    What is the weather in Redmond?

  7. Si vous avez ajouté des entrées à votre serveur MCP (par exemple, WEATHER_CHOICES), vous serez invité à fournir des valeurs.

  8. Vérifiez que le serveur répond avec la météo aléatoire :

    The weather in Redmond is balmy.

Problèmes courants

La commande « dnx » nécessaire pour exécuter SampleMcpServer est introuvable

Si VS Code affiche cette erreur lors du démarrage du serveur MCP, vous devez installer une version compatible du Kit de développement logiciel (SDK) .NET.

Capture d’écran montrant la commande dnx manquante dans VS Code.

La dnx commande est fournie dans le cadre du Kit de développement logiciel (SDK) .NET, à compter de la version 10. Installez le Kit de développement logiciel (SDK) .NET 10 pour résoudre ce problème.

GitHub Copilot n’utilise pas votre outil (une réponse est fournie sans appeler votre outil)

En règle générale, un agent IA comme GitHub Copilot est informé qu’il dispose d’outils disponibles par l’application cliente, comme VS Code. Certains outils, tels que l’exemple d’outil de nombre aléatoire, peuvent ne pas être utilisés par l’agent IA, car il dispose de fonctionnalités similaires intégrées.

Si votre outil n’est pas utilisé, vérifiez ce qui suit :

  1. Vérifiez que votre outil apparaît dans la liste des outils activés par VS Code. Consultez la capture d’écran dans Tester le serveur MCP pour savoir comment vérifier cela.
  2. Référencez explicitement le nom de l’outil dans votre invite. Dans VS Code, vous pouvez référencer votre outil par nom. Par exemple : Using #get_random_weather, what is the weather in Redmond?.
  3. Vérifiez que votre serveur MCP est en mesure de démarrer. Vous pouvez le vérifier en cliquant sur le bouton « Démarrer » visible au-dessus de la configuration de votre serveur MCP dans les paramètres utilisateur ou espace de travail VS Code.

Capture d’écran montrant un serveur MCP dans la configuration VS Code démarrée.

Contenu connexe

  • Last updated on