Conecte o Claude a ferramentas e agentes locais com MCP

Intermediário

Você quer que o Claude seja o cérebro e a sua máquina forneça as mãos — ler seus arquivos, consultar seu banco de dados, rodar seu script, até chamar um modelo local ou um agente local, tudo sem os seus dados saírem do laptop. Essa sinergia já tem um padrão: o Model Context Protocol (MCP). Em uma frase: o MCP é um padrão aberto que deixa um cliente de IA chamar ferramentas e dados externos através de pequenos programas chamados servidores MCP — e esses servidores podem rodar de forma privada, localmente, na sua própria máquina. Esta página mostra o que é o MCP, como a arquitetura local se encaixa, como adicionar um servidor local ao Claude e como construir um pequeno servidor seu.

What you'll learn

• Explicar o MCP em uma frase — um padrão aberto para que um cliente de IA chame ferramentas e dados externos via servidores MCP
• Ver a arquitetura local: um cliente MCP (Claude Code / Claude Desktop) falando com um servidor MCP local por stdio
• Entender por que ISSO É a sinergia Claude-como-cérebro + capacidades-locais que você quer
• Adicionar um servidor MCP local ao Claude com um comando
• Construir um pequeno servidor MCP que expõe uma ferramenta
• Conhecer a fronteira de confiança — servidores MCP agem com os SEUS privilégios, então instale só o que você confia

O que é o MCP (em uma frase)

O MCP é um padrão aberto para conectar aplicações de IA a sistemas externos. Um cliente de IA (como o Claude) fala um protocolo; qualquer servidor MCP que o fale pode se plugar e oferecer novas habilidades ao cliente. A analogia oficial é uma porta USB-C para IA: em vez de uma integração sob medida por ferramenta, você constrói para um conector e ele funciona em todo lugar.

A Anthropic introduziu e abriu o código do MCP, e desde o primeiro dia ele veio com suporte a servidor MCP local para que o Claude pudesse se conectar a sistemas internos e conjuntos de dados rodando na sua própria máquina.

Última verificação: 2026-06-28.

Números de adoção, a data de revisão da spec, a governança (a tutela do MCP) e o elenco exato de clientes que suportam MCP mudam com frequência. Trate qualquer número específico como perecível e confirme em modelcontextprotocol.io e no anúncio da Anthropic. Os fatos duráveis — o MCP é um padrão aberto, cliente ↔ servidor, servidores podem rodar localmente, amplamente adotado entre clientes — são estáveis.

Confirme na fonte oficial.

Um servidor MCP pode expor três tipos de coisa ao cliente:

• Tools (ferramentas) — ações que o modelo pode chamar (ler um arquivo, rodar uma consulta, bater numa API). É o mesmo formato do uso de ferramentas nativo do modelo: uma capacidade nomeada com entradas tipadas.
• Resources (recursos) — dados que o cliente pode ler (arquivos, registros, documentos).
• Prompts — templates de prompt reutilizáveis e parametrizados que o servidor oferece.

Para esta página, o destaque são as tools: um servidor MCP local é como você entrega ao Claude uma nova capacidade privada.

Por que essa é a sinergia que você quer

O que as pessoas querem dizer com "Claude como o cérebro, meu computador como o corpo" é exatamente a divisão cliente/servidor do MCP:

• O Claude é o orquestrador. Ele lê o seu objetivo, decide qual ferramenta chamar, a chama, lê o resultado e decide o próximo passo.
• Os servidores MCP locais são as capacidades. Cada um é um pequeno programa que você roda na sua máquina: um servidor de filesystem, um servidor de banco de dados, um wrapper em torno de um script local, até um servidor que chama um modelo local ou passa trabalho a um agente local.

Como o servidor roda localmente e o Claude fala com ele pela entrada/saída padrão da sua própria máquina, os seus dados e ações ficam no seu hardware — o modelo orquestra, mas as leituras de arquivo, o SQL e a execução do script acontecem localmente. Essa é a versão que preserva a privacidade do trabalho agêntico: cérebro na nuvem (ou local também), mãos estritamente na sua máquina.

E como o MCP é um padrão aberto adotado por muitos clientes, um servidor que você constrói não fica preso a um único app. O mesmo servidor local que você conecta ao Claude Code pode ser usado por outros clientes que falam MCP — construa uma vez, reuse em todo lugar.

A arquitetura local

A menor imagem útil tem duas partes e um canal:

• Cliente MCP (host). O app de IA — por exemplo o Claude Code ou o Claude Desktop. Ele contém o modelo e decide quais ferramentas chamar.
• Servidor MCP. Um processo separado que anuncia tools/resources/prompts e os executa quando solicitado.
• Transporte. Para servidores locais, o cliente inicia o servidor como um subprocesso e eles falam por stdio (entrada/saída padrão) usando mensagens JSON-RPC. Sem rede, sem porta — apenas um pipe local entre dois processos na sua máquina. (Servidores remotos também existem, por HTTP; esta página é sobre o caso local, por stdio.)

┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

O modelo nunca toca no seu disco diretamente — ele pede ao servidor local, e o servidor (rodando com as suas permissões) faz o trabalho e retorna um resultado.

Adicione um servidor MCP local ao Claude

O caminho mais rápido é o comando claude mcp add do Claude Code, que registra um servidor que o cliente iniciará por stdio. O formato geral é um nome, depois o comando que inicia o servidor.

Guided walkthrough1 of 4

1. Comece com um servidor de referência oficial (ex.: o servidor de filesystem) para que o comportamento seja conhecido. A Anthropic mantém uma coleção de servidores MCP de referência que você pode rodar localmente — filesystem, git, memory, fetch e mais.

Um claude mcp add mínimo para um servidor de filesystem local (tudo depois de -- é o comando de inicialização):

Adicione um servidor MCP de filesystem local ao Claude Code

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Se você preferir editar a config diretamente, um servidor stdio é declarado pelo comando que o inicia. O formato é assim:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Última verificação: 2026-06-28.

Os subcomandos exatos de claude mcp, os escopos de configuração, a localização do arquivo de config e os nomes precisos dos pacotes dos servidores de referência evoluem. Confirme a sintaxe atual no guia de MCP do Claude Code e no repositório de servidores de referência antes de depender de uma flag ou nome de pacote específico.

Confirme na fonte oficial.

Construa um pequeno servidor MCP

Um servidor é apenas um programa que usa um SDK do MCP, declara uma ferramenta e inicia um transporte stdio. Aqui está a ideia inteira em TypeScript — uma ferramenta que soma dois números (troque o corpo por "rode meu script", "consulte meu BD", "chame meu modelo local"):

npm install @modelcontextprotocol/sdk zod

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

Registre-o no Claude exatamente como qualquer outro servidor stdio — aponte o comando de inicialização para o seu arquivo:

Adicione o seu próprio servidor local ao Claude Code

claude mcp add my-local-tools -- node /abs/path/to/server.js

Esse é o loop completo: o Claude (cérebro) vê uma nova ferramenta, a chama quando relevante, e o seu código (mãos) roda localmente e retorna o resultado. Como ele fala o mesmo protocolo aberto, este servidor também funciona em outros clientes MCP sem mudanças.

Watch out

• Servidores MCP rodam com os seus privilégios e podem tomar ações reais — instale apenas servidores que você confia e fique atento a prompt-injection via resultados de ferramentas.

Teste-se

Teste-se

0/4

1. 1Em uma frase, o que é o MCP?
2. 2Para um servidor MCP LOCAL, como o cliente costuma falar com ele?
3. 3Por que construir um servidor MCP compensa entre ferramentas?
4. 4Qual é a principal razão para avaliar um servidor antes de instalá-lo?

Pressione Enter ou Espaço para virar o cartão. Use as setas esquerda e direita para navegar entre os cartões.Termo exibido.

1 / 8

Key takeaways

• O MCP é um padrão aberto para que um cliente de IA chame ferramentas e dados externos via servidores MCP — a Anthropic o introduziu com suporte a servidor local desde o começo.
• A arquitetura local é simples: um cliente MCP (Claude Code / Desktop) inicia um servidor MCP local como subprocesso e fala com ele por stdio — os seus dados ficam na sua máquina.
• Essa é a sinergia Claude-como-cérebro + capacidades-locais: o Claude orquestra; servidores locais (filesystem, BD, um script, até um modelo ou agente local) fornecem as mãos.
• Adicione um servidor com um comando (claude mcp add ... -- <comando de inicialização>); construa um com um SDK do MCP registrando uma ferramenta e conectando um transporte stdio.
• O MCP é amplamente adotado, então um servidor local que você constrói funciona entre muitos clientes — construa uma vez, reuse em todo lugar.
• Servidores agem com os seus privilégios: instale só o que você confia e trate resultados de ferramentas como um possível vetor de prompt-injection.

Próximo

• Use MCP a partir do terminal no dia a dia → Claude Code: MCP
• O que é o orquestrador → O que é Claude Code
• O formato de tool-calling que as ferramentas MCP seguem → Uso de ferramentas
• Rode o modelo ou agente local que um servidor pode envelopar → Agentes de IA locais

Fontes e leitura adicional

• Model Context Protocol — site oficial
• Arquitetura e conceitos do MCP
• Construa um servidor MCP (guia oficial)
• Introducing the Model Context Protocol — Anthropic
• Servidores MCP de referência (filesystem, git, fetch, …)
• Model Context Protocol — Wikipedia (visão geral e adoção)