AIGuide

Model Context Protocol (MCP): Cos’è e Come Usarlo nei Tuoi Progetti

Hai sentito parlare di MCP ma non sai ancora cosa sia esattamente? Model Context Protocol è il protocollo standard che sta rivoluzionando il modo in cui gli LLM come Claude si connettono a strumenti e dati esterni. In questa guida introduttiva scoprirai cos’è, come funziona e come integrarlo nei tuoi progetti.

Se hai già lavorato con Claude Code, saprai che uno dei suoi punti di forza è la capacità di interagire con file, terminale e strumenti del sistema. MCP è esattamente il protocollo sottostante che rende possibile tutto questo — e ora puoi usarlo anche tu nei tuoi progetti.

Cos’è MCP e Perché È Importante

Fino a poco tempo fa, integrare un LLM con strumenti esterni (database, file system, API) richiedeva soluzioni custom per ogni caso d’uso. Ogni team scriveva la propria integrazione, incompatibile con quelle degli altri. MCP nasce per risolvere questo problema: è un protocollo aperto standardizzato che definisce come gli LLM comunicano con strumenti e sorgenti di dati.

Pensa a MCP come al protocollo HTTP per il web: prima di HTTP, ogni server comunicava in modo diverso. HTTP ha standardizzato la comunicazione e ha reso possibile il web moderno. MCP fa lo stesso per le integrazioni LLM.

Vantaggi concreti:

  • Un MCP server scritto una volta funziona con qualsiasi client MCP-compatibile (Claude, altri LLM)
  • Ecosistema di server già pronti per i casi d’uso più comuni
  • Sicurezza: l’LLM non accede mai direttamente ai tuoi dati, ma passa sempre attraverso il server MCP
  • Separazione delle responsabilità: l’LLM decide cosa fare, il server MCP esegue le operazioni

Architettura MCP: Host, Client e Server

L’architettura MCP si basa su tre componenti distinti che collaborano:

Host — È l’applicazione che usa un LLM e ospita i client MCP. Esempi: Claude Desktop, un’applicazione chat custom, un IDE con AI. L’host gestisce la sessione con l’LLM e coordina i client.

Client MCP — Componente all’interno dell’host che gestisce una connessione 1:1 con un server MCP. Traduce le richieste dell’LLM nel protocollo MCP e riceve le risposte.

Server MCP — Un processo separato (locale o remoto) che espone capabilities specifiche: accesso a file, query su database, operazioni browser, chiamate API. Il server implementa il protocollo MCP e conosce il dominio specifico.

# Flusso di una richiesta MCP:
#
# Utente: "Leggi il file config.json"
#     │
#     ▼
# [Host/Claude Desktop]
#     │ L'LLM decide di usare lo strumento "read_file"
#     ▼
# [Client MCP] ──── JSON-RPC ────▶ [MCP Server: filesystem]
#                                        │
#                                        │ Legge il file
#                                        ▼
#                                  { "content": "..." }
#     ◀──────────────────────────────────┘
#     │
#     ▼
# [LLM processa il contenuto e risponde all'utente]

La comunicazione tra client e server avviene tramite JSON-RPC 2.0, un protocollo leggero e standard. Il trasporto può essere stdio (per processi locali) o HTTP con SSE (per server remoti).

Come Funziona il Protocollo MCP

MCP definisce tre tipi di capabilities che un server può esporre:

Tools — Funzioni che l’LLM può invocare per eseguire operazioni. Esempio: read_file, run_query, navigate_browser. Ogni tool ha uno schema JSON che descrive i parametri accettati.

Resources — Dati che l’LLM può leggere come contesto. Diverso dai tool: le resource sono dati passivi (file, pagine web), i tool sono azioni attive.

Prompts — Template di prompt predefiniti che il server mette a disposizione dell’LLM per task specifici.

// Esempio di schema di un tool MCP
{
  "name": "read_file",
  "description": "Legge il contenuto di un file dal filesystem locale",
  "inputSchema": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "Percorso assoluto o relativo del file da leggere"
      }
    },
    "required": ["path"]
  }
}

// Chiamata JSON-RPC dal client al server:
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/home/user/config.json"
    }
  }
}

// Risposta del server:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{ "api_key": "...", "debug": true }"
      }
    ]
  }
}

Server MCP Disponibili: L’Ecosistema

Uno dei punti di forza di MCP è l’ecosistema di server già pronti. Anthropic e la community hanno sviluppato server per i casi d’uso più comuni:

MCP Filesystem Server — Permette all’LLM di leggere, scrivere e navigare file e directory. Il server è configurabile per limitare l’accesso a cartelle specifiche.

MCP Browser Server (Puppeteer) — Automazione browser: l’LLM può navigare pagine web, fare click, compilare form, catturare screenshot.

MCP Database Servers — Connettori per PostgreSQL, SQLite, MySQL. L’LLM può eseguire query, esplorare lo schema e analizzare dati.

