Pular para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

Use this file to discover all available pages before exploring further.

Por padrão, qualquer pessoa que execute Claude Code pode conectar qualquer servidor MCP que escolher. A Anthropic analisa conectores em relação aos seus critérios de listagem antes de adicioná-los ao Diretório Anthropic, mas não realiza auditoria de segurança ou gerencia nenhum servidor MCP. Como administrador, você pode restringir quais servidores são executados em sua organização, desde a implantação de um conjunto fixo aprovado até a desabilitação completa do MCP. Esta página aborda como:
A página Segurança aborda o modelo de ameaça do MCP e como avaliar um servidor antes de aprová-lo. Decidir o que aplicar aborda restrições de MCP junto com os outros controles administrativos.

Escolher um padrão

Claude Code suporta uma variedade de níveis de restrição. Cada padrão usa um ou ambos os mecanismos abordados abaixo: managed-mcp.json para implantar um conjunto fixo, e allowedMcpServers/deniedMcpServers para filtrar o que os usuários configuram.
PadrãoO que fazConfigurar
Desabilitar MCPNenhum servidor é carregado em lugar nenhummanaged-mcp.json com um mapa de servidor vazio
Implantação fixaCada usuário obtém os mesmos servidores e não pode adicionar outrosmanaged-mcp.json com os servidores que você deseja
Catálogo aprovadoPublique uma lista de servidores aprovados; os usuários adicionam os que desejam, qualquer outro é bloqueadoallowedMcpServers + allowManagedMcpServersOnly: true
Apenas servidores de pluginsOs servidores podem vir apenas de plugins; os usuários não podem adicionar os seus própriosstrictPluginOnlyCustomization com mcp na lista
Lista de permissão suaveAplicar uma lista de permissão que os usuários podem ampliar em suas próprias configuraçõesallowedMcpServers sem allowManagedMcpServersOnly
Apenas lista de bloqueioBloqueie servidores conhecidos como ruins, permita tudo o maisdeniedMcpServers
Sem restriçõesOs usuários adicionam qualquer coisaNão implante nenhuma configuração gerenciada de MCP
Claude Code não possui um registro de servidor MCP integrado que os usuários possam procurar e instalar. Para o padrão de catálogo aprovado, compartilhe a lista aprovada e seus comandos claude mcp add em algum lugar onde seus usuários a encontrem, como um wiki interno, ou distribua os servidores como plugins através de um marketplace de plugins gerenciado para que os usuários possam procurar e instalá-los em /plugin.

Controle exclusivo com managed-mcp.json

Se você implantar um arquivo managed-mcp.json, Claude Code carrega apenas os servidores que esse arquivo define. Os usuários não podem adicionar, modificar ou usar nenhum outro servidor MCP, incluindo servidores fornecidos por plugins e conectores do claude.ai. Duas outras configurações podem filtrar ainda mais o conjunto gerenciado:
  • allowedMcpServers e deniedMcpServers também se aplicam a servidores gerenciados, portanto um servidor gerenciado que não passar por eles não será carregado.
  • O próprio deniedMcpServers de um usuário é mesclado a partir de suas configurações, portanto os usuários podem bloquear um servidor gerenciado para si mesmos.
Consulte Como um servidor é avaliado para a ordem completa de verificações. managed-mcp.json é um arquivo autônomo, portanto não pode ser entregue através de configurações gerenciadas pelo servidor. Qualquer processo que possa escrever em um caminho do sistema com privilégios de administrador pode implantá-lo. Em escala, isso geralmente é feito através de ferramentas de gerenciamento de dispositivos, como Jamf ou um perfil de configuração no macOS, Política de Grupo ou Intune no Windows, ou seu gerenciamento de frota de escolha no Linux. Claude Code procura o arquivo em um destes caminhos:
PlataformaCaminho
macOS/Library/Application Support/ClaudeCode/managed-mcp.json
Linux e WSL/etc/claude-code/managed-mcp.json
WindowsC:\Program Files\ClaudeCode\managed-mcp.json
O arquivo usa o mesmo formato que um arquivo de projeto .mcp.json:
{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "company-internal": {
      "type": "stdio",
      "command": "/usr/local/bin/company-mcp-server",
      "args": ["--config", "/etc/company/mcp-config.json"],
      "env": {
        "COMPANY_API_URL": "https://internal.example.com"
      }
    }
  }
}

