Compartilhar via

Criar um servidor MCP mínimo usando C# e publicar no NuGet

Neste início rápido, você criará um servidor mínimo do Modelo de Protocolo de Contexto (MCP) usando o SDK do C# para MCP, conecte-se a ele usando o GitHub Copilot e publique-o no NuGet. Os servidores MCP são serviços que expõem recursos aos clientes por meio do PROTOCOLO MCP (Model Context Protocol).

Observação

O Microsoft.McpServer.ProjectTemplates pacote de modelo está atualmente em versão prévia.

Pré-requisitos

Criar o projeto

  1. Em uma janela de terminal, instale o modelo do SERVIDOR MCP:

    dotnet new install Microsoft.McpServer.ProjectTemplates

    Observação

    O SDK do .NET 10.0 (versão prévia 6 ou posterior) é necessário para instalar Microsoft.McpServer.ProjectTemplates.

  2. Crie um novo aplicativo de servidor MCP com o dotnet new mcpserver comando:

    dotnet new mcpserver -n SampleMcpServer

    Por padrão, esse comando cria um pacote de ferramentas autossuficiente direcionado a todas as plataformas mais comuns nas quais o .NET tem suporte. Para ver mais opções, use dotnet new mcpserver --help.

  3. Navegue até o SampleMcpServer diretório:

    cd SampleMcpServer

  4. Compile o projeto:

    dotnet build

  5. Atualize o arquivo <PackageId> no .csproj para ser exclusivo no NuGet.org, por exemplo <NuGet.org username>.SampleMcpServer.

Configurar o servidor MCP no Visual Studio Code

Configure o GitHub Copilot para Visual Studio Code para usar o servidor MCP personalizado:

  1. Caso ainda não tenha feito isso, abra a pasta do projeto no Visual Studio Code.

  2. Crie uma .vscode pasta na raiz do projeto.

  3. Adicione um mcp.json arquivo na .vscode pasta com o seguinte conteúdo:

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

    Observação

    O VS Code executa servidores MCP da pasta raiz do workspace. O <relative-path-to-project-file> espaço reservado deve indicar o arquivo de projeto do .NET. Por exemplo, o valor deste aplicativo SampleMcpServer seria SampleMcpServer.csproj.

  4. Salve o arquivo.

Testar o servidor MCP

O modelo de servidor MCP inclui uma ferramenta chamada get_random_number você pode usar para teste e como ponto de partida para desenvolvimento.

  1. Abra o GitHub Copilot no Visual Studio Code e alterne para o modo de agente.

  2. Selecione o ícone Selecionar ferramentas para verificar se o SampleMcpServer está disponível com a ferramenta de exemplo listada.

    Uma captura de tela mostrando as ferramentas MCP disponíveis.

  3. Insira um prompt para executar a ferramenta get_random_number :

    Give me a random number between 1 and 100.

  4. O GitHub Copilot solicita permissão para executar a ferramenta get_random_number para seu prompt. Selecione Continuar ou use a seta para selecionar um comportamento mais específico:

    • A sessão atual sempre executa a operação na sessão atual do GitHub Copilot Agent Mode.
    • O workspace atual sempre executa o comando correspondente ao workspace do Visual Studio Code em uso no momento.
    • Sempre permitir define a operação para ser sempre executada em qualquer sessão do Modo Agente do GitHub Copilot ou em qualquer workspace do Visual Studio Code.

  5. Verifique se o servidor responde com um número aleatório:

    Your random number is 42.

Adicionar entradas e opções de configuração

Neste exemplo, você aprimora o servidor MCP para usar um conjunto de valores de configuração em uma variável de ambiente. Isso pode ser uma configuração necessária para o funcionamento do servidor MCP, como uma chave de API, um ponto de extremidade para se conectar ou um caminho de diretório local.

  1. Adicione outro método de ferramenta após o método GetRandomNumber em Tools/RandomNumberTools.cs. Atualize o código da ferramenta para usar uma variável de 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]}.";
}

  2. Atualize o .vscode/mcp.json para definir a variável de ambiente WEATHER_CHOICES para teste.

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

  3. Experimente outro prompt com Copilot no VS Code, como:

    What is the weather in Redmond, Washington?

    O VS Code deve retornar uma descrição do tempo aleatória.

  4. Atualize o .mcp/server.json para declarar a variável de ambiente. O server.json esquema de arquivo é definido pelo projeto do Registro MCP e é usado por NuGet.org para gerar a configuração do VS Code MCP.

    • Use a environmentVariables propriedade para declarar variáveis de ambiente usadas pelo aplicativo que serão definidas pelo cliente usando o servidor MCP (por exemplo, VS Code).

    • Use a packageArguments propriedade para definir argumentos da CLI que serão passados para seu aplicativo. Para obter mais exemplos, consulte o projeto do 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"
  }
}

    As únicas informações usadas por NuGet.org no server.json são o primeiro item da matriz packages cujo registryType valor corresponde ao nuget. As outras propriedades de nível superior, além da propriedade packages, não estão sendo utilizadas no momento e destinam-se ao próximo registro central do MCP. Você pode deixar os valores de espaço reservado até que o Registro MCP esteja pronto e ativo para aceitar entradas de servidor MCP.

