# MCP no Claude Code e em qualquer agente: configure e inspecione servidores por repositório

> Configurar um servidor MCP no Claude Code e em outros agentes de código é feito na configuração do próprio agente, em geral um arquivo `.mcp.json` na raiz do repositório. O Tallos não traz servidores MCP; ele inspeciona os seus. Em Configurações → Projetos → seu repositório → **Configurações MCP**, você vê cada servidor definido em `.mcp.json`, `.cursor/mcp.json`, `.claude.json` e `.claude/mcp.json`, com transporte, status e segredos mascarados.

- Canonical: https://runtallos.com/pt/recursos/mcp
- English: https://runtallos.com/features/mcp.md
- Autor: [Roberto Rocha](https://www.instagram.com/robertorochamkt/)
- Atualizado em: 2026-09-30
- Section: Recursos

## Em resumo

- Verifica `.mcp.json`, `.cursor/mcp.json`, `.claude.json` e `.claude/mcp.json`
- Transporte (`stdio` / `http`) e status (`enabled` / `disabled` / `invalid`) por servidor
- Valores sensíveis do `env` aparecem como `••••••••`
- Cria um `.mcp.json` vazio quando o repositório não tem nenhum
- Lê repositórios SSH pelo sistema de arquivos remoto

## O que é MCP?

**MCP (Model Context Protocol)** é um protocolo aberto, criado pela Anthropic, que permite a agentes de IA chamar ferramentas e fontes de dados externas por uma interface padrão. Cada integração roda como um **servidor MCP**: um programa pequeno ou um endpoint remoto que expõe ferramentas, como consultar um banco de dados, ler um gerenciador de tarefas ou buscar na documentação interna. O agente que suporta MCP se conecta aos servidores listados na configuração dele e chama essas ferramentas durante a tarefa.

Dois transportes cobrem quase todos os casos. No **stdio**, o agente inicia o servidor como um processo local e conversa com ele pela entrada e saída padrão. No **HTTP**, o servidor roda em outro lugar e o agente se conecta a uma URL. O [glossário](https://runtallos.com/pt/glossario) tem definições curtas dos termos relacionados.

## Como agentes como o Claude Code usam servidores MCP?

Cada agente lê os servidores MCP dos próprios arquivos de configuração e inicia ou se conecta a eles por conta própria. Um arquivo de projeto, quase sempre o `.mcp.json` na raiz do repositório, garante os mesmos servidores para todo mundo que clona o repo. O agente também pode guardar servidores pessoais em configurações de usuário, fora do repositório.

O Tallos não traz servidores MCP próprios e não muda a forma como os agentes carregam os seus. Quando você inicia o [Claude Code](https://runtallos.com/pt/integracoes/claude-code) ou outro agente com suporte a MCP num workspace do Tallos, ele lê as configurações exatamente como faria em qualquer terminal. O que o Tallos acrescenta é visibilidade: para cada repositório, você vê quais servidores os agentes vão encontrar antes de iniciá-los.

Todo workspace do Tallos é uma git worktree do mesmo repositório, então um `.mcp.json` commitado existe em todos eles e os [workspaces paralelos](https://runtallos.com/pt/recursos/workspaces-paralelos) recebem os mesmos servidores. Um arquivo sem commit só existe no workspace em que você o criou.

## O que o inspetor de Configurações MCP do Tallos mostra?

**Configurações MCP** é uma seção em Configurações → Projetos → *seu repositório* que inspeciona as definições de servidores MCP que os agentes podem usar naquele repositório. Ela lê a raiz do workspace ativo do repo (ou da worktree principal, quando nenhum workspace dele está ativo), verifica quatro arquivos conhecidos e lista cada servidor dentro do objeto `mcpServers`.

| Origem da configuração | Onde | O que o Tallos mostra |
| --- | --- | --- |
| Workspace | `.mcp.json` | Status do arquivo e, para cada servidor, nome, transporte, comando ou URL, `env` e status. **Adicionar configuração MCP** cria este arquivo quando não existe nenhuma configuração |
| Cursor | `.cursor/mcp.json` | Os mesmos detalhes por servidor, com o rótulo Cursor e o botão **Abrir** |
| Claude | `.claude.json` | Os servidores do objeto `mcpServers` no topo do arquivo |
| Claude workspace | `.claude/mcp.json` | Os mesmos detalhes por servidor, com o rótulo Claude workspace |

_Arquivos que as Configurações MCP verificam, a partir da raiz do workspace_

- **Por arquivo:** status de não encontrado, JSON inválido, ilegível, sem servidores ou a contagem de servidores, mais o botão **Abrir** para editar o arquivo no editor do Tallos.
- **Por servidor:** nome, transporte (`stdio` ou `http`), comando ou URL, o bloco `env` e o status `enabled`, `disabled` ou `invalid`.
- **Servidores inválidos** dizem o motivo, como falta de comando ou de URL.
- **Arquivos verificados** que não existem aparecem em *Verificado*, para você saber exatamente o que foi procurado.

O inspetor entende as variações mais comuns: `command` como texto ou lista, `url` ou `httpUrl`, e valores de `type` como `http`, `remote` e `local`. Um servidor com `"disabled": true` ou `"enabled": false` aparece como `disabled`. Arquivos acima de 256 KB, ou com mais de 256 servidores, são marcados como inválidos em vez de lidos.

## Como configurar um servidor MCP no Claude Code no meu repositório?

Adicione o servidor num arquivo `.mcp.json` na raiz do repositório, confira nas Configurações MCP, faça o commit e inicie o agente num workspace. O exemplo usa o formato padrão `mcpServers`.

1. **Abra as Configurações MCP** — No Tallos, vá em Configurações → Projetos, escolha o repositório e desça até **Configurações MCP**. Buscar `mcp` ou `.mcp.json` na busca das configurações também leva até lá.
2. **Crie o arquivo** — Se o repo não tem configuração MCP, clique em **Adicionar configuração MCP** e depois em **Criar configuração vazia** para confirmar. O Tallos grava o `.mcp.json` com um objeto `mcpServers` vazio e abre o arquivo no editor.
3. **Adicione os servidores** — Crie uma entrada por servidor dentro de `mcpServers`. Servidores locais usam `command`, `args` e, se precisar, `env`. Servidores remotos usam `"type": "http"` e uma `url`.
4. **Atualize e confira** — Clique em atualizar nas Configurações MCP. Cada servidor deve mostrar o transporte certo e `enabled`. Corrija o que estiver como `invalid` antes de iniciar um agente.
5. **Faça o commit e rode** — Commite o `.mcp.json` para que todo workspace e todo colega recebam o arquivo, e inicie o Claude Code ou outro agente com suporte a MCP num workspace. O próprio agente carrega os servidores.

```json
{
  "mcpServers": {
    "internal-docs": {
      "command": "node",
      "args": ["./tools/mcp/docs-server.js"],
      "env": {
        "DOCS_DIR": "./docs"
      }
    },
    "issue-tracker": {
      "type": "http",
      "url": "https://mcp.example.com/mcp"
    }
  }
}
```

Nas Configurações MCP, `internal-docs` aparece como `stdio` com o comando `node`, e `issue-tracker` como `http` com a URL. Os dois ficam `enabled`.

> **Cada agente com seu arquivo** — O `.mcp.json` é o arquivo de projeto que o Claude Code lê. Outros agentes podem usar outro caminho ou formato, então confira a documentação de cada um. O Cursor, por exemplo, lê `.cursor/mcp.json`, que o Tallos também inspeciona.

## Veja o que seus agentes vão carregar

> Instale o Tallos, adicione seu repositório e confira as Configurações MCP antes de iniciar os agentes. → https://runtallos.com/signup

## Como manter os segredos do MCP fora do git?

Não coloque chaves de API nem tokens em configuração MCP que vai para o repositório. Um `.mcp.json` commitado fica legível para todo mundo com acesso ao repo e para todo agente que trabalha nele.

- **Não commite segredos em texto puro.** Deixe servidores que precisam de token pessoal na configuração de usuário do agente, fora do repo, ou use referências a variáveis de ambiente se o seu agente suportar. A sintaxe está na documentação dele.
- **A máscara vale para a tela, não para o arquivo.** O Tallos mascara um valor do `env` quando a chave parece sensível (`token`, `secret`, `password`, `api_key`, `auth`, `bearer`, `cookie`, `session`, `credential`, `private_key`) ou quando o valor parece um formato de token conhecido, como `sk-…` ou `ghp_…`. Aparece `••••••••`; o arquivo no disco continua igual.
- **Ignore arquivos pessoais.** Se você guarda um arquivo MCP pessoal dentro da pasta do repo, coloque-o no `.gitignore`.
- **Leia antes de rodar.** Um servidor stdio é um programa que o agente executa na sua máquina. Confira os comandos nas Configurações MCP antes de abrir um agente num repo que você acabou de clonar.

## As Configurações MCP funcionam com repositórios SSH?

Funcionam. Num repositório em [workspace remoto](https://runtallos.com/pt/recursos/workspaces-remotos), o Tallos lê os arquivos pelo sistema de arquivos remoto via SSH. O repo precisa estar conectado; se não estiver, a seção pede para você conectar primeiro. Em repositórios remotos, a criação da configuração inicial fica limitada ao `.mcp.json` na raiz do workspace.

As Configurações MCP aparecem em repositórios git. Projetos que são só uma pasta não têm essa seção.

## Qual a relação entre servidores MCP, a CLI tallos e as skills?

Resolvem problemas diferentes e convivem bem. Servidores MCP dão ao agente ferramentas de sistemas externos. A [CLI tallos e as skills incluídas](https://runtallos.com/pt/recursos/cli-e-skills) deixam o agente pilotar o próprio Tallos: criar workspaces, ler terminais, usar o navegador integrado. As [skills de agentes](https://runtallos.com/pt/recursos/skills-de-agentes) são as instruções que dizem ao agente quando usar cada coisa.

## Perguntas frequentes

### Como adicionar um servidor MCP no Claude Code?

Coloque o servidor dentro de `mcpServers` num arquivo `.mcp.json` na raiz do repositório, com `command` e `args` para um servidor local ou `"type": "http"` e `url` para um remoto. No Tallos, Configurações → Projetos → seu repositório → Configurações MCP cria o arquivo vazio e confirma que o servidor foi detectado.

### O Tallos vem com servidores MCP próprios?

Não. O Tallos não traz servidores MCP. Os agentes usam os servidores definidos nas configurações deles, e o Tallos mostra o que cada repositório define.

### Quais arquivos de configuração MCP o Tallos lê?

Quatro arquivos na raiz do workspace: `.mcp.json`, `.cursor/mcp.json`, `.claude.json` e `.claude/mcp.json`. Os servidores vêm do objeto `mcpServers` de cada um.

### O Tallos mostra minhas chaves de API do MCP na tela?

Não. Valores do `env` com nome ou formato sensível, como `API_KEY` ou `GITHUB_TOKEN`, aparecem como `••••••••`. A máscara só afeta a exibição, então continue mantendo segredos fora dos arquivos commitados.

### O que significa invalid ao lado de um servidor MCP?

Falta algo que o agente precisa na entrada, como o comando de um servidor stdio ou a URL de um servidor HTTP. O Tallos mostra o motivo logo abaixo do nome do servidor.

### Os servidores MCP funcionam em todos os workspaces paralelos?

Um `.mcp.json` commitado faz parte do repositório, então existe em todo workspace que o Tallos cria a partir dele. Um arquivo sem commit só existe no workspace em que foi criado.

### Dá para inspecionar configurações MCP numa máquina remota via SSH?

Dá. Com a conexão ativa, o Tallos lê repositórios SSH pelo sistema de arquivos remoto e pode criar um `.mcp.json` inicial na raiz do workspace.

## Fontes

1. [What is the Model Context Protocol (MCP)?](https://modelcontextprotocol.io/docs/getting-started/intro) — Model Context Protocol
2. [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp) — Anthropic
3. [Model Context Protocol specification](https://modelcontextprotocol.io/specification/latest) — Model Context Protocol

---

**Rode seus agentes em paralelo com o Tallos** — Claude Code, Codex, Gemini e mais de 30 agentes — cada um no seu workspace, com squads, chat, terminais e revisão num só app. Usa as assinaturas que você já tem.

https://runtallos.com/signup (macOS 13+ · Windows 10+)