Autenticar com credenciais por usuário

Qualquer usuário na máquina pode ler este arquivo, portanto não armazene chaves de API ou outras credenciais em blocos env. Passe credenciais por usuário com uma destas alternativas:

Validar a configuração

Para confirmar que o arquivo está em vigor, execute duas verificações em uma máquina gerenciada:
  1. claude mcp list mostra apenas os servidores em managed-mcp.json. Se os próprios servidores de um usuário ainda aparecerem, o arquivo não está sendo lido; verifique o caminho e as permissões.
  2. claude mcp add --transport http test https://example.com/mcp falha com Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers. A URL não precisa ser um servidor real, pois a verificação de política rejeita o comando antes de qualquer coisa ser contatada.

Desabilitar MCP completamente

Implante um managed-mcp.json contendo um mapa de servidor vazio para bloquear todos os servidores MCP:
{
  "mcpServers": {}
}
Os usuários não veem nenhum servidor MCP em /mcp, e claude mcp add falha com o erro de política empresarial acima. Os servidores que os usuários configuraram anteriormente param de ser carregados na próxima vez que iniciam uma sessão, sem aviso de que a política é o motivo.

Controle baseado em política com listas de permissão e listas de bloqueio

Listas de permissão e listas de bloqueio filtram quais servidores configurados podem ser carregados. Elas não são um registro: um servidor ainda precisa ser adicionado por um usuário, um plugin ou managed-mcp.json antes que a lista de permissão ou lista de bloqueio se aplique a ele. Para implantar servidores para usuários, use managed-mcp.json. Para tornar a lista de permissão autoritária, defina allowedMcpServers e allowManagedMcpServersOnly: true juntos em uma fonte de configurações gerenciadas, como configurações gerenciadas pelo servidor ou um arquivo managed-settings.json implantado. Restringir a lista de permissão apenas a configurações gerenciadas mostra a configuração. Sem allowManagedMcpServersOnly, listas de permissão de todas as fontes de configurações são mescladas, incluindo o próprio ~/.claude/settings.json de um usuário, portanto um usuário pode ampliar o que sua lista de permissão permite. Listas de bloqueio são mescladas de todas as fontes independentemente.
allowManagedMcpServersOnly é separado de allowManagedPermissionRulesOnly, que bloqueia apenas regras de permissão. Definir esse sinalizador não aplica a lista de permissão de MCP.

Corresponder servidores por URL, comando ou nome

allowedMcpServers e deniedMcpServers são listas de entradas. Cada entrada é um objeto com uma única chave que identifica servidores por sua URL, seu comando ou seu nome:
ChaveCorrespondeUse para
serverUrlUma URL de servidor remoto, exata ou com curingas *Servidores HTTP e SSE
serverCommandO comando exato e argumentos que iniciam um servidor stdioServidores stdio
serverNameO rótulo atribuído pelo usuário. Correspondência exata apenas; curingas não são expandidosQualquer tipo, mas veja o Aviso abaixo
Deixar allowedMcpServers não definido é diferente de defini-lo como uma matriz vazia:
ConfiguraçãoNão definido (padrão)Matriz vazia []Preenchido
allowedMcpServersTodos os servidores permitidosNenhum servidor permitidoApenas servidores correspondentes permitidos
deniedMcpServersNenhum servidor bloqueadoNenhum servidor bloqueadoServidores correspondentes bloqueados
Uma lista de permissão que usa apenas entradas serverName não é um controle de segurança. O nome é o rótulo que um usuário atribui ao executar claude mcp add ou editar um arquivo de configuração, não o servidor subjacente, portanto um usuário pode chamar qualquer servidor de github. Para aplicar quais servidores realmente são executados, adicione entradas serverCommand ou serverUrl.

Como um servidor é avaliado

Antes de carregar um servidor, incluindo um de managed-mcp.json, Claude Code executa três verificações em ordem:
  1. Mesclar as listas. Entradas de lista de permissão e lista de bloqueio de todas as fontes de configurações se combinam em uma lista de permissão e uma lista de bloqueio. Quando allowManagedMcpServersOnly é true, apenas a lista de permissão gerenciada é mantida; a lista de bloqueio sempre é mesclada de todas as fontes.
  2. Verificar a lista de bloqueio. Um servidor que corresponde a qualquer entrada da lista de bloqueio, por URL, comando ou nome, é bloqueado. Nada substitui uma correspondência da lista de bloqueio.
  3. Verificar a lista de permissão. Se allowedMcpServers não estiver definido em lugar nenhum, todos os servidores que passaram na lista de bloqueio são carregados. Se estiver definido, o que o servidor deve corresponder depende de seu tipo, mostrado na tabela abaixo.
Tipo de servidorPermitido quando corresponde
Remoto (HTTP ou SSE)Uma entrada serverUrl. Uma correspondência serverName conta apenas quando a lista de permissão não contém entradas serverUrl
StdioUma entrada serverCommand. Uma correspondência serverName conta apenas quando a lista de permissão não contém entradas serverCommand
Duas regras de correspondência se aplicam dentro dessas verificações:
  • Comandos correspondem exatamente. Cada argumento, em ordem. ["npx", "-y", "server"] não corresponde a ["npx", "server"] ou ["npx", "-y", "server", "--flag"].
  • URLs suportam curingas * em qualquer lugar do padrão, incluindo o esquema. A correspondência de nome de host não diferencia maiúsculas de minúsculas e ignora um ponto FQDN à direita, portanto https://Mcp.Example.com/* corresponde a https://mcp.example.com/api. Os caminhos permanecem sensíveis a maiúsculas e minúsculas.
PadrãoPermite
https://mcp.example.com/*Todos os caminhos em um domínio específico
https://mcp.example.comTambém todos os caminhos nesse domínio. Um padrão sem caminho corresponde a qualquer caminho
https://*.example.com/*Qualquer subdomínio de example.com
http://localhost:*/*Qualquer porta em localhost
*://mcp.example.com/*Qualquer esquema para um domínio específico

Configuração de exemplo

A configuração abaixo configura uma lista de permissão rígida com uma lista de bloqueio. As linhas destacadas alteram como o resto da lista é avaliado, e os textos explicativos após o bloco explicam cada uma:
{
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "."] },
    { "serverCommand": ["python", "/usr/local/bin/approved-server.py"] },
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" },
    { "serverCommand": ["npx", "-y", "unapproved-package"] },
    { "serverUrl": "https://*.untrusted.example.com/*" }
  ]
}
  • Linha 3: a primeira entrada serverUrl. Uma vez que existe uma, cada servidor remoto deve corresponder a um padrão de URL, portanto um usuário não pode obter um servidor remoto não listado dando-lhe um nome permitido.
  • Linha 5: a primeira entrada serverCommand. Mesmo efeito para servidores stdio, portanto cada servidor local deve corresponder a um comando listado exatamente.
  • Linha 11: uma entrada serverName na lista de bloqueio. Entradas da lista de bloqueio sempre se aplicam, portanto qualquer servidor nomeado dangerous-server é bloqueado independentemente de sua URL ou comando.
Uma entrada serverName nesta lista de permissão nunca corresponderia a nada, pois ambos os tipos de transporte já têm entradas mais rigorosas. Os acordeões abaixo percorrem como um servidor é avaliado em relação a outras combinações de lista de permissão e lista de bloqueio.
{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}
ServidorResultado
Servidor HTTP em https://mcp.example.com/apiPermitido: corresponde ao padrão de URL
Servidor HTTP em https://api.internal.example.com/mcpPermitido: corresponde ao subdomínio curinga
Servidor HTTP em https://external.example.com/mcpBloqueado: não corresponde a nenhum padrão de URL
Servidor stdio com qualquer comandoBloqueado: sem entradas de nome ou comando para corresponder
{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
ServidorResultado
Servidor stdio com ["npx", "-y", "approved-package"]Permitido: corresponde ao comando
Servidor stdio com ["node", "server.js"]Bloqueado: não corresponde ao comando
Servidor HTTP nomeado my-apiBloqueado: sem entradas de nome para corresponder
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
ServidorResultado
Servidor stdio nomeado local-tool com ["npx", "-y", "approved-package"]Permitido: corresponde ao comando
Servidor stdio nomeado local-tool com ["node", "server.js"]Bloqueado: entradas de comando existem mas não correspondem
Servidor stdio nomeado github com ["node", "server.js"]Bloqueado: servidores stdio devem corresponder a comandos quando entradas de comando existem
Servidor HTTP nomeado githubPermitido: corresponde ao nome
Servidor HTTP nomeado other-apiBloqueado: nome não corresponde
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}
ServidorResultado
Servidor stdio nomeado github com qualquer comandoPermitido: sem restrições de comando
Servidor stdio nomeado internal-tool com qualquer comandoPermitido: sem restrições de comando
Servidor HTTP nomeado githubPermitido: corresponde ao nome
Qualquer servidor nomeado otherBloqueado: nome não corresponde
{
  "allowedMcpServers": [
    { "serverUrl": "https://*.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://staging.example.com/*" }
  ]
}
ServidorResultado
Servidor HTTP em https://mcp.example.com/apiPermitido: corresponde ao padrão de URL da lista de permissão, sem correspondência da lista de bloqueio
Servidor HTTP em https://staging.example.com/apiBloqueado: corresponde a ambos, mas a lista de bloqueio tem precedência
Servidor HTTP em https://other.com/mcpBloqueado: não corresponde à lista de permissão

Restringir a lista de permissão apenas a configurações gerenciadas

Para tornar a lista de permissão gerenciada a única que se aplica, defina allowManagedMcpServersOnly no arquivo de configurações gerenciadas:
{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}
Quando allowManagedMcpServersOnly é true, listas de permissão de configurações de usuário, projeto e local são ignoradas. A lista de bloqueio ainda é mesclada de todas as fontes, portanto os usuários sempre podem bloquear servidores para si mesmos.

Como as restrições aparecem para os usuários

Quando uma restrição bloqueia um servidor, o usuário vê um erro de claude mcp add ou o servidor para de ser carregado silenciosamente. Use esta tabela para reconhecer esses relatórios e para informar aos usuários o que esperar antes de implementar uma alteração:
RestriçãoO que o usuário vê
managed-mcp.json está presente e o usuário executa claude mcp addCannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers
O servidor está em uma lista de bloqueio e o usuário executa claude mcp addCannot add MCP server "<name>": server is explicitly blocked by enterprise policy
O servidor não está na lista de permissão e o usuário executa claude mcp addCannot add MCP server "<name>": not allowed by enterprise policy
Um servidor configurado anteriormente agora é bloqueado pela políticaO servidor desaparece silenciosamente de /mcp e claude mcp list sem aviso
No último caso, o usuário não recebe nenhum sinal de que a política é o motivo pelo qual seu servidor desapareceu, portanto informe aos usuários afetados quais servidores são bloqueados quando você implementar uma nova restrição.

Monitorar o uso de MCP

Quando exportação OpenTelemetry está configurada, Claude Code pode registrar quais servidores MCP e ferramentas os usuários invocam. Defina OTEL_LOG_TOOL_DETAILS=1 para incluir nomes de servidor MCP e ferramentas em eventos de ferramentas, depois agregue-os em seu coletor para ver quais servidores seus usuários realmente conectam. Consulte Monitoramento para configurar o exportador e para o esquema de evento completo.

Resumo de configuração

Cada arquivo e configuração que esta página aborda, o que controla e como entregá-lo:
SuperfícieO que controlaOnde ficaComo entregar
managed-mcp.jsonConjunto de servidor fixo, controle exclusivoCaminho do sistema: /Library/Application Support/ClaudeCode/, /etc/claude-code/, ou C:\Program Files\ClaudeCode\MDM, GPO, gerenciamento de frota ou qualquer processo com privilégios de administrador. Não pode ser definido através de configurações gerenciadas pelo servidor
allowedMcpServersLista de permissão de servidores permitidosQualquer arquivo de configurações; entradas de todas as fontes são mescladas a menos que allowManagedMcpServersOnly esteja definidoPara aplicação, uma fonte de configurações gerenciadas: configurações gerenciadas pelo servidor, managed-settings.json, perfil MDM ou registro
deniedMcpServersLista de bloqueio de servidores bloqueadosQualquer arquivo de configurações; entradas de todas as fontes são mescladasMesmo que allowedMcpServers
allowManagedMcpServersOnlyBloqueia a lista de permissão apenas para fontes gerenciadasApenas fontes de configurações gerenciadas; a configuração não tem efeito em outro lugarMesmo que allowedMcpServers

Recursos relacionados