Você pode testar o servidor MCP novamente antes de avançar.

Empacotar e publicar no NuGet

  1. Empacote o projeto:

    dotnet pack -c Release

    Esse comando produz um pacote de ferramentas e vários pacotes específicos da plataforma com base na <RuntimeIdentifiers> lista em SampleMcpServer.csproj.

  2. Publique os pacotes no NuGet:

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

    Publique todos os .nupkg arquivos para garantir que todas as plataformas compatíveis possam executar o servidor MCP.

    Se você quiser testar o fluxo de publicação antes de publicar no NuGet.org, poderá registrar uma conta no ambiente de integração da Galeria do NuGet: https://int.nugettest.org. O push comando seria modificado para:

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

Para obter mais informações, consulte Publicar um pacote.

Descobrir servidores MCP no NuGet.org

  1. Pesquise seu pacote de servidor MCP no NuGet.org (ou int.nugettest.org se você publicou no ambiente de integração) e selecione-o na lista.

    Uma captura de tela mostrando uma pesquisa por servidores MCP no NuGet.org.

  2. Exiba os detalhes do pacote e copie o JSON da guia "Servidor MCP".

    Uma captura de tela mostrando um servidor MCP específico exibido no NuGet.org.

  3. No arquivo mcp.json na pasta .vscode, adicione o JSON copiado, que tem a seguinte aparência:

    {
  "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 você publicou no ambiente de integração da Galeria do NuGet, precisará adicionar "--add-source", "https://apiint.nugettest.org/v3/index.json" no final da matriz "args".

  4. Salve o arquivo.

  5. No GitHub Copilot, selecione o ícone Selecionar ferramentas para verificar se o SampleMcpServer está disponível com as ferramentas listadas.

  6. Insira um prompt para executar a nova ferramenta get_city_weather:

    What is the weather in Redmond?

  7. Se você adicionou entradas ao servidor MCP (por exemplo, WEATHER_CHOICES), será solicitado que você forneça valores.

  8. Verifique se o servidor responde com o clima aleatório:

    The weather in Redmond is balmy.

Problemas comuns

O comando "dnx" necessário para executar SampleMcpServer não foi encontrado

Se o VS Code mostrar esse erro ao iniciar o servidor MCP, você precisará instalar uma versão compatível do SDK do .NET.

Uma captura de tela mostrando o comando dnx ausente no VS Code.

O dnx comando é enviado como parte do SDK do .NET, começando com a versão 10. Instale o SDK do .NET 10 para resolver esse problema.

O GitHub Copilot não usa sua ferramenta (uma resposta é fornecida sem invocar sua ferramenta)

De modo geral, um agente de IA como o GitHub Copilot é informado de que tem algumas ferramentas disponíveis pelo aplicativo cliente, como o VS Code. Algumas ferramentas, como a ferramenta de número aleatório de exemplo, podem não ser utilizadas pelo agente de IA porque ele tem funcionalidade semelhante integrada.

Se a ferramenta não estiver sendo usada, verifique o seguinte:

  1. Verifique se a ferramenta aparece na lista de ferramentas que o VS Code habilitou. Confira a captura de tela em Testar o servidor MCP para saber como verificar isso.
  2. Referencie explicitamente o nome da ferramenta em seu prompt. No VS Code, você pode referenciar sua ferramenta pelo nome. Por exemplo, Using #get_random_weather, what is the weather in Redmond?.
  3. Verifique se o servidor MCP está habilitado para iniciar. Você pode verificar isso clicando no botão "Iniciar" visível acima da configuração do servidor MCP nas configurações do usuário ou do workspace do VS Code.

Uma captura de tela mostrando um servidor MCP na configuração do VS Code iniciada.

Conteúdo relacionado

  • Last updated on