Vai al contenuto principale
Claude Code può connettersi a centinaia di strumenti e fonti di dati esterni attraverso il Model Context Protocol (MCP), uno standard open source per le integrazioni AI-tool. I server MCP danno a Claude Code accesso ai tuoi strumenti, database e API.

​
Cosa puoi fare con MCP

Con i server MCP connessi, puoi chiedere a Claude Code di:
  • Implementare funzionalità da issue tracker: “Aggiungi la funzionalità descritta nel ticket JIRA ENG-4521 e crea una PR su GitHub.”
  • Analizzare dati di monitoraggio: “Controlla Sentry e Statsig per verificare l’utilizzo della funzionalità descritta in ENG-4521.”
  • Interrogare database: “Trova gli indirizzi email di 10 utenti casuali che hanno utilizzato la funzionalità ENG-4521, in base al nostro database PostgreSQL.”
  • Integrare design: “Aggiorna il nostro modello di email standard in base ai nuovi design Figma che sono stati pubblicati su Slack”
  • Automatizzare flussi di lavoro: “Crea bozze Gmail invitando questi 10 utenti a una sessione di feedback sulla nuova funzionalità.”
  • Reagire a eventi esterni: Un server MCP può anche agire come un canale che invia messaggi nella tua sessione, in modo che Claude reagisca ai messaggi Telegram, chat Discord o eventi webhook mentre sei assente.

​
Server MCP popolari

Ecco alcuni server MCP comunemente utilizzati che puoi connettere a Claude Code:
Utilizza server MCP di terze parti a tuo rischio - Anthropic non ha verificato la correttezza o la sicurezza di tutti questi server. Assicurati di fidarti dei server MCP che stai installando. Fai particolare attenzione quando utilizzi server MCP che potrebbero recuperare contenuti non attendibili, poiché questi possono esporti al rischio di prompt injection.
Hai bisogno di un’integrazione specifica? Trova centinaia di altri server MCP su GitHub, oppure crea il tuo utilizzando l’MCP SDK.

​
Installazione dei server MCP

I server MCP possono essere configurati in tre modi diversi a seconda delle tue esigenze:

​
Opzione 1: Aggiungi un server HTTP remoto

I server HTTP sono l’opzione consigliata per connettersi ai server MCP remoti. Questo è il trasporto più ampiamente supportato per i servizi basati su cloud. 
# Sintassi di base
claude mcp add --transport http <name> <url>

# Esempio reale: Connessione a Notion
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Esempio con token Bearer
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

​
Opzione 2: Aggiungi un server SSE remoto

Il trasporto SSE (Server-Sent Events) è deprecato. Utilizza server HTTP invece, dove disponibili.
# Sintassi di base
claude mcp add --transport sse <name> <url>

# Esempio reale: Connessione ad Asana
claude mcp add --transport sse asana https://mcp.asana.com/sse

# Esempio con header di autenticazione
claude mcp add --transport sse private-api https://api.company.com/sse \
  --header "X-API-Key: your-key-here"

​
Opzione 3: Aggiungi un server stdio locale

I server stdio vengono eseguiti come processi locali sulla tua macchina. Sono ideali per strumenti che necessitano di accesso diretto al sistema o script personalizzati. 
# Sintassi di base
claude mcp add [options] <name> -- <command> [args...]

# Esempio reale: Aggiungi server Airtable
claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \
  -- npx -y airtable-mcp-server
Importante: Ordine delle opzioniTutte le opzioni (--transport, --env, --scope, --header) devono venire prima del nome del server. Il -- (doppio trattino) separa quindi il nome del server dal comando e dagli argomenti che vengono passati al server MCP.Per esempio:
  • claude mcp add --transport stdio myserver -- npx server → esegue npx server
  • claude mcp add --transport stdio --env KEY=value myserver -- python server.py --port 8080 → esegue python server.py --port 8080 con KEY=value nell’ambiente
Questo previene conflitti tra i flag di Claude e i flag del server.

​
Gestione dei tuoi server

Una volta configurati, puoi gestire i tuoi server MCP con questi comandi: 
# Elenca tutti i server configurati
claude mcp list

# Ottieni dettagli per un server specifico
claude mcp get github

# Rimuovi un server
claude mcp remove github

# (all'interno di Claude Code) Controlla lo stato del server
/mcp

​
Aggiornamenti dinamici degli strumenti

Claude Code supporta le notifiche list_changed di MCP, consentendo ai server MCP di aggiornare dinamicamente i loro strumenti, prompt e risorse disponibili senza richiedere di disconnettersi e riconnettersi. Quando un server MCP invia una notifica list_changed, Claude Code aggiorna automaticamente le capacità disponibili da quel server.

​
Invia messaggi con canali

