Uncategorized

Explorando o MCP Client para desenvolvedores .NET/C#

09/06/2025 Por Ramon Durães

A era da inteligência artificial criou novas oportunidades para o desenvolvimento de aplicações integradas a serviços de IA (OpenAI, Azure OpenAI, Google, Anthropic, Meta AI, Amazon Bedrock, Mistral AI, Ollama). Os desenvolvedores têm um papel fundamental na criação de integrações, seja para expor funcionalidades ou consumir recursos disponibilizados.

O Model Context Protocol (MCP) tornou-se um padrão para expor e consumir funcionalidades em provedores de LLM — conectando-se a recursos de inteligência artificial generativa (GenAI), agentes de IA e outras ferramentas. Com ele, você pode compartilhar tools via protocolo MCP, criando tanto servidores quanto clientes .NET que se comunicam entre si, ampliando a integração das suas aplicações .NET ao ecossistema de IA.

No primeiro artigo Explorando MCP Server para .NET Developers, apresentamos a construção das ferramentas (‘tools’) no MCP Server usando .NET/C# e o pacote NuGet Model Context Protocol. Agora, mostraremos como consumir um servidor MCP, de forma semelhante ao que já estamos acostumados com APIs tradicionais.

Configuração do ambiente

Introdução ao MCP Client

Eu acompanho o .NET desde o seu lançamento e estou muito empolgado em compartilhar este novo momento, apresentando o suporte ao desenvolvimento de aplicações clientes que se conectam a qualquer servidor compatível com o protocolo MCP ampliando as possibilidades de interação com as tecnologias do ecossistema de inteligência artificial.

Ao longo da minha trajetória como especialista em desenvolvimento de software, palestrante e consultor em projetos de software, acompanhei vários ciclos de evolução tecnológica. Este momento atual, que engloba LLMs modernos, RAG, MCP e A2A, expandinho as oportunidades para construirmos aplicações transformadoras para empresas e usuários aplicando a tecnologia inteligência artificial no dia a dia.

O MCP Client atua como uma ponte entre aplicações .NET e servidores MCP, permitindo invocar ferramentas remotas da mesma forma que chamamos uma API. Após receber a resposta, é possível incorporar o resultado ao fluxo do seu negócio e acionar decisões inteligentes por meio de um LLM ou agente de IA.

Ao longo deste artigo, focaremos nos fundamentos do MCP Client na perspectiva do desenvolvedor .NET/C#. Em projetos de produção, você poderá aplicar as mesmas boas práticas de desenvolvimento, arquitetura, segurança e logging que já utiliza hoje; no entanto, neste artigo nosso objetivo é demonstrar o acesso ao MCP Server.

Protocolo de comunicação

A comunicação com o MCP Server segue o padrão JSON-RPC 2.0 para integração cliente-servidor e pode ser realizada via Stdio, SSE ou HTTP Streaming conforme definições na implementação.

Stdio (Standard Input/Output): o cliente “executa” o servidor em um cenário local, por exemplo, com um editor ou agente de IA rodando na sua máquina.

var transportOptions = new StdioClientTransport(
    new StdioClientTransportOptions
    {
        Name = "MCP Stdio Client",
        Command = "dotnet",
        Arguments = new[]
        {
            "run",
            "--project",
            @"..\AppMcpServer"
        }
    }
);


HTTP Streaming: usando Server-Sent Events (SSE) ou Streamable HTTP para respostas em streaming via HTTP, seja com o servidor MCP rodando local ou remotamente.

var transportOptions = new SseClientTransport(
    new SseClientTransportOptions
    {
        Name = "MCP HTTP Client",
        Endpoint = new Uri("http://localhost:5000/mcp")
    }
);

Listagem de ferramentas disponíveis

O protocolo MCP permite interagir com o MCP Server e listar tools, prompts e resources, possibilitando que LLMs descubram automaticamente os serviços expostos.

  • Tools: endpoints das ferramentas, similar a API expostas.
  • Prompts: modelos com instruções de texto.
  • Resources: arquivos ou dados auxiliares (esquemas, templates etc.).

