Inteligência Artificial

Model Context Protocol: Dando Superpoderes aos Agentes de IA

Entenda o que é MCP e como esse protocolo permite agentes de IA a realizar tarefas que exigem comunicação com aplicações diversas.

Evandro Gayer Gomes
Evandro Gayer Gomes
Imagem de capa com texto "Model Context Protocol".

Introdução

Nos últimos anos, sistemas baseados em agentes de inteligência artificial evoluíram de simples assistentes conversacionais para plataformas capazes de executar fluxos de trabalho complexos e interagir com múltiplos sistemas corporativos.

Com o surgimento do conceito de Agentic AI, ou inteligência artificial orientada a agentes, sistemas de inteligência artificial ganharam capacidade de raciocinar e executar tarefas complexas, não se limitando apenas a responder perguntas.

Para realizar essas tarefas, agentes podem interagir com diversas ferramentas externas, como:

  • Contas de email, para sumarizar o conteúdo de emails, categorizá-los e responder de forma automática;
  • Navegadores, para realizar buscas na internet e interagir com sistemas diversos;
  • Ferramentas de escritório, para edição de planilhas, apresentações, documentos de texto, imagens, vídeos, entre outras;
  • APIs corporativas, para realizar integrações entre sistemas diversos.

Essa crescente capacidade cria alguns desafios: como fornecer acesso seguro, padronizado e flexível a diferentes tipos de ferramentas, independentemente da linguagem de programação, infraestrutura ou protocolo original?

Foi nesse contexto que surgiu o Model Context Protocol (MCP), um padrão aberto que define como agentes e modelos de linguagem podem se conectar a servidores que disponibilizam ferramentas, recursos e dados, permitindo uma integração uniforme e escalável.

O que é o protocolo MCP?

O MCP é um protocolo que padroniza a comunicação entre um cliente, geralmente um agente ou host LLM, e um servidor que disponibiliza funcionalidades na forma de ferramentas (tools), recursos (resources) e prompts pré-definidos.

Esse protocolo, criado inicialmente pela Anthropic para uso com o Claude, tem recebido diversas atualizações e está sendo adotado em larga escala para integrar aplicações diversas com agentes de inteligência artificial.

Com ele, um agente não precisa conhecer previamente a API ou a implementação de uma funcionalidade. Basta conectar-se ao servidor MCP e descobrir quais operações estão disponíveis.

A arquitetura foi projetada para ser extensível e independente do transporte, suportando desde conexões locais via stdio (standard input e standard output) até comunicações remotas via HTTP, que é basicamente o protocolo usado quando você acessa uma página da web para carregar informações, como aqui no LinkedIn.

Arquitetura do protocolo

O MCP adota o modelo cliente-servidor, com papéis claros:

  • Cliente MCP (host): geralmente um LLM ou ambiente que consome as ferramentas expostas, como, por exemplo, um modelo como o GPT-5 da OpenAI ou o Gemini, da Google.
  • Servidor MCP: provê um conjunto de funcionalidades na forma de ferramentas (tools), que podem ser listadas e invocadas dinamicamente pelos modelos de LLM.

A arquitetura se divide em duas camadas principais:

  1. Camada de dados (Data Layer): define as operações de alto nível usando JSON-RPC 2.0, como tools/list, tools/call, resources/list, entre outras.
  2. Camada de transporte (Transport Layer): define como os dados trafegam. Suporta protocolos como stdio, para conexões locais entre um agente e ferramentas que interagem com o sistema, e streamable HTTP, para permitir acesso a ferramentas hospedadas em servidores remotos. Esse costuma ser o método mais comum quando precisamos disponibilizar acesso a uma API, por exemplo.

Grandes empresas têm disponibilizado servidores MCP para interagir com suas plataformas. Você pode encontrar uma lista de servidores MCP disponíveis para uso neste link.

Diferenças entre MCP e protocolos como REST

O ponto central da diferença entre o MCP e APIs tradicionais está no papel do agente.

Enquanto REST exige que o cliente humano ou desenvolvedor saiba qual endpoint chamar e quais parâmetros passar, no MCP o agente de inteligência artificial descobre as ferramentas disponíveis e decide, com base no contexto da conversa e dos prompts, qual ferramenta usar e quais parâmetros enviar.

No caso do MCP, a descoberta de ferramentas para consumo é feita em tempo de execução, e a integração acontece por meio da definição de funções e retornos estruturados nas respostas geradas por LLMs.

As conexões entre o agente e as ferramentas podem ser feitas via stdio, no caso de ferramentas que rodam no mesmo computador que o agente, ou via HTTP, por meio de endpoints pré-definidos que servem para listar as ferramentas e realizar as chamadas corretamente conforme o contexto passado pelo agente.

Segurança aplicada a ferramentas MCP

O protocolo foi atualizado recentemente e especifica um fluxo de autorização baseado em OAuth 2.1 para transportes HTTP, garantindo que clientes MCP só acessem servidores protegidos após autenticação e autorização adequadas.

Ele suporta descoberta automática de servidores de autorização, registro dinâmico de clientes, uso do parâmetro resource para vincular tokens ao servidor correto e validação rigorosa do público-alvo do token (audience binding).

Para conexões locais via stdio, as credenciais podem ser obtidas do ambiente, evitando a sobrecarga de autenticação remota.

Quando desenvolvemos soluções que utilizam MCP para interação com ferramentas, temos mais alguns pontos relacionados à segurança para considerar:

  • Um agente pode ter acesso a quais ferramentas, e com quais níveis de permissão?
  • Devo permitir acesso total a uma determinada solução e deixar que o agente execute as ferramentas sem controle, ou é necessário incluir uma validação manual no processo, com human-in-the-loop?
  • Como eu garanto que uma chamada a ferramenta não vai causar inconsistência em uma base de dados em caso de falhas ou dados incorretos?