MCP Git Server — Operazioni git: commit, diff, log, branch. Ottimo per workflow di code review assistita dall’AI.

MCP Fetch Server — Permette all’LLM di fare richieste HTTP a URL esterni, utile per integrare API di terze parti senza scrivere codice custom.

Esempio Pratico: Claude Desktop + MCP Filesystem

Vediamo come configurare Claude Desktop per usare il server MCP del filesystem. Questo è il setup più comune e il punto di partenza ideale per capire MCP in pratica.

Step 1: Installare il server MCP filesystem

# Il server MCP filesystem è disponibile come pacchetto npm
npm install -g @modelcontextprotocol/server-filesystem

# Verifica installazione
mcp-server-filesystem --help

Step 2: Configurare Claude Desktop

La configurazione si trova in ~/Library/Application Support/Claude/claude_desktop_config.json su macOS:

{
  "mcpServers": {
    "filesystem": {
      "command": "mcp-server-filesystem",
      "args": [
        "/Users/tuonome/Desktop",
        "/Users/tuonome/Documents/progetti"
      ]
    }
  }
}

Gli args sono le directory a cui il server avrà accesso. Per sicurezza, limita sempre l’accesso alle sole cartelle necessarie.

Step 3: Riavviare Claude Desktop e verificare

Dopo il riavvio, nell’interfaccia di Claude Desktop apparirà un’icona che indica i server MCP connessi. Puoi ora chiedere a Claude di leggere file, creare documenti, navigare directory — tutto all’interno delle cartelle configurate.

# Esempio di configurazione con più server MCP
{
  "mcpServers": {
    "filesystem": {
      "command": "mcp-server-filesystem",
      "args": ["/Users/tuonome/progetti"]
    },
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "mcp-server-postgres",
      "args": ["postgresql://localhost/mydb"]
    }
  }
}

Tool Use vs MCP: Qual è la Differenza?

Una domanda comune: qual è la differenza tra il Tool Use dell’API Anthropic e MCP?

Tool Use (API) — È una feature dell’API Anthropic che permette di definire funzioni che l’LLM può chiamare. I tool sono definiti nel payload della richiesta API e la loro esecuzione avviene nel tuo codice. Ideale per applicazioni custom dove controlli tutto il flusso.

MCP — È un protocollo separato e standardizzato. I server MCP sono processi indipendenti che possono essere usati da qualsiasi client MCP-compatibile. Ideale per strumenti condivisibili, ecosistema, integrazione con applicazioni host come Claude Desktop.

In pratica: se stai costruendo un’applicazione one-off che usa l’API direttamente, il Tool Use è sufficiente. Se vuoi creare uno strumento riutilizzabile che funzioni con Claude Desktop, altri LLM, o altri client MCP, costruisci un server MCP.

Per approfondire, la documentazione ufficiale Anthropic su MCP è il punto di riferimento completo.

💡 Takeaway: MCP standardizza le integrazioni LLM come HTTP ha standardizzato il web. 🔧 Inizia con il server filesystem su Claude Desktop: in 10 minuti hai un LLM che legge e scrive file nel tuo sistema. 🎯 Costruisci un server MCP custom solo quando hai un’integrazione specifica da condividere o riusare — altrimenti il Tool Use API è più rapido.

FAQ su MCP

MCP funziona solo con Claude?

No. MCP è un protocollo aperto e altri LLM e applicazioni stanno adottando il supporto. L’obiettivo è essere agnostico rispetto al modello: un server MCP scritto oggi dovrebbe funzionare con qualsiasi LLM MCP-compatibile in futuro.

È sicuro dare a Claude accesso al filesystem?

Con le dovute precauzioni, sì. Il server MCP filesystem limita l’accesso alle sole directory che configuri. Claude non può accedere a file al di fuori di quelle cartelle. Usa directory di lavoro dedicate invece di dare accesso alla home completa.

Come creo un server MCP personalizzato?

Anthropic fornisce SDK ufficiali per TypeScript e Python. Un server MCP minimale in TypeScript richiede circa 50 righe di codice: si implementa il metodo listTools per dichiarare gli strumenti disponibili e callTool per gestire le invocazioni. La documentazione include template e guide passo-passo.

MCP funziona con server remoti o solo locali?

Entrambi. Per i processi locali si usa il trasporto stdio (il più semplice). Per server remoti si usa HTTP con Server-Sent Events (SSE), che permette connessioni da client a server MCP deployati nel cloud.

Quanto è maturo l’ecosistema MCP?

MCP è stato rilasciato da Anthropic a fine 2024 e ha avuto un’adozione rapida. Nel 2026 l’ecosistema conta centinaia di server disponibili e supporto in crescita da parte di altri vendor AI. Per i casi d’uso più comuni (filesystem, database, browser, git) esistono implementazioni stabili e mantenute.

Condividi

Articoli Recenti

Categorie popolari

AltroCSSJSTipsGuide

Potrebbe interessarti: