Vai al contenuto principale

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.

Per impostazione predefinita, chiunque esegua Claude Code può connettere qualsiasi server MCP desideri. Anthropic esamina i connettori rispetto ai suoi criteri di elenco prima di aggiungerli alla Directory Anthropic, ma non esegue audit di sicurezza né gestisce alcun server MCP. Come amministratore, potete limitare quali server vengono eseguiti nella vostra organizzazione, da un set fisso approvato alla disabilitazione completa di MCP. Questa pagina spiega come:
La pagina Security copre il modello di minaccia MCP e come valutare un server prima di approvarlo. Decidere cosa applicare copre le restrizioni MCP insieme agli altri controlli amministrativi.

Scegliere un modello

Claude Code supporta una gamma di livelli di restrizione. Ogni modello utilizza uno o entrambi i meccanismi descritti di seguito: managed-mcp.json per distribuire un set fisso, e allowedMcpServers/deniedMcpServers per filtrare ciò che gli utenti configurano.
ModelloCosa faConfigurare
Disabilitare MCPNessun server viene caricato da nessuna partemanaged-mcp.json con una mappa di server vuota
Distribuzione fissaOgni utente ottiene gli stessi server e non può aggiungerne altrimanaged-mcp.json con i server desiderati
Catalogo approvatoPubblicare un elenco di server approvati; gli utenti aggiungono quelli che desiderano, tutto il resto viene bloccatoallowedMcpServers + allowManagedMcpServersOnly: true
Solo server pluginI server possono provenire solo da plugin; gli utenti non possono aggiungere i propristrictPluginOnlyCustomization con mcp nell’elenco
Allowlist softApplicare un allowlist che gli utenti possono ampliare nelle loro impostazioniallowedMcpServers senza allowManagedMcpServersOnly
Solo denylistBloccare i server noti come cattivi, consentire tutto il restodeniedMcpServers
Nessuna restrizioneGli utenti aggiungono qualsiasi cosaNon distribuire alcuna configurazione MCP gestita
Claude Code non dispone di un registro di server MCP integrato che gli utenti possono sfogliare e installare. Per il modello di catalogo approvato, condividete l’elenco approvato e i suoi comandi claude mcp add in un luogo dove i vostri utenti li troveranno, come un wiki interno, oppure distribuite i server come plugin attraverso un marketplace di plugin gestito in modo che gli utenti possano sfogliarli e installarli da /plugin.

Controllo esclusivo con managed-mcp.json

Se distribuite un file managed-mcp.json, Claude Code carica solo i server che quel file definisce. Gli utenti non possono aggiungere, modificare o utilizzare alcun altro server MCP, inclusi i server forniti da plugin e i connettori di claude.ai. Due altre impostazioni possono filtrare ulteriormente il set gestito:
  • allowedMcpServers e deniedMcpServers si applicano anche ai server gestiti, quindi un server gestito che non li supera non verrà caricato.
  • Il proprio deniedMcpServers di un utente si unisce dalle sue impostazioni, quindi gli utenti possono bloccare un server gestito per se stessi.
Vedere Come viene valutato un server per l’ordine completo dei controlli. managed-mcp.json è un file autonomo, quindi non può essere consegnato attraverso impostazioni gestite dal server. Qualsiasi processo che possa scrivere in un percorso di sistema con privilegi di amministratore può distribuirlo. Su larga scala, di solito avviene attraverso strumenti di gestione dei dispositivi, come Jamf o un profilo di configurazione su macOS, Criteri di gruppo o Intune su Windows, o la gestione della flotta di vostra scelta su Linux. Claude Code cerca il file in uno di questi percorsi:
PiattaformaPercorso
macOS/Library/Application Support/ClaudeCode/managed-mcp.json
Linux e WSL/etc/claude-code/managed-mcp.json
WindowsC:\Program Files\ClaudeCode\managed-mcp.json
Il file utilizza lo stesso formato di un file di progetto .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"
      }
    }
  }
}

Autenticarsi con credenziali per utente

Qualsiasi utente sulla macchina può leggere questo file, quindi non archiviate chiavi API o altre credenziali nei blocchi env. Passate le credenziali per utente con uno di questi:

Convalidare la configurazione

Per confermare che il file è in vigore, eseguite due controlli su una macchina gestita:
  1. claude mcp list mostra solo i server in managed-mcp.json. Se i server personali di un utente appaiono ancora, il file non viene letto; controllate il percorso e i permessi.
  2. claude mcp add --transport http test https://example.com/mcp fallisce con Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers. L’URL non deve essere un server reale, poiché il controllo della politica rifiuta il comando prima che qualsiasi cosa venga contattata.

Disabilitare completamente MCP

Distribuite un managed-mcp.json contenente una mappa di server vuota per bloccare ogni server MCP:
{
  "mcpServers": {}
}
Gli utenti non vedono alcun server MCP in /mcp, e claude mcp add fallisce con l’errore di politica aziendale di cui sopra. I server che gli utenti avevano precedentemente configurato smettono di caricarsi la prossima volta che avviano una sessione, senza alcun avviso che la politica è il motivo.

Controllo basato su politica con allowlist e denylist

Le allowlist e le denylist filtrano quali server configurati sono autorizzati a caricarsi. Non sono un registro: un server deve comunque essere aggiunto da un utente, un plugin o managed-mcp.json prima che l’allowlist o la denylist si applichino ad esso. Per distribuire server agli utenti, utilizzate managed-mcp.json. Per rendere l’allowlist autorevole, impostate allowedMcpServers e allowManagedMcpServersOnly: true insieme in una fonte di impostazioni gestite, come impostazioni gestite dal server o un file managed-settings.json distribuito. Limitare l’allowlist solo alle impostazioni gestite mostra la configurazione. Senza allowManagedMcpServersOnly, le allowlist da ogni fonte di impostazioni si uniscono, incluso il ~/.claude/settings.json personale di un utente, quindi un utente può ampliare ciò che la vostra allowlist consente. Le denylist si uniscono da ogni fonte indipendentemente.
allowManagedMcpServersOnly è separato da allowManagedPermissionRulesOnly, che blocca solo le regole di autorizzazione. L’impostazione di quel flag non applica l’allowlist MCP.

Abbinare i server per URL, comando o nome

allowedMcpServers e deniedMcpServers sono elenchi di voci. Ogni voce è un oggetto con una singola chiave che identifica i server per il loro URL, il loro comando o il loro nome:
ChiaveCorrisponde aUsare per
serverUrlUn URL di server remoto, esatto o con caratteri jolly *Server HTTP e SSE
serverCommandIl comando esatto e gli argomenti che avviano un server stdioServer stdio
serverNameL’etichetta assegnata dall’utente. Solo corrispondenza esatta; i caratteri jolly non vengono espansiEntrambi i tipi, ma vedere l’Avvertenza di seguito
Lasciare allowedMcpServers non impostato è diverso dall’impostarlo su un array vuoto:
ImpostazioneNon impostato (predefinito)Array vuoto []Popolato
allowedMcpServersTutti i server consentitiNessun server consentitoSolo i server corrispondenti consentiti
deniedMcpServersNessun server bloccatoNessun server bloccatoServer corrispondenti bloccati
Un allowlist che utilizza solo voci serverName non è un controllo di sicurezza. Il nome è l’etichetta che un utente assegna quando esegue claude mcp add o modifica un file di configurazione, non il server sottostante, quindi un utente può chiamare qualsiasi server github. Per applicare quali server vengono effettivamente eseguiti, aggiungete voci serverCommand o serverUrl.

Come viene valutato un server

Prima di caricare un server, incluso uno da managed-mcp.json, Claude Code esegue tre controlli in ordine:
  1. Unire gli elenchi. Le voci di allowlist e denylist da ogni fonte di impostazioni si combinano in un allowlist e una denylist. Quando allowManagedMcpServersOnly è true, viene mantenuto solo l’allowlist gestito; la denylist si unisce sempre da ogni fonte.
  2. Controllare la denylist. Un server che corrisponde a qualsiasi voce di denylist, per URL, comando o nome, viene bloccato. Nulla sostituisce una corrispondenza di denylist.
  3. Controllare l’allowlist. Se allowedMcpServers non è impostato da nessuna parte, ogni server che ha superato la denylist viene caricato. Se è impostato, ciò a cui il server deve corrispondere dipende dal suo tipo, mostrato nella tabella di seguito.
Tipo di serverConsentito quando corrisponde a
Remoto (HTTP o SSE)Una voce serverUrl. Una corrispondenza serverName conta solo quando l’allowlist non contiene voci serverUrl
StdioUna voce serverCommand. Una corrispondenza serverName conta solo quando l’allowlist non contiene voci serverCommand
Due regole di corrispondenza si applicano all’interno di questi controlli:
  • I comandi corrispondono esattamente. Ogni argomento, in ordine. ["npx", "-y", "server"] non corrisponde a ["npx", "server"] o ["npx", "-y", "server", "--flag"].
  • Gli URL supportano caratteri jolly * ovunque nel modello, incluso lo schema. La corrispondenza del nome host non distingue tra maiuscole e minuscole e ignora un punto FQDN finale, quindi https://Mcp.Example.com/* corrisponde a https://mcp.example.com/api. I percorsi rimangono sensibili alle maiuscole.
ModelloConsente
https://mcp.example.com/*Tutti i percorsi su un dominio specifico
https://mcp.example.comAnche tutti i percorsi su quel dominio. Un modello senza percorso corrisponde a qualsiasi percorso
https://*.example.com/*Qualsiasi sottodominio di example.com
http://localhost:*/*Qualsiasi porta su localhost
*://mcp.example.com/*Qualsiasi schema a un dominio specifico

Configurazione di esempio

La configurazione di seguito configura un allowlist rigido con una denylist. Le righe evidenziate cambiano il modo in cui il resto dell’elenco viene valutato, e i callout dopo il blocco spiegano ognuno:
{
  "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/*" }
  ]
}
  • Riga 3: la prima voce serverUrl. Una volta che ne esiste una, ogni server remoto deve corrispondere a un modello di URL, quindi un utente non può ottenere un server remoto non elencato dandogli un nome consentito.
  • Riga 5: la prima voce serverCommand. Lo stesso effetto per i server stdio, quindi ogni server locale deve corrispondere esattamente a un comando elencato.
  • Riga 11: una voce serverName nella denylist. Le voci di denylist si applicano sempre, quindi qualsiasi server denominato dangerous-server viene bloccato indipendentemente dal suo URL o comando.
Una voce serverName in questo allowlist non corrisponderebbe mai a nulla, poiché entrambi i tipi di trasporto hanno già voci più rigorose. Gli accordion di seguito illustrano come un server viene valutato rispetto ad altre combinazioni di allowlist e denylist.
{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}
ServerRisultato
Server HTTP a https://mcp.example.com/apiConsentito: corrisponde al modello di URL
Server HTTP a https://api.internal.example.com/mcpConsentito: corrisponde al sottodominio con carattere jolly
Server HTTP a https://external.example.com/mcpBloccato: non corrisponde a nessun modello di URL
Server stdio con qualsiasi comandoBloccato: nessuna voce di nome o comando a cui corrispondere
{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
ServerRisultato
Server stdio con ["npx", "-y", "approved-package"]Consentito: corrisponde al comando
Server stdio con ["node", "server.js"]Bloccato: non corrisponde al comando
Server HTTP denominato my-apiBloccato: nessuna voce di nome a cui corrispondere
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
ServerRisultato
Server stdio denominato local-tool con ["npx", "-y", "approved-package"]Consentito: corrisponde al comando
Server stdio denominato local-tool con ["node", "server.js"]Bloccato: le voci di comando esistono ma non corrisponde
Server stdio denominato github con ["node", "server.js"]Bloccato: i server stdio devono corrispondere ai comandi quando le voci di comando esistono
Server HTTP denominato githubConsentito: corrisponde al nome
Server HTTP denominato other-apiBloccato: il nome non corrisponde
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}
ServerRisultato
Server stdio denominato github con qualsiasi comandoConsentito: nessuna restrizione di comando
Server stdio denominato internal-tool con qualsiasi comandoConsentito: nessuna restrizione di comando
Server HTTP denominato githubConsentito: corrisponde al nome
Qualsiasi server denominato otherBloccato: il nome non corrisponde
{
  "allowedMcpServers": [
    { "serverUrl": "https://*.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://staging.example.com/*" }
  ]
}
ServerRisultato
Server HTTP a https://mcp.example.com/apiConsentito: corrisponde al modello di URL dell’allowlist, nessuna corrispondenza di denylist
Server HTTP a https://staging.example.com/apiBloccato: corrisponde a entrambi, ma la denylist ha la precedenza
Server HTTP a https://other.com/mcpBloccato: non corrisponde all’allowlist

Limitare l’allowlist solo alle impostazioni gestite

Per rendere l’allowlist gestito l’unico che si applica, impostate allowManagedMcpServersOnly nel file di impostazioni gestite:
{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}
Quando allowManagedMcpServersOnly è true, le allowlist dalle impostazioni di utente, progetto e locale vengono ignorate. La denylist si unisce comunque da tutte le fonti, quindi gli utenti possono sempre bloccare i server per se stessi.

Come le restrizioni appaiono agli utenti

Quando una restrizione blocca un server, l’utente vede un errore da claude mcp add o il server smette silenziosamente di caricarsi. Utilizzate questa tabella per riconoscere questi rapporti e per comunicare agli utenti cosa aspettarsi prima di implementare una modifica:
RestrizioneCosa vede l’utente
managed-mcp.json è presente e l’utente esegue claude mcp addCannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers
Il server è su una denylist e l’utente esegue claude mcp addCannot add MCP server "<name>": server is explicitly blocked by enterprise policy
Il server non è sull’allowlist e l’utente esegue claude mcp addCannot add MCP server "<name>": not allowed by enterprise policy
Un server precedentemente configurato è ora bloccato dalla politicaIl server scompare silenziosamente da /mcp e claude mcp list senza avviso
Nell’ultimo caso, l’utente non riceve alcun segnale che la politica è il motivo per cui il suo server è scomparso, quindi comunicate agli utenti interessati quali server sono bloccati quando implementate una nuova restrizione.

Monitorare l’utilizzo di MCP

Quando l’esportazione OpenTelemetry è configurata, Claude Code può registrare quali server MCP e strumenti gli utenti invocano. Impostate OTEL_LOG_TOOL_DETAILS=1 per includere i nomi dei server MCP e degli strumenti negli eventi degli strumenti, quindi aggregateli nel vostro collector per vedere quali server i vostri utenti effettivamente connettono. Vedere Monitoraggio per configurare l’esportatore e per lo schema completo degli eventi.

Riepilogo della configurazione

Ogni file e impostazione che questa pagina copre, cosa controlla e come consegnarlo:
SuperficieCosa controllaDove si trovaCome consegnare
managed-mcp.jsonSet di server fisso, controllo esclusivoPercorso di sistema: /Library/Application Support/ClaudeCode/, /etc/claude-code/, o C:\Program Files\ClaudeCode\MDM, GPO, gestione della flotta, o qualsiasi processo con privilegi di amministratore. Non può essere impostato attraverso impostazioni gestite dal server
allowedMcpServersAllowlist di server consentitiQualsiasi file di impostazioni; le voci da ogni fonte si uniscono a meno che allowManagedMcpServersOnly non sia impostatoPer l’applicazione, una fonte di impostazioni gestite: impostazioni gestite dal server, managed-settings.json, profilo MDM, o registro
deniedMcpServersDenylist di server bloccatiQualsiasi file di impostazioni; le voci da ogni fonte si unisconoUguale a allowedMcpServers
allowManagedMcpServersOnlyBlocca l’allowlist solo alle fonti gestiteSolo fonti di impostazioni gestite; l’impostazione non ha effetto altroveUguale a allowedMcpServers

Risorse correlate