Para os pontos citados acima, empresas têm aplicado diferentes estratégias, como desenvolvimento de aplicações que seguem fluxos estruturados ou técnicas de engenharia de prompt para obtenção de resultados mais precisos.

Exemplo prático: criando uma ferramenta MCP em C#

Para demonstrar como criar um servidor MCP e expor ferramentas para uso, criei um servidor de exemplo que expõe duas ferramentas: uma para criar contatos e outra para listá-los.

O código-fonte completo pode ser encontrado neste repositório:

https://github.com/evgomes/mcp-dotnet-manage-contacts

Para fins didáticos, não utilizei base de dados nem lógica complexa para as ferramentas.

Estrutura do projeto

O projeto utiliza os pacotes NuGet ModelContextProtocol e ModelContextProtocol.AspNetCore, ambos na versão 0.3.0-preview.3 no momento de escrita deste artigo. Estes são os pacotes oficiais do SDK em C#.

O projeto está estruturado da seguinte forma:

ManageContacts.McpServer/
├─ Tools/
│  └─ ContactTools.cs            # Ferramentas MCP
├─ Properties/
│  └─ launchSettings.json        # Perfil para execução em dev
├─ appsettings.json
├─ ManageContacts.McpServer.csproj
└─ Program.cs                    # Host ASP.NET Core + MCP HTTP (/mcp)

Program.cs

Nessa classe, temos a configuração principal para habilitar os serviços MCP utilizando o transporte via HTTP. Aqui também registramos as ferramentas e mapeamos as rotas do servidor MCP nas rotas iniciadas com /mcp.

// Configura os serviços do servidor MCP.
var builder = WebApplication.CreateBuilder(args);

// Adiciona o servidor MCP, habilita transporte HTTP e registra tools via reflexão.
builder
    .Services
    .AddMcpServer()
    .WithHttpTransport()
    .WithToolsFromAssembly();

var app = builder.Build();

// Mapeia o endpoint "/mcp" para atender chamadas MCP.
app.MapMcp("/mcp");

app.Run();

Tools/ContactTools.cs

Aqui temos a implementação das ferramentas. Note a utilização do atributo McpServerToolType, que define que a classe em questão representa uma coleção de ferramentas, e do atributo McpServerTool, que mapeia um método como ferramenta.

Os atributos Description são utilizados pelos modelos de LLM para descrever as entradas e saídas das ferramentas, melhorando a precisão no uso delas quando chamadas pelos agentes.

using ModelContextProtocol.Server;
using System.ComponentModel;

namespace ManageContacts.McpServer.Tools;

[McpServerToolType]
public class ContactTools
{
    private static readonly List<Contact> _contacts = new();

    public record Contact(string FullName, string Email);

    [McpServerTool(Name = "create-contact"),
     Description("Cria um novo contato com nome completo e e-mail, armazenado em memória.")]
    public Contact CreateContact
    (
        [Description("Nome completo do contato.")] string fullName,
        [Description("Endereço de e-mail do contato.")] string email
    )
    {
        // Adiciona o contato à lista em memória.
        var contact = new Contact(fullName, email);
        _contacts.Add(contact);
        return contact;
    }

    [McpServerTool(Name = "list-contacts"),
     Description("Lista contatos armazenados em memória. Opcionalmente filtra por nome ou e-mail.")]
    public IEnumerable<Contact> ListContacts
    (
        [Description("Filtro opcional (case-insensitive) que busca em nome e e-mail.")] string? searchTerm = null
    )
    {
        // Retorna todos os contatos ou aplica filtro por substring.
        var queryable = _contacts.AsQueryable();

        if (!string.IsNullOrWhiteSpace(searchTerm))
        {
            queryable = queryable.Where(x =>
                x.FullName.Contains(searchTerm, StringComparison.OrdinalIgnoreCase) ||
                x.Email.Contains(searchTerm, StringComparison.OrdinalIgnoreCase));
        }

        return queryable.ToList();
    }
}

Podemos executar o projeto utilizando o seguinte comando:

dotnet run --project ManageContacts.McpServer

Execute o comando acima na pasta do projeto. Certifique-se de instalar o SDK do .NET 9 para funcionar corretamente.

Com o projeto em execução, podemos testá-lo utilizando o Claude Desktop. Faça a instalação da ferramenta em https://claude.ai/download e, na pasta onde estão os arquivos de configuração, edite o arquivo claude_desktop_config.json com as seguintes informações:

{
  "mcpServers": {
    "manage-contacts": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:5096/mcp"
      ]
    }
  }
}

Essa configuração mapeia o servidor MCP em execução local para uso por parte do Claude. Será preciso reiniciar a aplicação para que as ferramentas sejam exibidas.

Exemplo de inclusão de contato usando o Claude.
Exemplo de inclusão de contato usando o Claude.
Utilizando a ferramenta de listagem de contatos.
Utilizando a ferramenta de listagem de contatos.

Conclusão

O MCP está criando um novo paradigma para a integração entre agentes de IA e sistemas corporativos. Sua capacidade de descoberta dinâmica, segurança embutida e suporte a múltiplos transportes torna a adoção viável para empresas de todos os portes.

Ao expor ferramentas internas como servidores MCP, organizações podem criar agentes capazes de automatizar tarefas de ponta a ponta, integrar informações dispersas e interagir com sistemas legados sem esforço manual.

Essa padronização não apenas acelera a inovação, mas também abre novas possibilidades para criar fluxos de trabalho inteligentes que transformam dados em ação.

Leia Mais

Link copiado