A seguir, veremos como listar as tools disponíveis, com detalhes como nome, descrição e JSON Schema, que fornecem as instruções para que um LLM, Agente de inteligência artificial interaja automaticamente com o MCP Server.

// Cria o cliente MCP com o transporte especificado
var mcpClient = await McpClientFactory.CreateAsync(transportOptions);
// Recupera a lista de tools disponíveis
var availableTools = await mcpClient.ListToolsAsync();

// Exibe as tools disponíveis
Console.WriteLine("Ferramentas disponíveis:");
foreach (var tool in availableTools)
{
    Console.WriteLine($"Nome: {tool.Name}");
    Console.WriteLine($"Descrição: {tool.Description}");
    Console.WriteLine($"Schema: {tool.JsonSchema}");
    Console.WriteLine(new string('-', 30));
}

Exemplo de saída com a documentação fornecida pelo MCP Server:

Ferramentas disponíveis:
Nome: say
Descrição: Retorna uma saudação para o nome informado.
Schema: {"title":"say","description":"Retorna uma saudação para o nome informado.","type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
------------------------------
Nome: Add
Descrição: Soma dois inteiros e retorna o resultado. Exemplo: 5 + 2 = 7
Schema: {"title":"Add","description":"Soma dois inteiros e retorna o resultado.","type":"object","properties":{"a":{"type":"integer"},"b":{"type":"integer"}},"required":["a","b"]}
------------------------------
Nome: Divide
Descrição: Divide dois inteiros e retorna o resultado como decimal. Exemplo: 10 / 4 = 2.5
Schema: {"title":"Divide","description":"Divide dois inteiros e retorna o resultado como decimal.","type":"object","properties":{"a":{"type":"integer"},"b":{"type":"integer"}},"required":["a","b"]}
------------------------------
Nome: Subtract
Descrição: Subtrai o segundo inteiro do primeiro e retorna o resultado. Exemplo: 9 - 3 = 6
Schema: {"title":"Subtract","description":"Subtrai o segundo inteiro do primeiro e retorna o resultado.","type":"object","properties":{"a":{"type":"integer"},"b":{"type":"integer"}},"required":["a","b"]}
------------------------------
Nome: Multiply
Descrição: Multiplica dois inteiros e retorna o resultado. Exemplo: 3 * 4 = 12
Schema: {"title":"Multiply","description":"Multiplica dois inteiros e retorna o resultado.","type":"object","properties":{"a":{"type":"integer"},"b":{"type":"integer"}},"required":["a","b"]}

Executando ferramentas

Se você já conhece as tools disponíveis, pode chamá-las diretamente, passando os parâmetros necessários sem a necessidade da listagem anterior.

// Encontra a tool "say"
var sayTool = availableTools
    .FirstOrDefault(t => string.Equals(t.Name, "say", StringComparison.OrdinalIgnoreCase)) ??
    throw new InvalidOperationException("A tool 'say' não está disponível.");

// Prepara os parâmetros para a tool "say"
var parameters = new Dictionary<string, object?> { { "name", "ramon" } };

// Chama a tool "say" com os parâmetros
var response = await mcpClient.CallToolAsync(sayTool.Name, parameters);

O método CallToolAsync é o recurso principal no MCP Client para executar ferramentas MCP externamente. Ele recebe o nome do método e os parâmetros necessários, retornando o resultado no formato especificado.

Criando o projeto MCP Client com a comunicação HTTP

  1. Crie um projeto e entre na pasta:dotnet new console -o AppMcpClient
  2. Adicione o pacote NuGet ModelContextProtocoldotnet add package ModelContextProtocol --prerelease

Implementação do MCP Client

Abra o projeto no Visual Studio Code e substitua o conteúdo de Program.cs pelo código abaixo. Após adicionar efetue um build do projeto para validar o novo código.

using ModelContextProtocol.Client;

Console.WriteLine("Inicializando MCP Client...");

var transportOptions = new SseClientTransport(new SseClientTransportOptions
{
    Name = "MCP Client",
    Endpoint = new Uri("http://localhost:5000/mcp")
});

// Cria o cliente MCP e lista as tools
var mcpClient = await McpClientFactory.CreateAsync(transportOptions);
var availableTools = await mcpClient.ListToolsAsync();

// Exibe as tools disponíveis
Console.WriteLine("Ferramentas disponíveis:");
foreach (var tool in availableTools)
{
    Console.WriteLine($"Nome: {tool.Name}");
    Console.WriteLine($"Descrição: {tool.Description}");
    Console.WriteLine($"Schema: {tool.JsonSchema}");
    Console.WriteLine(new string('-', 30));
}

// Chama a tool "say"
var sayTool = availableTools.First(t => t.Name.Equals("say", StringComparison.OrdinalIgnoreCase));
var parameters = new Dictionary<string, object?> { { "name", "ramon" } };
var response = await mcpClient.CallToolAsync(sayTool.Name, parameters);

// Processa a resposta
var result = response.Content?.FirstOrDefault()?.Text ?? "Sem retorno";
Console.WriteLine($"Resposta da ferramenta: {result}");

Executando o MCP Client HTTP

Agora chegou o momento de executar o MCP Server e o MCP Client para testar a implementação do novo cliente MCP. Neste exemplo, conforme o código anterior, acionaremos a ferramenta say com o parâmetro "ramon".

  1. Clone o repositório mcp-first-server.
  2. Em uma aba do terminal entre na pasta e execute o projeto AppMcpServer para habilitar o MCP Server em http://localhost:5000/mcp.
  3. Em outra aba do terminal entre na pasta e execute o projeto AppMcpClient para se conectar ao servidor MCP.

Ao final o clinte MCP deverá executar a ferramenta remota e exibir o log com o retorno.

Resposta da ferramenta: Hello, ramon!

Criando o projeto MCP Client com a comunicação Stdio

A mesma implementação anterior pode ser adaptada para usar o protocolo Stdio, fazendo com que o cliente execute o servidor em background.

  1. Crie um projeto e entre na pasta:dotnet new console -o AppMcpClientStdio
  2. Adicione o pacote NuGet ModelContextProtocoldotnet add package ModelContextProtocol --prerelease

Copie o exemplo de Program.cs do projeto anterior para o AppMcpClientStdio e ajuste apenas o transportOptions no novo projeto . A única diferença é o path relativo para o servidor MCP:

/AppMcpServer
/AppMcpClientStdio   ← sua pasta aqui

Exemplo do transportOptions para Stdio.

var transportOptions = new StdioClientTransport(new StdioClientTransportOptions
{
    Name = "MCP Stdio Client",
    Command = "dotnet",
    Arguments = new[] { "run", "--project", @"..\AppMcpServer" }
});

Executando o MCP Client Stdio

O procedimeneto para executar o projeto Stdio é muito simpleste. Antes de avançar, certifique de fechar qualquer projeto aberto no exemplo anterior esteja finalizado.

No terminal entre na pasta AppMcpClientStdio e execute dotnet run o projeto, ele iniciará internamente o servidor AppMcpServer via Stdio e consumirá a ferramenta automaticamente obtendo o mesmo resultado do teste realizado com o HTTP.

Considerações finais

O MCP Client democratiza o consumo de funcionalidades de IA em aplicações .NET, simplificando a descoberta e invocação de métodos remotamente, com segurança e padronização. Durante minhas consultorias e palestras, destaco sempre essa nova oportunidade de integrar inteligência artificial com .NET em poucos passos. Hoje, qualquer desenvolvedor .NET pode explorar recursos de IA em LLM, RAG, agentes de IA, garantindo que fluxos orquestrados por LLMs aconteçam de forma automatizada e robusta.

A sua contribuição é valiosa

Este artigo é fruto de longas horas de pesquisa, desenvolvimento, validação de contexto e elaboração minuciosa. Se fez sentido para você, deixe seu comentário e compartilhe com a sua rede além de sugerir novos temas.

Precisa de ajuda especializada em estratégia de software para apoiar a modernização do seu software e projetos de arquitetura de IA, microsserviços, cloud, RAG? Entre em contato.

Até a próxima !!!

Ramon Durães

TagsAI C# dotnet genai IA inteligência artificial LLM MCP MCP Client MCP Server RAG Visual STudio