Un server MCP può anche inviare messaggi direttamente nella tua sessione in modo che Claude possa reagire a eventi esterni come risultati CI, avvisi di monitoraggio o messaggi di chat. Per abilitare questa funzionalità, il tuo server dichiara la capacità claude/channel e tu la abiliti con il flag --channels all’avvio. Vedi Canali per utilizzare un canale ufficialmente supportato, oppure Riferimento canali per costruire il tuo.
Suggerimenti:
  • Utilizza il flag --scope per specificare dove viene archiviata la configurazione:
    • local (predefinito): Disponibile solo per te nel progetto corrente (era chiamato project nelle versioni precedenti)
    • project: Condiviso con tutti nel progetto tramite il file .mcp.json
    • user: Disponibile per te in tutti i progetti (era chiamato global nelle versioni precedenti)
  • Imposta le variabili di ambiente con i flag --env (per esempio, --env KEY=value)
  • Configura il timeout di avvio del server MCP utilizzando la variabile di ambiente MCP_TIMEOUT (per esempio, MCP_TIMEOUT=10000 claude imposta un timeout di 10 secondi)
  • Claude Code visualizzerà un avviso quando l’output dello strumento MCP supera 10.000 token. Per aumentare questo limite, imposta la variabile di ambiente MAX_MCP_OUTPUT_TOKENS (per esempio, MAX_MCP_OUTPUT_TOKENS=50000)
  • Utilizza /mcp per autenticarti con server remoti che richiedono l’autenticazione OAuth 2.0
Utenti Windows: Su Windows nativo (non WSL), i server MCP locali che utilizzano npx richiedono il wrapper cmd /c per garantire l’esecuzione corretta.
# Questo crea command="cmd" che Windows può eseguire
claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package
Senza il wrapper cmd /c, incontrerai errori “Connection closed” perché Windows non può eseguire direttamente npx. (Vedi la nota sopra per una spiegazione del parametro --.)

​
Server MCP forniti da plugin

I plugin possono raggruppare server MCP, fornendo automaticamente strumenti e integrazioni quando il plugin è abilitato. I server MCP dei plugin funzionano in modo identico ai server configurati dall’utente. Come funzionano i server MCP dei plugin:
  • I plugin definiscono i server MCP in .mcp.json nella radice del plugin o inline in plugin.json
  • Quando un plugin è abilitato, i suoi server MCP si avviano automaticamente
  • Gli strumenti MCP del plugin appaiono insieme agli strumenti MCP configurati manualmente
  • I server dei plugin vengono gestiti tramite l’installazione del plugin (non tramite comandi /mcp)
Esempio di configurazione MCP del plugin: In .mcp.json nella radice del plugin: 
{
  "mcpServers": {
    "database-tools": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
      "env": {
        "DB_URL": "${DB_URL}"
      }
    }
  }
}
O inline in plugin.json: 
{
  "name": "my-plugin",
  "mcpServers": {
    "plugin-api": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/api-server",
      "args": ["--port", "8080"]
    }
  }
}
Funzionalità MCP del plugin:
  • Ciclo di vita automatico: All’avvio della sessione, i server per i plugin abilitati si connettono automaticamente. Se abiliti o disabiliti un plugin durante una sessione, esegui /reload-plugins per connettere o disconnettere i suoi server MCP
  • Variabili di ambiente: Utilizza ${CLAUDE_PLUGIN_ROOT} per i file del plugin raggruppati e ${CLAUDE_PLUGIN_DATA} per lo stato persistente che sopravvive agli aggiornamenti del plugin
  • Accesso alle variabili di ambiente dell’utente: Accesso alle stesse variabili di ambiente dei server configurati manualmente
  • Tipi di trasporto multipli: Supporto per trasporti stdio, SSE e HTTP (il supporto del trasporto può variare a seconda del server)
Visualizzazione dei server MCP del plugin: 
# All'interno di Claude Code, vedi tutti i server MCP inclusi quelli dei plugin
/mcp
I server dei plugin appaiono nell’elenco con indicatori che mostrano che provengono dai plugin. Vantaggi dei server MCP dei plugin:
  • Distribuzione raggruppata: Strumenti e server confezionati insieme
  • Configurazione automatica: Nessuna configurazione MCP manuale necessaria
  • Coerenza del team: Tutti ottengono gli stessi strumenti quando il plugin è installato
Vedi il riferimento dei componenti del plugin per i dettagli su come raggruppare i server MCP con i plugin.

​
Ambiti di installazione MCP

I server MCP possono essere configurati a tre diversi livelli di ambito, ognuno dei quali serve scopi distinti per gestire l’accessibilità e la condivisione dei server. Comprendere questi ambiti ti aiuta a determinare il modo migliore per configurare i server per le tue esigenze specifiche.

​
Ambito locale

I server con ambito locale rappresentano il livello di configurazione predefinito e vengono archiviati in ~/.claude.json nel percorso del tuo progetto. Questi server rimangono privati per te e sono accessibili solo quando lavori all’interno della directory del progetto corrente. Questo ambito è ideale per server di sviluppo personali, configurazioni sperimentali o server contenenti credenziali sensibili che non dovrebbero essere condivise.
Il termine “ambito locale” per i server MCP differisce dalle impostazioni locali generali. I server MCP con ambito locale vengono archiviati in ~/.claude.json (la tua directory home), mentre le impostazioni locali generali utilizzano .claude/settings.local.json (nella directory del progetto). Vedi Impostazioni per i dettagli sui percorsi dei file di impostazioni.
# Aggiungi un server con ambito locale (predefinito)
claude mcp add --transport http stripe https://mcp.stripe.com

# Specifica esplicitamente l'ambito locale
claude mcp add --transport http stripe --scope local https://mcp.stripe.com

​
Ambito del progetto

I server con ambito del progetto abilitano la collaborazione del team archiviando le configurazioni in un file .mcp.json nella directory radice del tuo progetto. Questo file è progettato per essere archiviato nel controllo della versione, assicurando che tutti i membri del team abbiano accesso agli stessi strumenti e servizi MCP. Quando aggiungi un server con ambito del progetto, Claude Code crea o aggiorna automaticamente questo file con la struttura di configurazione appropriata. 
# Aggiungi un server con ambito del progetto
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
Il file .mcp.json risultante segue un formato standardizzato: 
{
  "mcpServers": {
    "shared-server": {
      "command": "/path/to/server",
      "args": [],
      "env": {}
    }
  }
}
Per motivi di sicurezza, Claude Code richiede l’approvazione prima di utilizzare server con ambito del progetto dai file .mcp.json. Se devi ripristinare queste scelte di approvazione, utilizza il comando claude mcp reset-project-choices.

​
Ambito utente

I server con ambito utente vengono archiviati in ~/.claude.json e forniscono accessibilità tra progetti, rendendoli disponibili in tutti i progetti sulla tua macchina mentre rimangono privati al tuo account utente. Questo ambito funziona bene per server di utilità personali, strumenti di sviluppo o servizi che utilizzi frequentemente in diversi progetti. 
# Aggiungi un server utente
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic

​
Scelta dell’ambito giusto

Seleziona il tuo ambito in base a:
  • Ambito locale: Server personali, configurazioni sperimentali o credenziali sensibili specifici di un progetto
  • Ambito del progetto: Server condivisi dal team, strumenti specifici del progetto o servizi necessari per la collaborazione
  • Ambito utente: Utilità personali necessarie in più progetti, strumenti di sviluppo o servizi utilizzati frequentemente
Dove vengono archiviati i server MCP?
  • Ambito utente e locale: ~/.claude.json (nel campo mcpServers o nei percorsi del progetto)
  • Ambito del progetto: .mcp.json nella radice del tuo progetto (archiviato nel controllo della versione)
  • Gestito: managed-mcp.json nelle directory di sistema (vedi Configurazione MCP gestita)

​
Gerarchia e precedenza dell’ambito

Le configurazioni del server MCP seguono una chiara gerarchia di precedenza. Quando server con lo stesso nome esistono in più ambiti, il sistema risolve i conflitti dando priorità ai server con ambito locale per primi, seguiti dai server con ambito del progetto e infine dai server con ambito utente. Questo design assicura che le configurazioni personali possano sovrascrivere quelle condivise quando necessario.

​
Espansione delle variabili di ambiente in .mcp.json

Claude Code supporta l’espansione delle variabili di ambiente nei file .mcp.json, consentendo ai team di condividere configurazioni mantenendo flessibilità per i percorsi specifici della macchina e i valori sensibili come le chiavi API. Sintassi supportata:
  • ${VAR} - Si espande al valore della variabile di ambiente VAR
  • ${VAR:-default} - Si espande a VAR se impostato, altrimenti utilizza default
Posizioni di espansione: Le variabili di ambiente possono essere espanse in:
  • command - Il percorso dell’eseguibile del server
  • args - Argomenti della riga di comando
  • env - Variabili di ambiente passate al server
  • url - Per i tipi di server HTTP
  • headers - Per l’autenticazione del server HTTP
Esempio con espansione di variabili: 
{
  "mcpServers": {
    "api-server": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "Authorization": "Bearer ${API_KEY}"
      }
    }
  }
}
Se una variabile di ambiente richiesta non è impostata e non ha un valore predefinito, Claude Code non riuscirà ad analizzare la configurazione.

​
Esempi pratici

​
Esempio: Monitora gli errori con Sentry

claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
Autenticati con il tuo account Sentry: 
/mcp
Quindi esegui il debug dei problemi di produzione: 
Quali sono gli errori più comuni nelle ultime 24 ore?

Mostrami la stack trace per l'errore ID abc123

Quale deployment ha introdotto questi nuovi errori?

​
Esempio: Connettiti a GitHub per le revisioni del codice

claude mcp add --transport http github https://api.githubcopilot.com/mcp/
Autenticati se necessario selezionando “Authenticate” per GitHub: 
/mcp
Quindi lavora con GitHub: 
Rivedi la PR #456 e suggerisci miglioramenti

Crea un nuovo issue per il bug che abbiamo appena trovato

Mostrami tutte le PR aperte assegnate a me

​
Esempio: Interroga il tuo database PostgreSQL

claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
  --dsn "postgresql://readonly:[email protected]:5432/analytics"
Quindi interroga il tuo database naturalmente: 
Qual è il nostro ricavo totale questo mese?

Mostrami lo schema per la tabella orders

Trova i clienti che non hanno effettuato un acquisto negli ultimi 90 giorni

​
Autenticazione con server MCP remoti

Molti server MCP basati su cloud richiedono l’autenticazione. Claude Code supporta OAuth 2.0 per connessioni sicure.
1

Aggiungi il server che richiede l'autenticazione

Per esempio:
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
2

Utilizza il comando /mcp all'interno di Claude Code

In Claude Code, utilizza il comando:
/mcp
Quindi segui i passaggi nel tuo browser per accedere.
Suggerimenti:
  • I token di autenticazione vengono archiviati in modo sicuro e aggiornati automaticamente
  • Utilizza “Clear authentication” nel menu /mcp per revocare l’accesso
  • Se il tuo browser non si apre automaticamente, copia l’URL fornito e aprilo manualmente
  • Se il reindirizzamento del browser non riesce con un errore di connessione dopo l’autenticazione, incolla l’URL di callback completo dalla barra degli indirizzi del tuo browser nel prompt dell’URL che appare in Claude Code
  • L’autenticazione OAuth funziona con i server HTTP

​
Utilizza una porta di callback OAuth fissa

Alcuni server MCP richiedono un URI di reindirizzamento specifico registrato in anticipo. Per impostazione predefinita, Claude Code sceglie una porta disponibile casuale per il callback OAuth. Utilizza --callback-port per fissare la porta in modo che corrisponda a un URI di reindirizzamento pre-registrato della forma http://localhost:PORT/callback. Puoi utilizzare --callback-port da solo (con registrazione dinamica del client) o insieme a --client-id (con credenziali pre-configurate). 
# Porta di callback fissa con registrazione dinamica del client
claude mcp add --transport http \
  --callback-port 8080 \
  my-server https://mcp.example.com/mcp

​
Utilizza credenziali OAuth pre-configurate

Alcuni server MCP non supportano la configurazione OAuth automatica tramite Dynamic Client Registration. Se vedi un errore come “Incompatible auth server: does not support dynamic client registration,” il server richiede credenziali pre-configurate. Claude Code supporta anche server che utilizzano un Client ID Metadata Document (CIMD) invece di Dynamic Client Registration e li scopre automaticamente. Se la scoperta automatica non riesce, registra prima un’app OAuth tramite il portale degli sviluppatori del server, quindi fornisci le credenziali quando aggiungi il server.
1

Registra un'app OAuth con il server

Crea un’app tramite il portale degli sviluppatori del server e annota il tuo ID client e il segreto client.Molti server richiedono anche un URI di reindirizzamento. Se è così, scegli una porta e registra un URI di reindirizzamento nel formato http://localhost:PORT/callback. Utilizza quella stessa porta con --callback-port nel passaggio successivo.
2

Aggiungi il server con le tue credenziali

Scegli uno dei seguenti metodi. La porta utilizzata per --callback-port può essere qualsiasi porta disponibile. Deve solo corrispondere all’URI di reindirizzamento che hai registrato nel passaggio precedente.
Utilizza --client-id per passare l’ID client della tua app. Il flag --client-secret richiede il segreto con input mascherato:
claude mcp add --transport http \
  --client-id your-client-id --client-secret --callback-port 8080 \
  my-server https://mcp.example.com/mcp
3

Autenticati in Claude Code

Esegui /mcp in Claude Code e segui il flusso di accesso del browser.
Suggerimenti:
  • Il segreto client viene archiviato in modo sicuro nel tuo portachiavi di sistema (macOS) o in un file di credenziali, non nella tua configurazione
  • Se il server utilizza un client OAuth pubblico senza segreto, utilizza solo --client-id senza --client-secret
  • --callback-port può essere utilizzato con o senza --client-id
  • Questi flag si applicano solo ai trasporti HTTP e SSE. Non hanno effetto sui server stdio
  • Utilizza claude mcp get <name> per verificare che le credenziali OAuth siano configurate per un server

​
Sovrascrivi la scoperta dei metadati OAuth

Se il tuo server MCP restituisce errori sull’endpoint dei metadati OAuth standard (/.well-known/oauth-authorization-server) ma espone un endpoint OIDC funzionante, puoi dire a Claude Code di recuperare i metadati OAuth direttamente da un URL che specifichi, bypassando la catena di scoperta standard. Imposta authServerMetadataUrl nell’oggetto oauth della configurazione del tuo server in .mcp.json: 
{
  "mcpServers": {
    "my-server": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "oauth": {
        "authServerMetadataUrl": "https://auth.example.com/.well-known/openid-configuration"
      }
    }
  }
}
L’URL deve utilizzare https://. Questa opzione richiede Claude Code v2.1.64 o successiva.

​
Utilizza intestazioni dinamiche per l’autenticazione personalizzata

Se il tuo server MCP utilizza uno schema di autenticazione diverso da OAuth (come Kerberos, token di breve durata o un SSO interno), utilizza headersHelper per generare intestazioni di richiesta al momento della connessione. Claude Code esegue il comando e unisce il suo output alle intestazioni di connessione. 
{
  "mcpServers": {
    "internal-api": {
      "type": "http",
      "url": "https://mcp.internal.example.com",
      "headersHelper": "/opt/bin/get-mcp-auth-headers.sh"
    }
  }
}
Il comando può anche essere inline: 
{
  "mcpServers": {
    "internal-api": {
      "type": "http",
      "url": "https://mcp.internal.example.com",
      "headersHelper": "echo '{\"Authorization\": \"Bearer '\"$(get-token)\"'\"}'"
    }
  }
}
Requisiti:
  • Il comando deve scrivere un oggetto JSON di coppie chiave-valore stringa su stdout
  • Il comando viene eseguito in una shell con un timeout di 10 secondi
  • Le intestazioni dinamiche sovrascrivono qualsiasi headers statico con lo stesso nome
L’helper viene eseguito di nuovo ad ogni connessione (all’avvio della sessione e alla riconnessione). Non c’è caching, quindi il tuo script è responsabile di qualsiasi riutilizzo di token.
headersHelper esegue comandi shell arbitrari. Quando definito a livello di progetto o locale, viene eseguito solo dopo che accetti la finestra di dialogo di fiducia dell’area di lavoro.

​
Aggiungi server MCP dalla configurazione JSON

Se hai una configurazione JSON per un server MCP, puoi aggiungerla direttamente:
1

Aggiungi un server MCP da JSON

# Sintassi di base
claude mcp add-json <name> '<json>'

# Esempio: Aggiunta di un server HTTP con configurazione JSON
claude mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}'

# Esempio: Aggiunta di un server stdio con configurazione JSON
claude mcp add-json local-weather '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}'

# Esempio: Aggiunta di un server HTTP con credenziali OAuth pre-configurate
claude mcp add-json my-server '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' --client-secret
2

Verifica che il server sia stato aggiunto

claude mcp get weather-api
Suggerimenti:
  • Assicurati che il JSON sia correttamente sfuggito nella tua shell
  • Il JSON deve conformarsi allo schema di configurazione del server MCP
  • Puoi utilizzare --scope user per aggiungere il server alla tua configurazione utente invece di quella specifica del progetto

​
Importa server MCP da Claude Desktop

Se hai già configurato server MCP in Claude Desktop, puoi importarli:
1

Importa server da Claude Desktop

# Sintassi di base 
claude mcp add-from-claude-desktop
2

Seleziona quali server importare

Dopo aver eseguito il comando, vedrai una finestra di dialogo interattiva che ti consente di selezionare quali server desideri importare.
3

Verifica che i server siano stati importati

claude mcp list
Suggerimenti:
  • Questa funzionalità funziona solo su macOS e Windows Subsystem for Linux (WSL)
  • Legge il file di configurazione di Claude Desktop dalla sua posizione standard su quelle piattaforme
  • Utilizza il flag --scope user per aggiungere server alla tua configurazione utente
  • I server importati avranno gli stessi nomi di Claude Desktop
  • Se server con gli stessi nomi esistono già, riceveranno un suffisso numerico (per esempio, server_1)

​
Utilizza server MCP da Claude.ai

Se hai effettuato l’accesso a Claude Code con un account Claude.ai, i server MCP che hai aggiunto in Claude.ai sono automaticamente disponibili in Claude Code:
1

Configura server MCP in Claude.ai

Aggiungi server su claude.ai/settings/connectors. Nei piani Team ed Enterprise, solo gli amministratori possono aggiungere server.
2

Autentica il server MCP

Completa eventuali passaggi di autenticazione richiesti in Claude.ai.
3

Visualizza e gestisci i server in Claude Code

In Claude Code, utilizza il comando:
/mcp
I server Claude.ai appaiono nell’elenco con indicatori che mostrano che provengono da Claude.ai.
Per disabilitare i server MCP di claude.ai in Claude Code, imposta la variabile di ambiente ENABLE_CLAUDEAI_MCP_SERVERS su false: 
ENABLE_CLAUDEAI_MCP_SERVERS=false claude

​
Utilizza Claude Code come server MCP

Puoi utilizzare Claude Code stesso come server MCP a cui altre applicazioni possono connettersi: 
# Avvia Claude come server MCP stdio
claude mcp serve
Puoi utilizzarlo in Claude Desktop aggiungendo questa configurazione a claude_desktop_config.json: 
{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}
Configurazione del percorso dell’eseguibile: Il campo command deve fare riferimento all’eseguibile di Claude Code. Se il comando claude non è nel PATH del tuo sistema, dovrai specificare il percorso completo dell’eseguibile.Per trovare il percorso completo:
which claude
Quindi utilizza il percorso completo nella tua configurazione:
{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "/full/path/to/claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}
Senza il percorso dell’eseguibile corretto, incontrerai errori come spawn claude ENOENT.
Suggerimenti:
  • Il server fornisce accesso agli strumenti di Claude come View, Edit, LS, ecc.
  • In Claude Desktop, prova a chiedere a Claude di leggere file in una directory, fare modifiche e altro ancora.
  • Nota che questo server MCP sta solo esponendo gli strumenti di Claude Code al tuo client MCP, quindi il tuo client è responsabile dell’implementazione della conferma dell’utente per le singole chiamate di strumenti.

​
Limiti di output MCP e avvisi

Quando gli strumenti MCP producono output di grandi dimensioni, Claude Code aiuta a gestire l’utilizzo dei token per evitare di sovraccaricare il contesto della tua conversazione:
  • Soglia di avviso di output: Claude Code visualizza un avviso quando l’output di qualsiasi strumento MCP supera 10.000 token
  • Limite configurabile: Puoi regolare il massimo di token di output MCP consentiti utilizzando la variabile di ambiente MAX_MCP_OUTPUT_TOKENS
  • Limite predefinito: Il massimo predefinito è 25.000 token
Per aumentare il limite per gli strumenti che producono output di grandi dimensioni: 
# Imposta un limite più alto per gli output degli strumenti MCP
export MAX_MCP_OUTPUT_TOKENS=50000
claude
Questo è particolarmente utile quando si lavora con server MCP che:
  • Interrogano grandi set di dati o database
  • Generano report o documentazione dettagliati
  • Elaborano file di log estesi o informazioni di debug
Se incontri frequentemente avvisi di output con server MCP specifici, considera di aumentare il limite o configurare il server per impaginare o filtrare le sue risposte.

​
Rispondi alle richieste di elicitazione MCP

I server MCP possono richiedere input strutturato da te durante un’attività utilizzando l’elicitazione. Quando un server ha bisogno di informazioni che non può ottenere da solo, Claude Code visualizza una finestra di dialogo interattiva e passa la tua risposta al server. Non è richiesta alcuna configurazione da parte tua: le finestre di dialogo di elicitazione appaiono automaticamente quando un server le richiede. I server possono richiedere input in due modi:
  • Modalità modulo: Claude Code mostra una finestra di dialogo con campi modulo definiti dal server (per esempio, un prompt di nome utente e password). Compila i campi e invia.
  • Modalità URL: Claude Code apre un URL del browser per l’autenticazione o l’approvazione. Completa il flusso nel browser, quindi conferma nella CLI.
Per rispondere automaticamente alle richieste di elicitazione senza mostrare una finestra di dialogo, utilizza l’hook Elicitation. Se stai costruendo un server MCP che utilizza l’elicitazione, vedi la specifica di elicitazione MCP per i dettagli del protocollo e gli esempi di schema.

​
Utilizza risorse MCP

I server MCP possono esporre risorse che puoi referenziare utilizzando menzioni @, simile a come referenzi i file.

​
Referenzia risorse MCP

1

Elenca le risorse disponibili

Digita @ nel tuo prompt per vedere le risorse disponibili da tutti i server MCP connessi. Le risorse appaiono insieme ai file nel menu di completamento automatico.
2

Referenzia una risorsa specifica

Utilizza il formato @server:protocol://resource/path per referenziare una risorsa:
Puoi analizzare @github:issue://123 e suggerire una correzione?

Per favore rivedi la documentazione API su @docs:file://api/authentication
3

Referenze di risorse multiple

Puoi referenziare più risorse in un singolo prompt:
Confronta @postgres:schema://users con @docs:file://database/user-model
Suggerimenti:
  • Le risorse vengono recuperate automaticamente e incluse come allegati quando referenziate
  • I percorsi delle risorse sono ricercabili con fuzzy search nel completamento automatico della menzione @
  • Claude Code fornisce automaticamente strumenti per elencare e leggere risorse MCP quando i server le supportano
  • Le risorse possono contenere qualsiasi tipo di contenuto fornito dal server MCP (testo, JSON, dati strutturati, ecc.)
Quando hai molti server MCP configurati, le definizioni degli strumenti possono consumare una parte significativa della tua finestra di contesto. MCP Tool Search risolve questo caricando gli strumenti su richiesta invece di precaricarli tutti.

​
Come funziona

Claude Code abilita automaticamente Tool Search quando le descrizioni dei tuoi strumenti MCP consumerebbero più del 10% della finestra di contesto. Puoi regolare questa soglia o disabilitare completamente la ricerca degli strumenti. Quando attivato:
  1. Gli strumenti MCP vengono differiti piuttosto che caricati nel contesto in anticipo
  2. Claude utilizza uno strumento di ricerca per scoprire gli strumenti MCP rilevanti quando necessario
  3. Solo gli strumenti che Claude effettivamente necessita vengono caricati nel contesto
  4. Gli strumenti MCP continuano a funzionare esattamente come prima dal tuo punto di vista

​
Per gli autori di server MCP

Se stai costruendo un server MCP, il campo delle istruzioni del server diventa più utile con Tool Search abilitato. Le istruzioni del server aiutano Claude a capire quando cercare i tuoi strumenti, simile a come funzionano le skills. Aggiungi istruzioni del server chiare e descrittive che spieghino:
  • Quale categoria di attività gestiscono i tuoi strumenti
  • Quando Claude dovrebbe cercare i tuoi strumenti
  • Capacità chiave che il tuo server fornisce

​
Configura la ricerca degli strumenti

La ricerca degli strumenti è abilitata per impostazione predefinita: gli strumenti MCP vengono differiti e scoperti su richiesta. Quando ANTHROPIC_BASE_URL punta a un host non di prima parte, la ricerca degli strumenti è disabilitata per impostazione predefinita perché la maggior parte dei proxy non inoltrano blocchi tool_reference. Imposta ENABLE_TOOL_SEARCH esplicitamente se il tuo proxy lo fa. Questa funzionalità richiede modelli che supportano blocchi tool_reference: Sonnet 4 e successivi, oppure Opus 4 e successivi. I modelli Haiku non supportano la ricerca degli strumenti. Controlla il comportamento della ricerca degli strumenti con la variabile di ambiente ENABLE_TOOL_SEARCH:
ValoreComportamento
(non impostato)Abilitato per impostazione predefinita. Disabilitato quando ANTHROPIC_BASE_URL è un host non di prima parte
trueSempre abilitato, incluso per ANTHROPIC_BASE_URL non di prima parte
autoSi attiva quando gli strumenti MCP superano il 10% del contesto
auto:<N>Si attiva a una soglia personalizzata, dove <N> è una percentuale (ad es. auto:5 per il 5%)
falseDisabilitato, tutti gli strumenti MCP caricati in anticipo
# Utilizza una soglia personalizzata del 5%
ENABLE_TOOL_SEARCH=auto:5 claude

# Disabilita completamente la ricerca degli strumenti
ENABLE_TOOL_SEARCH=false claude
Oppure imposta il valore nel campo env del tuo settings.json. Puoi anche disabilitare lo strumento MCPSearch specificamente utilizzando l’impostazione disallowedTools: 
{
  "permissions": {
    "deny": ["MCPSearch"]
  }
}

​
Utilizza i prompt MCP come comandi

I server MCP possono esporre prompt che diventano disponibili come comandi in Claude Code.

​
Esegui i prompt MCP

1

Scopri i prompt disponibili

Digita / per vedere tutti i comandi disponibili, inclusi quelli dai server MCP. I prompt MCP appaiono con il formato /mcp__servername__promptname.
2

Esegui un prompt senza argomenti

/mcp__github__list_prs
3

Esegui un prompt con argomenti

Molti prompt accettano argomenti. Passali separati da spazi dopo il comando:
/mcp__github__pr_review 456

/mcp__jira__create_issue "Bug nel flusso di accesso" high
Suggerimenti:
  • I prompt MCP vengono scoperti dinamicamente dai server connessi
  • Gli argomenti vengono analizzati in base ai parametri definiti del prompt
  • I risultati del prompt vengono iniettati direttamente nella conversazione
  • I nomi del server e del prompt vengono normalizzati (gli spazi diventano trattini bassi)

​
Configurazione MCP gestita

Per le organizzazioni che necessitano di un controllo centralizzato sui server MCP, Claude Code supporta due opzioni di configurazione:
  1. Controllo esclusivo con managed-mcp.json: Distribuisci un set fisso di server MCP che gli utenti non possono modificare o estendere
  2. Controllo basato su policy con allowlist/denylist: Consenti agli utenti di aggiungere i propri server, ma limita quali sono consentiti
Queste opzioni consentono agli amministratori IT di:
  • Controllare a quali server MCP i dipendenti possono accedere: Distribuisci un set standardizzato di server MCP approvati in tutta l’organizzazione
  • Prevenire server MCP non autorizzati: Limita gli utenti dall’aggiungere server MCP non approvati
  • Disabilitare completamente MCP: Rimuovi completamente la funzionalità MCP se necessario

​
Opzione 1: Controllo esclusivo con managed-mcp.json

Quando distribuisci un file managed-mcp.json, assume il controllo esclusivo su tutti i server MCP. Gli utenti non possono aggiungere, modificare o utilizzare alcun server MCP diverso da quelli definiti in questo file. Questo è l’approccio più semplice per le organizzazioni che desiderano un controllo completo. Gli amministratori di sistema distribuiscono il file di configurazione a una directory a livello di sistema:
  • macOS: /Library/Application Support/ClaudeCode/managed-mcp.json
  • Linux e WSL: /etc/claude-code/managed-mcp.json
  • Windows: C:\Program Files\ClaudeCode\managed-mcp.json
Questi sono percorsi a livello di sistema (non directory home dell’utente come ~/Library/...) che richiedono privilegi di amministratore. Sono progettati per essere distribuiti dagli amministratori IT.
Il file managed-mcp.json utilizza lo stesso formato di un file .mcp.json standard: 
{
  "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.company.com"
      }
    }
  }
}

​
Opzione 2: Controllo basato su policy con allowlist e denylist

Invece di assumere il controllo esclusivo, gli amministratori possono consentire agli utenti di configurare i propri server MCP mentre applicano restrizioni su quali server sono consentiti. Questo approccio utilizza allowedMcpServers e deniedMcpServers nel file di impostazioni gestite.
Scelta tra le opzioni: Utilizza l’Opzione 1 (managed-mcp.json) quando desideri distribuire un set fisso di server senza personalizzazione dell’utente. Utilizza l’Opzione 2 (allowlist/denylist) quando desideri consentire agli utenti di aggiungere i propri server entro i vincoli della policy.

​
Opzioni di restrizione

Ogni voce nell’allowlist o denylist può limitare i server in tre modi:
  1. Per nome del server (serverName): Corrisponde al nome configurato del server
  2. Per comando (serverCommand): Corrisponde al comando esatto e agli argomenti utilizzati per avviare i server stdio
  3. Per pattern URL (serverUrl): Corrisponde agli URL dei server remoti con supporto per i caratteri jolly
Importante: Ogni voce deve avere esattamente uno tra serverName, serverCommand o serverUrl.

​
Configurazione di esempio

{
  "allowedMcpServers": [
    // Consenti per nome del server
    { "serverName": "github" },
    { "serverName": "sentry" },

    // Consenti per comando esatto (per server stdio)
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem"] },
    { "serverCommand": ["python", "/usr/local/bin/approved-server.py"] },

    // Consenti per pattern URL (per server remoti)
    { "serverUrl": "https://mcp.company.com/*" },
    { "serverUrl": "https://*.internal.corp/*" }
  ],
  "deniedMcpServers": [
    // Blocca per nome del server
    { "serverName": "dangerous-server" },

    // Blocca per comando esatto (per server stdio)
    { "serverCommand": ["npx", "-y", "unapproved-package"] },

    // Blocca per pattern URL (per server remoti)
    { "serverUrl": "https://*.untrusted.com/*" }
  ]
}

​
Come funzionano le restrizioni basate su comando

Corrispondenza esatta:
  • Gli array di comando devono corrispondere esattamente - sia il comando che tutti gli argomenti nell’ordine corretto
  • Esempio: ["npx", "-y", "server"] NON corrisponderà a ["npx", "server"] o ["npx", "-y", "server", "--flag"]
Comportamento del server stdio:
  • Quando l’allowlist contiene qualsiasi voce serverCommand, i server stdio devono corrispondere a uno di quei comandi
  • I server stdio non possono passare solo per nome quando sono presenti restrizioni di comando
  • Questo assicura che gli amministratori possono applicare quali comandi sono consentiti di eseguire
Comportamento del server non-stdio:
  • I server remoti (HTTP, SSE, WebSocket) utilizzano la corrispondenza basata su URL quando esistono voci serverUrl nell’allowlist
  • Se non esistono voci URL, i server remoti ricadono sulla corrispondenza basata su nome
  • Le restrizioni di comando non si applicano ai server remoti

​
Come funzionano le restrizioni basate su URL

I pattern URL supportano i caratteri jolly utilizzando * per corrispondere a qualsiasi sequenza di caratteri. Questo è utile per consentire interi domini o sottodomini. Esempi di caratteri jolly:
  • https://mcp.company.com/* - Consenti tutti i percorsi su un dominio specifico
  • https://*.example.com/* - Consenti qualsiasi sottodominio di example.com
  • http://localhost:*/* - Consenti qualsiasi porta su localhost
Comportamento del server remoto:
  • Quando l’allowlist contiene qualsiasi voce serverUrl, i server remoti devono corrispondere a uno di quei pattern URL
  • I server remoti non possono passare solo per nome quando sono presenti restrizioni URL
  • Questo assicura che gli amministratori possono applicare quali endpoint remoti sono consentiti
{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.company.com/*" },
    { "serverUrl": "https://*.internal.corp/*" }
  ]
}
Risultato:
  • Server HTTP su https://mcp.company.com/api: ✅ Consentito (corrisponde al pattern URL)
  • Server HTTP su https://api.internal.corp/mcp: ✅ Consentito (corrisponde al sottodominio jolly)
  • Server HTTP su https://external.com/mcp: ❌ Bloccato (non corrisponde a nessun pattern URL)
  • Server stdio con qualsiasi comando: ❌ Bloccato (nessuna voce di nome o comando per corrispondere)
{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
Risultato:
  • 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-api”: ❌ Bloccato (nessuna voce di nome per corrispondere)
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}
Risultato:
  • 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 “github”: ✅ Consentito (corrisponde al nome)
  • Server HTTP denominato “other-api”: ❌ Bloccato (il nome non corrisponde)
{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}
Risultato:
  • Server stdio denominato “github” con qualsiasi comando: ✅ Consentito (nessuna restrizione di comando)
  • Server stdio denominato “internal-tool” con qualsiasi comando: ✅ Consentito (nessuna restrizione di comando)
  • Server HTTP denominato “github”: ✅ Consentito (corrisponde al nome)
  • Qualsiasi server denominato “other”: ❌ Bloccato (il nome non corrisponde)

​
Comportamento dell’allowlist (allowedMcpServers)

  • undefined (predefinito): Nessuna restrizione - gli utenti possono configurare qualsiasi server MCP
  • Array vuoto []: Blocco completo - gli utenti non possono configurare alcun server MCP
  • Elenco di voci: Gli utenti possono configurare solo server che corrispondono per nome, comando o pattern URL

​
Comportamento della denylist (deniedMcpServers)

  • undefined (predefinito): Nessun server è bloccato
  • Array vuoto []: Nessun server è bloccato
  • Elenco di voci: I server specificati sono esplicitamente bloccati in tutti gli ambiti

​
Note importanti

  • L’Opzione 1 e l’Opzione 2 possono essere combinate: Se managed-mcp.json esiste, ha il controllo esclusivo e gli utenti non possono aggiungere server. Gli allowlist/denylist si applicano comunque ai server gestiti stessi.
  • La denylist ha precedenza assoluta: Se un server corrisponde a una voce della denylist (per nome, comando o URL), sarà bloccato anche se è nell’allowlist
  • Le restrizioni basate su nome, comando e URL funzionano insieme: un server passa se corrisponde a una voce di nome, una voce di comando o un pattern URL (a meno che non sia bloccato dalla denylist)
Quando utilizzi managed-mcp.json: Gli utenti non possono aggiungere server MCP tramite claude mcp add o file di configurazione. Le impostazioni allowedMcpServers e deniedMcpServers si applicano comunque per filtrare quali server gestiti vengono effettivamente caricati.