[args...]
```
Sono supportati tre trasporti: `--transport stdio` (predefinito, un processo locale), `--transport http` (HTTP remoto) e `--transport sse` (indicato come deprecato; da usare solo se il server non è ancora stato migrato).
Sono supportati tre ambiti tramite il flag `--scope`:
- `local` — solo nella cartella del progetto corrente (predefinito).
- `project` — scritto in `.mcp.json`, salvato nel repository e disponibile a tutto il team.
- `user` — globale per tutti i progetti sul computer.
Un esempio minimo con il server Filesystem di riferimento del progetto MCP. Si avvia in mezzo minuto:
```bash
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem@2026.8.31 /Users/me/projects
claude mcp list
```
Dopo `list`, vedrai `filesystem` nell’elenco se la cartella indicata nel comando esiste; altrimenti il server non si avvierà. Potrà vedere le cartelle di lavoro di Claude Code, cioè la cartella da cui lo hai avviato. Spiego più avanti, nella sezione 5.2, perché succede e quando questo server è davvero utile.
Per verificare la connessione MCP, esegui `/mcp` in una sessione di Claude Code. Mostrerà tutti i server, il loro stato e gli elenchi dei relativi strumenti. Le istruzioni aggiuntive per lavorare con Ailoot sono disponibili nella [documentazione](https://ailoot.ai/docs/). Consulta il README del server MCP scelto per i relativi comandi specifici.
## Claude Code server MCP integrazioni online: quando scegliere HTTP invece di stdio? {#stdio-o-http-quale-trasporto-scegliere}
Punti chiave
stdio è un processo locale sul tuo computer: funziona tutto senza rete e non serve OAuth. HTTP è un servizio remoto, accessibile con un token o OAuth, e può essere condiviso tra dispositivi. Se un server MCP viene installato tramite `npx` o `uvx`, usa stdio. Se un servizio ha un proprio indirizzo pubblico, usa HTTP. SSE è ufficialmente indicato come deprecato: non farci affidamento.
Confronto secondo i criteri principali:
| Criterio | stdio | HTTP |
|----|----|----|
| Dove viene eseguito | In locale (processo figlio di Claude Code) | Server remoto |
| Autorizzazione | Non necessaria | OAuth 2.1 o token Bearer |
| Porte di rete | Nessuna | Indirizzo pubblico |
| Casi d’uso | Filesystem, Postgres, utilità locali | GitHub, Slack, Notion, Linear, Sentry |
| Riconnessione | Non necessaria | Backoff esponenziale, fino a 5 tentativi |
| Distribuzione | Installazione del pacchetto in locale | Servizio del fornitore |
Regola pratica: tutto ciò che è archiviato sul disco o in un database locale usa stdio. Tutto ciò che è nel cloud usa HTTP. SSE è ufficialmente deprecato: non sceglierlo.
## 7 server MCP pronti all’uso per imprenditori
Punti chiave
Ecco sette configurazioni che coprono l’80% delle attività di chi fa vibe coding: codice (GitHub), file (Filesystem), database (Postgres tramite DBHub), comunicazione del team (Slack), base di conoscenza (Notion), tracciamento degli errori (Sentry) e flussi di lavoro nel browser (Playwright). Per ogni configurazione qui sotto fornisco un comando d’installazione in una riga e un esempio preciso di come chiedere a Claude di svolgere il lavoro in una conversazione reale.
### 5.1. GitHub MCP — il server ufficiale di GitHub
Che cosa fa: dà a Claude Code accesso alle issue, alle pull request, ai file del repository e alle esecuzioni delle action. Il server è open source e ha più di 30.000 stelle su GitHub.
Installazione (HTTP, tramite OAuth):
```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
```
In alternativa, usa stdio tramite Docker se ti serve un token PAT invece di OAuth.
Esempio: «Leggi le issue aperte con l’etichetta `bug`, raggruppale per componente e suggerisci l’ordine in cui chiuderle». Claude chiamerà GitHub MCP, leggerà tutte le issue e restituirà un elenco prioritizzato.
Repository: [github/github-mcp-server](https://github.com/github/github-mcp-server).
### 5.2. Filesystem MCP — il server di riferimento del progetto MCP
Che cosa fa: dà all’IA accesso ai file sul computer nelle cartelle approvate. È distribuito dal progetto MCP stesso; il registro npm indica come autore Model Context Protocol a Series of LF Projects, LLC.
Installazione (stdio), con una versione bloccata:
```bash
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem@2026.8.31 /Users/me/projects
```
Quando Claude Code si connette, passa al server le proprie cartelle di lavoro, che sostituiscono tutte quelle specificate nel comando. Le cartelle di lavoro di Claude Code sono quella da cui lo hai avviato, più quelle aggiunte con il comando `/add-dir` o il flag `--add-dir`. Non puoi indicare tramite il comando una cartella separata per i mockup. La cartella indicata nel comando deve comunque esistere, altrimenti il server non si avvia.
Quindi, in Claude Code questo server perlopiù duplica gli strumenti integrati. Per accedere ai file in un’altra cartella basta `/add-dir`: dopo averlo usato, anche gli strumenti di Claude Code possono leggere quella cartella. Il server è più utile per i programmi che non dispongono di un proprio accesso ai file. In Claude Desktop può verificarsi un altro problema: gli strumenti del server vengono rifiutati perché le loro descrizioni usano un vecchio formato dello schema; il problema è ancora aperto.
Concedi l’accesso solo alle cartelle che ti servono davvero, sia nel comando sia tramite `/add-dir`. Non concedere l’accesso alla radice del disco: è la prima falla di sicurezza.
Esempio: prima `/add-dir ~/Documents/design`, poi «Sposta tutti i mockup da `~/Documents/design/landing-v3/` nel progetto corrente e rinominali secondo la convenzione `hero-*.png`».
### 5.3. Postgres MCP — DBHub (Bytebase)
Che cosa fa: collega Claude a Postgres, MySQL, SQL Server, MariaDB o SQLite. Supporta la modalità di sola lettura, così l’agente IA non può eliminare il database con un solo comando. Spesso viene usato al posto del server di riferimento di Anthropic archiviato, `server-postgres`.
Installazione (HTTP, sola lettura):
```bash
claude mcp add postgres -- npx -y @bytebase/dbhub --dsn "postgresql://user:pass@localhost:5432/mydb?sslmode=disable" --readonly
```
Per un database di produzione, usa sempre un utente separato con autorizzazioni di sola lettura e anonimizza i dati personali tramite una VIEW o una route API intermedia. Non collegarti a un database di produzione con autorizzazioni di scrittura.
Esempio: «Interroga i clienti con stato di abbonamento `expired` dell’ultimo mese ed elenca i primi 20 per importo totale dei pagamenti».
Repository: [bytebase/dbhub](https://github.com/bytebase/dbhub).
### 5.4. Slack MCP — comunicazione del team
Che cosa fa: dà a Claude accesso alla lettura dei canali Slack e all’invio di messaggi. Utile per l’automazione: «Quando la build va a buon fine, pubblica in `#releases`»; «Compila un riepilogo settimanale da `#engineering`».
Installazione (stdio tramite un wrapper npx, come `@modelcontextprotocol/server-slack` o un equivalente del fornitore):
```bash
claude mcp add slack \
-e SLACK_BOT_TOKEN=xoxb-... \
-e SLACK_TEAM_ID=T0... \
-- npx -y @modelcontextprotocol/server-slack
```
L’autorizzazione usa un token bot Slack; l’accesso è limitato dagli scope configurati in Slack. Puoi concedere all’IA solo `chat:read` e `chat:write:user`, impedendole così di modificare le impostazioni dell’area di lavoro. Consulta il README del server scelto per i comandi aggiornati: l’ecosistema cambia rapidamente.
Esempio: «Ogni mattina alle 9:00, invia l’elenco delle PR unite ieri a `#daily`».
### 5.5. Notion MCP — base di conoscenza
Che cosa fa: dà a Claude accesso alle pagine e ai database di Notion. È una base di conoscenza al di fuori del tuo progetto: se lì conservi appunti, un registro clienti o le linee guida editoriali, l’IA può leggerli.
Installazione (HTTP, tramite OAuth):
```bash
claude mcp add --transport http notion https://mcp.notion.com/mcp
```
In alternativa, usa il plugin ufficiale di Anthropic `@makenotion/claude-code-notion-plugin`.
Esempio: «Nel database Notion “Customers”, trova tutte le persone con stato “active” che non hanno fatto una chiamata da più di due settimane. Prepara un’email per ciascuna».
Guida di Notion: [developers.notion.com/guides/mcp](https://developers.notion.com/guides/mcp/get-started-with-mcp).
### 5.6. Sentry MCP — tracciamento degli errori
Che cosa fa: collega Claude agli errori del tuo sistema di produzione. Quando una pagina restituisce un errore 500, puoi chiedere «Mostrami le 10 issue più recenti in Sentry per il progetto e spiegami la causa principale di ciascuna» e ottenere subito un’analisi.
Installazione (HTTP):
```bash
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```
L’autorizzazione avviene tramite OAuth di Sentry. L’accesso può essere limitato a un progetto specifico.
Esempio: «Prendi le tre issue più frequenti delle ultime 24 ore. Spiega in parole semplici che cosa è successo e suggerisci come risolverlo».
Repository: [getsentry/sentry-mcp](https://github.com/getsentry/sentry-mcp).
### 5.7. Playwright MCP — flussi di lavoro nel browser
Che cosa fa: dà a Claude un browser. L’IA può aprire una pagina, fare clic, compilare un modulo e acquisire uno screenshot. Utile per controlli dell’interfaccia, test manuali dopo la pubblicazione e analisi dei flussi di lavoro.
Installazione (stdio):
```bash
claude mcp add playwright -- npx -y @playwright/mcp@latest
```
La versione v0.0.75, pubblicata il 7 maggio 2026, è mantenuta attivamente da Microsoft (più di 32.000 stelle).
Esempio: «Apri la home page del nostro sito, controlla che tutte le card vengano visualizzate correttamente e acquisisci uno screenshot su desktop e mobile».
Repository: [microsoft/playwright-mcp](https://github.com/microsoft/playwright-mcp).
Consulta il README della versione di Playwright MCP scelta per il comando con una versione bloccata, il flag per più sessioni simultanee e gli errori d’installazione più comuni.
## Come controllare la sicurezza con un hook PreToolUse
Punti chiave
MCP dà molta potenza all’IA: può scrivere nei database, inviare messaggi ed eliminare file. Un hook PreToolUse può controllare le chiamate corrispondenti, ma una regex sul prefisso SQL non è un’autorizzazione del database e un matcher limitato a Postgres non copre Slack o gli strumenti sui file. Usa prima i permessi effettivi dei servizi e del file system e verifica separatamente l’ambito esatto dell’hook.
Una blacklist del prefisso SQL non costituisce un confine di sola lettura: SQL minuscolo, commenti, `UPDATE`, `INSERT`, `ALTER`, istruzioni multiple e funzioni con effetti collaterali non sono coperti da tre prefissi maiuscoli. Assegna alla connessione un ruolo separato con permessi di sola lettura e verificali su un database di prova eliminabile. Un hook aggiunge un controllo sulle chiamate agli strumenti, senza sostituire quei permessi.
Questo è un esempio volutamente ristretto di **quarantena**: nega tutte le chiamate delle tre famiglie di server MCP indicate finché non avrai revisionato e provato una policy più specifica. Blocca letture e scritture. Adatta i nomi a quelli effettivi: un server rinominato, Bash integrato o un altro connettore restano fuori da questi schemi.
Inserisci queste regole separate in `.claude/settings.json`:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "mcp__postgres__.*",
"hooks": [{"type": "command", "command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/deny-unapproved-mcp.sh\""}]
},
{
"matcher": "mcp__slack__.*",
"hooks": [{"type": "command", "command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/deny-unapproved-mcp.sh\""}]
},
{
"matcher": "mcp__filesystem__.*",
"hooks": [{"type": "command", "command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/deny-unapproved-mcp.sh\""}]
}
]
}
}
```
Salva questo script come `.claude/hooks/deny-unapproved-mcp.sh`. Restituisce il [contratto di decisione PreToolUse documentato](https://code.claude.com/docs/en/hooks#pretooluse-decision-control), non il vecchio `decision: approve/block` al livello principale:
```bash
#!/bin/bash
printf '%s\n' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"This MCP server family is quarantined pending a reviewed policy."}}'
```
Lo script non analizza né classifica SQL: nega sempre una chiamata corrispondente. Prima di collegare dati importanti, verifica in una sessione isolata corrispondenza e risultato dell’hook: `SELECT 1`, `delete` minuscolo, un `UPDATE` preceduto da commento, uno strumento Slack di lettura o invio e una lettura Filesystem di `.env` devono essere tutti negati quando il nome dello strumento corrisponde. Uno strumento di un’altra famiglia deve restare fuori dall’esempio: verifica esplicitamente anche questo confine.
Per consentire lavoro database in sola lettura, usa permessi verificati e sostituisci la quarantena con una policy revisionata per gli strumenti reali. Per Slack usa credenziali senza privilegi d’invio quando servono solo letture. Per i file limita le radici consentite del server e i permessi del processo. Non affermare che l’hook impedisca l’accesso attraverso altri strumenti, comandi shell, allegati ai prompt o una policy modificabile dall’agente.
Lo stesso approccio è trattato più in dettaglio nella guida [Plan Mode in Claude Code](https://ailoot.ai/blog/it/claude-code-plan-mode/), che descrive una logica analoga di «controllo prima dell’esecuzione».
## Che cosa fare se hai più di 40 strumenti e Claude si perde?
Punti chiave
Sette server possono facilmente significare 50–100 strumenti. Claude Code usa Tool Search per impostazione predefinita: all’avvio, nel contesto entrano solo i nomi degli strumenti e le istruzioni del server; Claude carica la descrizione completa quando gli serve uno strumento. Se la ricerca è disattivata, tutte le descrizioni vengono caricate subito e, dopo circa 40 strumenti, Claude inizia a confondersi: sceglie lo strumento sbagliato o ricorre a MCP quando basterebbe un normale comando.
Secondo la [documentazione di Claude Code](https://code.claude.com/docs/en/mcp#scale-with-mcp-tool-search), ora è attivata per impostazione predefinita e non è necessario abilitarla manualmente.
Eccezioni in cui Claude Code carica subito tutti gli strumenti: uso tramite un proxy di terze parti (quando `ANTHROPIC_BASE_URL` è impostato su un indirizzo diverso da quello di Anthropic), modelli precedenti alla generazione 4.5 in Google Cloud e distribuzioni Microsoft Foundry su Azure. La variabile `ENABLE_TOOL_SEARCH` modifica il comportamento:
- non impostata — tutti gli strumenti MCP sono rimandati e caricati su richiesta;
- `true` — lo stesso comportamento, più il tentativo di Claude Code di abilitare la ricerca tramite un proxy;
- `auto` — modalità a soglia: finché tutte le descrizioni degli strumenti occupano meno del 10% della finestra di contesto, vengono caricate subito; superata la soglia, vengono rimandate;
- `auto:N` — lo stesso comportamento, ma con una soglia percentuale personalizzata, per esempio `auto:5`;
- `false` — il comportamento precedente: tutti gli strumenti entrano subito nel contesto.
Per gli strumenti critici che devono essere sempre visibili, in `.mcp.json` accanto alla descrizione del server c’è il flag `alwaysLoad: true`. Ogni strumento di questo tipo occupa spazio nel contesto fin dal primo minuto: usalo solo per gli strumenti di cui Claude ha bisogno quasi a ogni risposta.
Se hai cinque o più server MCP e Claude si confonde su quale strumento chiamare, controlla prima se la ricerca è disattivata: cerca `ENABLE_TOOL_SEARCH=false` nelle impostazioni e verifica se stai lavorando tramite un proxy.
Può essere utile anche [ridurre il contesto con /compact](https://ailoot.ai/blog/it/claude-code-token-limits-saving/).
## Quando non serve MCP: è meglio una Skill, un Subagent o una CLI?
Punti chiave
In termini di token, MCP è il modo più costoso per dare a Claude capacità esterne. Se l’attività si può svolgere con uno strumento CLI già pronto (`gh issue list`, `psql`, `curl`) o con una skill di una pagina, usa quelli invece di creare server MCP. Regola: MCP è giustificato solo quando l’IA ha bisogno di una conversazione bidirezionale in tempo reale con un servizio, non di una risposta isolata.
Gerarchia per costo in token e complessità:
1. **Comando CLI tramite Bash** — quasi gratuito. L’IA esegue `gh pr list`, `psql -c` o `curl` e ottiene una risposta come un normale utente del terminale.
2. **Skill** — economica. Un modello di prompt pronto all’uso, con istruzioni su che cosa chiamare e come elaborare il risultato. Viene caricato in base a un’attivazione nel nome della cartella.
3. **Subagent** — medio. Contesto separato per un’attività lunga, con una propria sessione di token.
4. **Server MCP** — costoso. Nel contesto restano solo i nomi degli strumenti, ma la descrizione dello strumento viene caricata quando Claude lo individua prima di una chiamata; inoltre, le risposte dei servizi possono essere lunghe: Claude Code mostra un avviso quando la risposta di uno strumento supera i 10.000 token. Si aggiunge una sessione OAuth per HTTP.
Un consiglio controintuitivo: per analizzare pagine web, lavorare con git, aprire PDF e usare utilità open source, scegli **CLI**, non MCP. L’IA può usare i comandi del terminale proprio come una persona e i token vengono spesi solo per il comando e la sua risposta, senza descrizioni degli strumenti né sovraccarico del server.
MCP è giustificato in due casi:
- Il servizio è **chiuso**: Slack, Notion, Sentry, Linear. Esistono anche strumenti CLI, ma MCP offre un accesso più granulare tramite OAuth e controlli degli scope.
- Serve una **conversazione bidirezionale in tempo reale**: l’IA si connette a Postgres, controlla lo schema, esegue una query successiva, ottiene i dati e passa all’azione seguente. Con CLI servirebbero 10 comandi manuali.
## 6 anti-pattern di connessione MCP
Punti chiave
Sei errori specifici che mettono in difficoltà chi fa vibe coding nelle prime settimane con MCP. Ogni anti-pattern si può correggere in un minuto: apri `claude mcp list`, controlla l’elenco e verifica scope e hook. La maggior parte dei problemi si risolve rimuovendo un server non necessario, non aggiungendone uno nuovo; questa sezione è una breve checklist da seguire dall’inizio alla fine.
1. **Collezione di server MCP.** Hai collegato 10 server «per ogni evenienza»; Claude si confonde su quale strumento chiamare e le risposte intasano il contesto. Soluzione: tieni 3–5 server per il progetto corrente e rimuovi gli altri con `claude mcp remove`.
2. **Accesso in scrittura a un database di produzione.** Hai collegato Postgres MCP a un database di produzione senza `--readonly`, un utente separato o un hook allowlist. Basta un prompt — «elimina i record di test» — e i dati di produzione vengono cancellati. Soluzione: un ruolo separato del database con permessi di sola lettura verificati, la modalità di sola lettura del server dove applicabile e controlli provati sulle chiamate agli strumenti. Una blacklist dei prefissi `DROP|TRUNCATE|DELETE` non è un’autorizzazione sufficiente.
3. **Dati personali senza anonimizzazione.** Hai collegato direttamente un database contenente email, numeri di telefono e dati dei passaporti dei clienti. Claude vede i dati, che finiscono nei log di Anthropic. Soluzione: una VIEW o una route API intermedia che restituisca dati mascherati, come `j***@gmail.com`.
4. **MCP al posto di una skill.** Ti serve «creare un rapporto di vendita nel formato X»: un’attività di routine che si risolve con una skill dotata di un prompt pronto all’uso. Non creare un server MCP.
5. **MCP al posto di una CLI open source.** Devi convertire un PDF in testo. C’è `pdftotext`. Non creare un «PDF MCP»: fa solo sprecare token.
6. **Non monitorare il costo in token.** Vedi il server connesso in `claude mcp list`, ma non quanto usa in ogni conversazione. Dopo una settimana non sai che «MCP ha consumato il 40% del contesto e ho pagato tutto questo tempo». Soluzione: disattiva periodicamente i server inutilizzati e osserva come cambia l’uso tramite il [monitoraggio dei limiti di utilizzo di Claude Code](https://ailoot.ai/blog/it/claude-code-token-limits-saving/).
## Come risolvere i problemi di connessione MCP
Punti chiave
I problemi più comuni: il callback OAuth non funziona, il nome del server è in conflitto con uno esistente oppure lo strumento non compare in `claude mcp list` dopo `add`. La procedura standard di risoluzione li affronta così: `list` mostra ciò che si è connesso, `status` controlla l’indicatore di stato e, se è rosso, `logs` restituisce una traccia dello stack. Dopo aver modificato `--scope` o una variabile ENV, riavvia tutto.
Checklist passo passo:
1. **Il server è visibile nell’elenco?**
```bash
claude mcp list
```
In caso contrario, `claude mcp add` non è stato completato. La causa più comune è `--scope`: lo hai aggiunto a `local` e stai controllando da un altro progetto.
2. **Lo stato del server è verde?**
```bash
claude mcp status
```
Rosso significa che il processo non si è avviato (per stdio) o che il server non ha risposto (per HTTP).
3. **I log del server contengono informazioni utili?**
```bash
claude mcp logs
```
Se vedi una traccia dello stack, di solito il problema riguarda il pacchetto (`npx` non è riuscito a trovarlo o la versione di Node è inferiore alla 20).
4. **Il callback OAuth non torna?** Di solito il problema riguarda `--callback-port` o un filtro di rete. Inoltra una porta specifica:
```bash
claude mcp add --transport http --callback-port 8765 [name] [url]
```
5. **Conflitto tra nomi degli strumenti?** Due server espongono uno strumento con lo stesso nome e Claude chiama quello sbagliato. Usa Tool Search (vedi l’H2 precedente) oppure rimuovi manualmente il server in più con `claude mcp remove`.
6. **Non riesci a vedere le estensioni (connector) di claude.ai?** È un problema noto: le estensioni (connector) dell’interfaccia web di claude.ai non sono disponibili in Claude Code quando usa una chiave API. Soluzione: collega MCP tramite CLI, non tramite l’interfaccia web.
## Prossimi passi: OAuth, server MCP personalizzati e Plugin Marketplace
Punti chiave
Dopo i sette server pronti all’uso, i tre passi successivi sono configurare OAuth per i tuoi server HTTP (se vuoi condividere MCP con il team), scrivere un MCP personalizzato per un servizio specifico e collegarti al Plugin Marketplace di Anthropic. Il Marketplace è stato lanciato il 9 ottobre 2025 e racchiude MCP in plugin installabili con un solo comando.
Il Plugin Marketplace semplifica le cose a chi non vuole ricordare i comandi d’installazione. Il formato è un manifest `.claude-plugin/marketplace.json` che descrive un insieme di server in un unico pacchetto.
Installa un plugin dal marketplace:
```bash
claude plugin install
```
Un plugin può contenere contemporaneamente vari server MCP, skill e subagent: una configurazione pronta per uno scenario specifico, come l’e-commerce, il marketing o un ufficio legale.
Scrivi il tuo server MCP seguendo la specifica `modelcontextprotocol.io`. Un modello minimo usa l’SDK Python o TypeScript di Anthropic; poi descrivi gli strumenti e collega un trasporto. La complessità è paragonabile a quella di scrivere un’API REST con FastAPI.
Se il tuo progetto ha già un [CLAUDE.md configurato](https://ailoot.ai/blog/it/claude-md-template/) e conosci il [context engineering](https://ailoot.ai/blog/it/context-engineering/), aggiungere un MCP personalizzato richiede un giorno. Se non hai queste basi, è meglio impararle prima.
### Fonti
- [Model Context Protocol — sito ufficiale](https://modelcontextprotocol.io/)
- [Anthropic presenta MCP — 25 novembre 2024](https://www.anthropic.com/news/model-context-protocol)
- [Documentazione MCP di Claude Code](https://code.claude.com/docs/en/mcp)
- [Claude Code: Tool Search per MCP](https://code.claude.com/docs/en/mcp#scale-with-mcp-tool-search)
- [Annuncio dei plugin di Claude Code — 9 ottobre 2025](https://claude.com/blog/claude-code-plugins)
- [Code with Claude 2026](https://claude.com/code-with-claude)
- [modelcontextprotocol/servers — registro ufficiale](https://github.com/modelcontextprotocol/servers)
- [github/github-mcp-server](https://github.com/github/github-mcp-server)
- [microsoft/playwright-mcp](https://github.com/microsoft/playwright-mcp)
- [bytebase/dbhub — Postgres MCP](https://github.com/bytebase/dbhub)
- [getsentry/sentry-mcp](https://github.com/getsentry/sentry-mcp)
- [makenotion/claude-code-notion-plugin](https://github.com/makenotion/claude-code-notion-plugin)
- [Guida MCP di Notion](https://developers.notion.com/guides/mcp/get-started-with-mcp)
- [Repository Anthropic Claude Code — issue e changelog](https://github.com/anthropics/claude-code)
Per continuare a lavorare con i modelli, vai su [Ailoot](https://ailoot.ai/).
## Domande frequenti
### Questo hook rende di sola lettura l’accesso al database di produzione?
No. L’esempio mette in quarantena tutte le chiamate corrispondenti alle famiglie MCP indicate; non classifica SQL. La sola lettura deve essere garantita da un ruolo separato con permessi verificati, usando gli hook come controllo aggiuntivo.
### Come verifico l’ambito dell’hook?
In una sessione isolata controlla che i nomi corrispondenti vengano negati per letture e scritture, anche con SQL minuscolo o preceduto da commenti. Poi verifica che uno strumento estraneo sia fuori dal matcher: quel percorso richiede propri permessi o una propria policy.
## Ailoot · L’azienda e il suo portafoglio di progetti
Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.
L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.
Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.