Criar um cliente MCP mínimo usando .NET

2025-05-30

Neste início rápido, você cria um cliente MCP (Model Context Protocol) mínimo usando o SDK C# para MCP. Você também aprenderá como configurar o cliente para se conectar a um servidor MCP, como o criado no início rápido Criar um servidor MCP mínimo .

Pré-requisitos

Observação

O cliente MCP que cria nas próximas seções conecta-se ao servidor MCP de exemplo do quickstart Criar um servidor MCP mínimo. Você também pode usar seu próprio servidor MCP se fornecer sua própria configuração de conexão.

Criar o aplicativo host .NET

Conclua as etapas a seguir para criar um aplicativo de console .NET. O aplicativo atua como um host para um cliente MCP que se conecta a um servidor MCP.

Criar o projeto

Em uma janela de terminal, navegue até o diretório onde você deseja criar seu aplicativo e crie um novo aplicativo de console com o dotnet new comando:
```
dotnet new console -n MCPHostApp
```
Navegue até a pasta do projeto recém-criada:
```
cd MCPHostApp
```

Execute os seguintes comandos para adicionar os pacotes NuGet necessários:

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package ModelContextProtocol --prerelease

Abra a pasta do projeto no editor de sua escolha, como o Visual Studio Code:
```
code .
```

Adicionar o código do aplicativo

Substitua o conteúdo do Program.cs pelo seguinte código:

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.AI;
using ModelContextProtocol.Client;

// Create an IChatClient using Azure OpenAI.
IChatClient client =
    new ChatClientBuilder(
        new AzureOpenAIClient(new Uri("<your-azure-openai-endpoint>"),
        new DefaultAzureCredential())
        .GetChatClient("gpt-4o").AsIChatClient())
    .UseFunctionInvocation()
    .Build();

// Create the MCP client
// Configure it to start and connect to your MCP server.
IMcpClient mcpClient = await McpClientFactory.CreateAsync(
    new StdioClientTransport(new()
    {
        Command = "dotnet run",
        Arguments = ["--project", "<path-to-your-mcp-server-project>"],
        Name = "Minimal MCP Server",
    }));

// List all available tools from the MCP server.
Console.WriteLine("Available tools:");
IList<McpClientTool> tools = await mcpClient.ListToolsAsync();
foreach (McpClientTool tool in tools)
{
    Console.WriteLine($"{tool}");
}
Console.WriteLine();

// Conversational loop that can utilize the tools via prompts.
List<ChatMessage> messages = [];
while (true)
{
    Console.Write("Prompt: ");
    messages.Add(new(ChatRole.User, Console.ReadLine()));

    List<ChatResponseUpdate> updates = [];
    await foreach (ChatResponseUpdate update in client
        .GetStreamingResponseAsync(messages, new() { Tools = [.. tools] }))
    {
        Console.Write(update);
        updates.Add(update);
    }
    Console.WriteLine();

    messages.AddMessages(updates);
}

O código anterior realiza as seguintes tarefas:

Inicializa uma IChatClient abstração usando as Microsoft.Extensions.AI bibliotecas.
Cria um cliente MCP e o configura para se conectar ao seu servidor MCP.
Recupera e exibe uma lista de ferramentas disponíveis do servidor MCP, que é uma função MCP padrão.
Implementa um loop de conversação que processa solicitações do usuário e utiliza as ferramentas para respostas.

Executar e testar o aplicativo

Conclua as seguintes etapas para testar seu aplicativo host .NET:

Em uma janela de terminal aberta para a raiz do seu projeto, execute o seguinte comando para iniciar o aplicativo:
```
dotnet run
```
Quando o aplicativo estiver em execução, insira um prompt para executar a ferramenta ReverseEcho :
```
Reverse the following: "Hello, minimal MCP server!"
```
Verifique se o servidor responde com a mensagem ecoada:
```
!revres PCM laminim ,olleH
```

Introdução ao .NET AI e ao Model Context Protocol

Partilhar via