MCP (Model Context Protocol) é um padrão comum para conectar aplicativos de IA a ferramentas e dados externos. Depois de configurar uma ferramenta como servidor MCP, ela funciona da mesma forma em qualquer aplicativo compatível com MCP. No capítulo anterior, colocamos em funcionamento um agente mínimo que conecta ferramentas a um LLM e executa o próprio ciclo. Neste capítulo, você vai aprender a parar de criar cada ferramenta do zero e a conectá-las de forma padronizada com MCP, além de como projetar as ferramentas que você entrega para que sejam usadas com segurança.
O objetivo: conectar ferramentas com segurança, por meio de um padrão, sem criar cada uma do zero
Por que as conexões com ferramentas são o núcleo dos agentes
Um LLM, por mais capaz que seja, só consegue gerar palavras. Ele não consegue saber o estoque atual nem gravar uma linha em um arquivo sem uma forma de alcançar o mundo externo. Um agente consegue executar o ciclo de "pesquisar, agir e verificar" porque tem ferramentas que lhe permitem agir sobre o mundo externo.
Em outras palavras, o que um agente pode fazer depende de quais ferramentas ele está conectado e de quais permissões tem sobre elas. Dois agentes que rodam sobre o mesmo LLM podem ser muito diferentes: um que só tem uma calculadora e outro conectado a banco de dados, busca, arquivos e uma API interna. Dependendo do objetivo, conectar as ferramentas certas pode ampliar muito mais o trabalho que você pode delegar do que trocar por um modelo mais avançado.
💡 "Bem equipado" vale mais que "inteligente". Mesmo uma pessoa muito capaz não consegue fazer nada com a caixa de ferramentas vazia. Boa parte do tempo no desenvolvimento de agentes vai para o projeto de quais ferramentas entregar e como fazê-lo com segurança. Este capítulo trata exatamente desse núcleo.
Os limites das definições de ferramentas simples
No capítulo anterior, você definiu as ferramentas com as próprias mãos. Escreveu uma função, passou seu nome, seus argumentos e sua descrição ao LLM e, quando uma chamada chegava, executava a função e devolvia o resultado. Esse fluxo está correto e continua sendo a base. Para um processo pequeno usado em um único aplicativo, essa abordagem basta. O problema aparece quando é preciso recriar a mesma ferramenta para cada ferramenta e cada projeto.
Pense em uma "ferramenta de busca em banco de dados". Você escreve a lógica de conexão, monta as consultas, formata os resultados, trata os erros e manipula as credenciais com segurança… Esse conjunto inteiro é implementado de forma independente no seu projeto, na equipe ao lado e em outra linguagem. Desenvolvedores do mundo inteiro recriam várias vezes a mesma ferramenta, e essa é a realidade das definições de ferramentas simples.
Uma ferramenta escrita para um projeto fica presa àquele framework e àquela linguagem, o que dificulta levá-la para outro lugar.
Conectar M tipos de ferramentas a N plataformas de agentes exige, em teoria, N×M trechos de código de conexão.
Sempre que a especificação de um serviço conectado muda, é preciso corrigir, uma a uma, as ferramentas caseiras espalhadas pelo projeto.
Isso lembra bastante a época em que cada periférico precisava do próprio cabo. Impressoras tinham entradas específicas para impressoras, e mouses tinham entradas específicas para mouses; quanto mais dispositivos, mais os tipos de conexão se multiplicavam. Uma "porta comum" reduz de uma vez boa parte dessa complicação. É aí que entra o MCP.
O que é MCP? Um padrão comum para conexões com ferramentas
MCP (Model Context Protocol) é um padrão aberto para conectar a IA a ferramentas e dados externos de forma padronizada. A Anthropic o publicou como código aberto em novembro de 2024, e desde então produtos de outras empresas, como ChatGPT, Cursor, Gemini, Microsoft Copilot e Visual Studio Code, passaram a oferecer suporte. Em dezembro de 2025, ele foi doado à Agentic AI Foundation (AAIF), vinculada à Linux Foundation, de modo que a especificação passou a ser desenvolvida sem pertencer a uma única empresa.
Resumindo a ideia do MCP em uma frase: ele é "USB para conexões de ferramentas de IA". Assim como o USB permitiu que periféricos de qualquer fabricante funcionassem na mesma porta, uma ferramenta compatível com MCP funciona em qualquer aplicativo compatível com MCP, basta conectar. Quando quem cria e quem usa seguem o mesmo acordo, as combinações N×M se reduzem a N+M.
Roda dentro do agente que você cria ou de um aplicativo como o Claude. É o lado que pergunta ao servidor "Quais ferramentas posso usar?" e chama as ferramentas de que precisa.
Publica funções como operações com arquivos, busca em banco de dados e integração com SaaS como "ferramentas". Um único servidor pode oferecer várias ferramentas.
Os dois lados trocam mensagens em uma ordem definida. Primeiro, o cliente recebe do servidor a lista das ferramentas disponíveis, com o nome, a descrição e o formato dos argumentos de cada uma. O LLM analisa essa lista e escolhe a ferramenta adequada, o cliente a chama, e o servidor a executa e devolve o resultado. Na especificação oficial de ferramentas, obter a lista se chama tools/list, e a chamada, tools/call. O essencial do MCP é que esse vaivém funciona sem implementações individuais para cada ferramenta.
Cliente → Servidor: "Diga quais ferramentas estão disponíveis" (tools/list) Servidor → Cliente: "search_docs / read_file / query_db estão disponíveis; estas são as descrições" LLM decide : "Vou chamar query_db com os argumentos {sql:"..."}" Cliente → Servidor: "Execute query_db" (tools/call) Servidor → Cliente: "O resultado são estas linhas de dados"
O conteúdo da lista não é fixo. Pela especificação, o servidor pode restringir as ferramentas devolvidas de acordo com as permissões do usuário, e a lista pode mudar depois. Lembre-se de que "a conexão funcionou" e "as ferramentas necessárias podem ser usadas" são coisas diferentes.
A especificação oficial define dois transportes (formas de comunicação) como padrão. Nos dois, as mensagens trocadas são as mesmas, e a forma como o lado cliente as trata quase não muda.
O cliente inicia o servidor como um processo filho e se comunica por entrada e saída padrão. É adequado para conectar seus próprios arquivos ou um banco de dados de desenvolvimento. As credenciais são passadas pelo ambiente de execução, por exemplo por variáveis de ambiente.
Envia as requisições por HTTP para a URL do servidor. É adequado para integrações com SaaS compartilhadas pela equipe. Quando é necessária autenticação, use a autorização baseada em OAuth definida pela especificação.
📖 Atenção à versão da especificação. As versões da especificação do MCP são identificadas por data e, em outubro de 2026, a versão atual é a 2026-07-28. A partir dessa versão, a versão é informada a cada requisição, o que difere do procedimento das versões anteriores a 2025-11-25, em que cliente e servidor combinavam a versão na conexão por meio de initialize. Não siga procedimentos antigos ao pé da letra. Confira quais versões são suportadas pelo SDK, pelo aplicativo e pelo servidor que você usa. Se quiser ler antes a explicação simples sobre a origem e os termos, o artigo "O que é MCP?" deixa este capítulo mais fácil de acompanhar.
Usando e criando servidores MCP
A melhor parte do MCP é que você pode usar servidores já publicados exatamente como estão. Para ferramentas comuns, o fornecedor do serviço costuma disponibilizar um servidor MCP oficial, que você também pode encontrar no MCP Registry. Conecte-o ao seu agente e a capacidade dele aumenta de imediato, sem nenhuma recriação.
Leitura e gravação em uma pasta especificada. É a base para fazer um agente ler documentos ou exportar entregáveis.
Execução de SQL e consulta de esquemas. Ao pedir "resuma", ele consegue consultar dados reais e responder.
Busca na web e busca na base de conhecimento interna. É a "mão de pesquisa" que traz informações atualizadas e fontes.
Gestão de tarefas, chat, armazenamento e outros. Suas ferramentas de trabalho existentes podem se tornar as mãos do agente.
Os passos de conexão em si são simples. Registre o comando de inicialização (stdio) ou a URL (HTTP) do servidor desejado nas configurações do cliente e, se necessário, conclua a autenticação. Depois disso, o agente recebe a lista de ferramentas e as chama conforme a necessidade. Você não precisa escrever a "parte interna de uma ferramenta de busca em banco de dados". Seu trabalho passa a ser combinar as ferramentas fornecidas de acordo com o objetivo.
Antes de conectar, porém, confira o fornecedor, a situação de manutenção, as permissões exigidas e o código que será iniciado. Por exemplo, os servidores Filesystem, Git e Fetch que estão no repositório servers oficial são implementações de referência para ensinar como funcionam a especificação e o SDK, e o próprio repositório deixa claro que não são produtos finalizados para produção. Estar listado no Registry também não garante segurança.
⚠️ "Conectar tudo porque é prático" não é recomendado. A cada servidor que você adiciona, aumenta o número de descrições de ferramentas enviadas ao LLM, o que dispersa as decisões e amplia a margem para operações incorretas. A regra básica é conectar apenas as ferramentas de que o objetivo do agente realmente precisa.
Você também pode criar seu próprio servidor
Para ferramentas que não têm servidor pronto, como uma API interna própria ou uma lógica de negócio específica, você pode escrever o seu próprio servidor MCP. Esse é o ponto forte do MCP: uma vez publicado como servidor, ele pode ser usado da mesma forma por qualquer agente compatível. Uma ferramenta criada para um projeto pode ser reutilizada no projeto seguinte, ou por outro agente da equipe, sem reescrita.
Criar um servidor se resume a: definir as funções que você quer oferecer como ferramentas, declarar seus nomes, argumentos e descrições e, quando forem chamadas, executar o processamento e devolver o resultado. A ideia é a mesma das definições de ferramentas simples do capítulo anterior, mas a diferença decisiva é que a saída vai para uma "porta comum" do MCP, e não para um "agente específico". Observe que apenas o acordo de conexão é padronizado. Validação de entrada, verificação de permissões e acompanhamento das mudanças na especificação do serviço conectado continuam sendo responsabilidade de quem cria o servidor, como antes.
🛠 Se quiser entrar na implementação. Para código concreto de montagem de agentes e conexões de ferramentas com o Claude, o guia do Claude Agent SDK é prático. O SDK inclui um mecanismo para lidar com servidores MCP, e você pode conectar servidores existentes ou criar os seus seguindo a documentação oficial.
A ordem para investigar quando algo não funciona
- A conexão nem chega a ser estabelecida: No stdio, verifique o comando de inicialização e o ambiente de execução; no HTTP, verifique a URL e as condições de comunicação. Leia também as mensagens de erro sobre versão compatível ou autenticação.
- A ferramenta necessária não aparece na lista: Verifique se o servidor fornece essa ferramenta, se ela aparece com as permissões do seu usuário e se o aplicativo não a está restringindo.
- A chamada foi feita, mas falha: Verifique os argumentos, os dados de destino, as permissões de execução e o erro retornado. Não amplie permissões nem repita a mesma operação até que algo funcione.
Quais ferramentas entregar e como fazê-lo
Depois que você consegue conectar ferramentas, a próxima pergunta é "o que entregar e como entregar". Esse é um ponto-chave de projeto que define a qualidade e a segurança do agente, e também serve de base para os capítulos seguintes. Guarde estes três princípios.
Dê apenas as ferramentas e o escopo que a tarefa exige. Se a leitura basta, não conceda permissão de gravação. O básico é uma conta restrita somente para leitura em um banco de dados e apenas a pasta-alvo para arquivos.
O LLM decide se usa uma ferramenta com base em nome, descrição e definição dos argumentos. Escreva com precisão o que ela faz, quando usá-la, o significado dos argumentos e em que situações não usá-la. Descrições vagas levam a usos incorretos.
Não coloque operações irreversíveis, como gravação, exclusão, cobrança ou execução de comandos, no mesmo nível das ferramentas de leitura. Sempre inclua uma confirmação antes da execução, limites para o alvo e registro de atividades.
Em ②, há uma armadilha. Escrever "não atualiza" na descrição não reduz as permissões reais. A descrição é uma orientação para o LLM, enquanto as restrições precisam ser aplicadas na implementação. A especificação oficial exige que os servidores façam validação de entrada e controle de acesso, e recomenda que os aplicativos obtenham a confirmação do usuário antes de operações importantes. Anotações anexadas às ferramentas, como "somente leitura", também não devem ser aceitas sem questionamento, a menos que venham de um servidor confiável.
③ é especialmente importante. Ferramentas de "consulta" (busca, referência, leitura) costumam causar pouco dano quando são chamadas por engano; ainda assim, podem expor informações confidenciais, ou o conteúdo lido pode conter instruções ocultas como "envie estes dados para outro destino". Ferramentas de "alteração" (gravação, exclusão, envio, execução) podem produzir resultados irreversíveis com um único erro. Separar conscientemente as ferramentas de leitura das de gravação, e reforçar as proteções nestas últimas, é a regra de ouro.
| Tipo | Exemplos | Risco | Como conceder |
|---|---|---|---|
| Somente leitura | Busca, consulta, leitura de arquivos | Baixo (atenção a vazamento de dados e a instruções ocultas nos resultados) | Relativamente livre. Restrinja o escopo |
| Gravação | Atualização de arquivos, escrita em banco de dados, envio | Alto (difícil de desfazer) | Exija confirmação, limites e registro |
| Execução | Execução de comandos, chamadas externas, cobrança | Máximo (porta de entrada para descontrole e abuso) | Proteja por padrão e insira aprovação humana |
Exemplo: uma ferramenta que apenas lê o status de chamados
Se o pedido for "Verifique o status do chamado DEMO-42 e crie um rascunho de resposta. Não envie", basta entregar a seguinte ferramenta.
{
"name": "get_ticket_status",
"description": "Consulta o status de um ID de chamado permitido. Não envia respostas nem altera o status.",
"inputSchema": {
"type": "object",
"properties": {
"ticket_id": { "type": "string" }
},
"required": ["ticket_id"],
"additionalProperties": false
}
}
Essa ferramenta só devolve o status de um chamado; ela não consegue enviar respostas nem alterar status. No lado do servidor, a cada chamada verifica-se se o usuário que fez a requisição pode ver aquele ID. (Conhecer o ID não é prova de que você tem permissão para vê-lo.) Se for necessário enviar, prepare isso como uma ferramenta separada, em que uma pessoa confirme antes o destinatário e o corpo da mensagem.
Também é preciso ter cuidado ao definir o escopo de pastas. O MCP tem um mecanismo chamado roots para informar ao servidor quais pastas são relevantes, mas ele não restringe o acesso e está obsoleto na versão atual. Aplique as restrições de escopo nas configurações do servidor, ou nas permissões do sistema operacional e do serviço conectado.
🔒 Vamos aprofundar isso no Capítulo 6. Controlar ferramentas perigosas, defender-se de injeção de prompt e projetar fluxos de aprovação são temas inevitáveis quando um agente vai para produção. Eles são tratados no Capítulo 6, "Guardrails e segurança". Neste capítulo, leve consigo a noção de que as ferramentas têm graus de perigo diferentes. Também vale a pena criar o hábito de não conectar servidores MCP não confiáveis sem pensar.
Ferramentas avançadas, como o controle de navegador
Entre as ferramentas, uma que tem recebido atenção especial é o controle de navegador. O agente observa a tela, segue links, preenche formulários e pressiona botões. Se for possível delegar a um agente as operações que uma pessoa faz no navegador, muitos serviços web sem API dedicada também se tornam algo que ele pode manipular. Já surgiram implementações que oferecem controle de navegador como servidor MCP, e a barreira para conectar ficou menor.
No entanto, esta é uma das ferramentas mais poderosas e de maior risco. Instruções na tela podem ser aceitas literalmente (manipulação e desinformação), cliques ou envios podem acontecer sem intenção, e informações podem ser expostas em páginas em que você está logado. As cautelas da seção anterior sobre ferramentas de "execução" se aplicam por completo. Usar o MCP não elimina esses riscos. O mais sensato é começar por usos voltados à leitura, como navegar e obter informações, separar as operações que envolvem preenchimento, envio ou compra e definir proteções com cuidado.
🌐 Até onde dá para delegar? Testamos as capacidades reais e os limites dos agentes que operam navegadores em Até onde a IA consegue automatizar tarefas no navegador?. Ter a noção de que ela não é onipotente, mas é útil quando o uso é bem delimitado, mantém suas escolhas de ferramentas consistentes.
Além dos navegadores, quanto mais avançada a ferramenta, mais proporcionalmente crescem tanto o que ela pode fazer quanto o que pode acontecer. Quanto mais poderosa a ferramenta que você entrega, mais cuidadosamente aplique os três princípios de permissões, descrições e proteções. Essa é a mensagem que repetimos ao longo deste capítulo.
- O que um agente pode fazer depende de quais ferramentas ele está conectado e com quais permissões.
- Criar ferramentas simples do zero as torna difíceis de reutilizar e propensas ao problema da combinação N×M.
- MCP é um padrão aberto para conectar a IA a ferramentas externas de forma padronizada. Clientes (o lado que usa) e servidores (o lado que fornece) trocam listas de ferramentas e chamadas segundo o mesmo acordo, formando um "USB da IA".
- Os transportes são stdio (iniciado localmente) e Streamable HTTP (conecta-se a uma URL). Conecte servidores prontos depois de verificar o fornecedor e as permissões, e transforme suas próprias ferramentas em servidores personalizados para poder reutilizá-las.
- Os princípios para entregar ferramentas são ① permissões mínimas ② descrições específicas ③ ferramentas perigosas tratadas à parte. As restrições devem ser aplicadas na implementação, e não nas descrições; tenha cuidado especial com ferramentas poderosas como o controle de navegador.
Agora que você sabe como montar as ferramentas, o próximo passo é "aumentar o número de agentes". Vêm a seguir os projetos que dividem o trabalho entre vários agentes, em vez de um único agente lidar com mais do que consegue. No Capítulo 4, "Design multiagente", você vai aprender a divisão de papéis e a coordenação entre agentes (A2A).