Model Context Protocol (MCP): Guida Completa 2026

Il Model Context Protocol (MCP) è passato in poco più di un anno dall'essere un esperimento di Anthropic a uno standard universale adottato da OpenAI, Google, Microsoft, AWS, Block e Cloudflare. A marzo 2026 ha superato i 97 milioni di installazioni e a dicembre 2025 è stato donato alla Linux Foundation tramite l'Agentic AI Foundation. Numeri che raccontano un cambio di paradigma: gli LLM smettono di vivere isolati e iniziano a parlare con database, file system, API e strumenti aziendali attraverso un'unica interfaccia.

Se sei uno sviluppatore, un freelance o gestisci un'agenzia che integra AI nei progetti dei clienti, ignorare MCP nel 2026 significa lavorare con strumenti già obsoleti. In questa guida vedremo cos'è MCP, come funziona la sua architettura, come creare il tuo primo server in Python e TypeScript, quali piattaforme lo supportano oggi e quali sono i rischi di sicurezza segnalati dal CERT-AgID.

Niente fuffa: solo la guida che avrei voluto trovare quando ho iniziato a integrare MCP nei miei progetti freelance.

Cos'è il Model Context Protocol (MCP)

Il Model Context Protocol è uno standard aperto, basato su JSON-RPC 2.0, che definisce come un'applicazione AI (un client) comunica con strumenti, dati e servizi esterni (server). Anthropic l'ha presentato come "USB-C per l'intelligenza artificiale", e l'analogia regge: prima di MCP, ogni integrazione tra un LLM e un tool richiedeva codice custom incompatibile con gli altri ecosistemi.

Esempio concreto. Vuoi che la tua AI legga il calendario aziendale, recuperi dati da un database PostgreSQL e crei task su un sistema di project management? Prima di MCP avresti dovuto:

• Scrivere un connettore custom per ChatGPT con function calling proprietario
• Riscriverlo da zero per Claude con un'altra logica
• Rifarlo ancora per Gemini, Cursor o qualsiasi altro client

Con MCP scrivi un server una volta sola, e lo stesso server funziona con qualunque client compatibile con il protocollo. Per chi sviluppa software per i clienti, è una rivoluzione: il codice diventa portabile, riutilizzabile e indipendente dal vendor AI.

Perché MCP è importante nel 2026

Tre motivi pratici, non hype:

• Eliminazione del lock-in: un cliente che oggi usa Claude e domani vuole passare a Gemini non deve riscrivere le integrazioni AI.
• Ecosistema in esplosione: oltre 12.000 server MCP pubblici disponibili, dai filesystem ai gestionali aziendali.
• Governance neutrale: dopo il passaggio alla Linux Foundation, MCP non è più "il protocollo di Anthropic" ma uno standard governato da un consorzio.

Come funziona MCP: architettura tecnica

L'architettura MCP si basa su tre componenti che comunicano tra loro: host, client e server. Capirli è fondamentale prima di scrivere una sola riga di codice.

I tre componenti dell'architettura

• Host: l'applicazione AI che contiene l'LLM. Esempi: Claude Desktop, Claude Code, Cursor, Visual Studio Code con Copilot, Gemini CLI.
• Client: vive dentro l'host e gestisce la connessione con un singolo server MCP. Un host può avere più client attivi contemporaneamente, uno per server.
• Server: il programma che espone tools, resources e prompts all'LLM. È quello che scriveremo noi nei tutorial successivi.

La comunicazione tra client e server avviene tramite JSON-RPC 2.0, un protocollo leggero e ben documentato. Il trasporto può essere di due tipi:

• stdio: il server gira in locale come processo figlio del client. È il trasporto più semplice e quello che useremo nei tutorial.
• HTTP con Server-Sent Events (SSE): il server è remoto e accessibile via rete. Indispensabile per server condivisi tra utenti o deployati nel cloud.

Le tre capability di un server MCP

Ogni server MCP può esporre tre tipi di capability all'LLM:

• Tools: funzioni eseguibili che l'AI può invocare per compiere azioni. Esempi: read_file, send_email, query_database. Sono azioni attive con effetti collaterali.
• Resources: dati che l'LLM può leggere come contesto, senza modificarli. Esempi: contenuto di un file, log di sistema, una pagina web. Sono dati passivi.
• Prompts: template di prompt riutilizzabili che il server mette a disposizione del client per task specifici.

Nella maggior parte dei casi reali userai principalmente tools. Resources e prompts sono utili in scenari avanzati o quando vuoi guidare il modo in cui l'LLM interagisce con il tuo server.

Da Anthropic alla Linux Foundation: la storia di MCP

Capire la traiettoria di MCP aiuta a prendere decisioni di adozione più consapevoli. Ecco la timeline essenziale:

• Novembre 2024: Anthropic rilascia MCP come progetto open source, con SDK ufficiali per Python e TypeScript.
• Marzo 2025: OpenAI annuncia il supporto MCP nei propri prodotti, segnando la fine della frammentazione tra protocolli AI proprietari.
• Estate 2025: Google DeepMind, Microsoft e AWS aderiscono allo standard. Nascono SDK ufficiali in Java, C#, Go e Kotlin.
• Dicembre 2025: Anthropic dona MCP all'Agentic AI Foundation (AAIF) della Linux Foundation, co-fondata con OpenAI, Block, Google, Microsoft, AWS e Cloudflare.
• Marzo 2026: il protocollo supera i 97 milioni di installazioni complessive e il count dei server pubblici tocca quota 12.000.

Il passaggio alla Linux Foundation è il dettaglio che cambia tutto per chi sviluppa per i clienti. Significa che MCP è diventato una dipendenza neutrale, non controllata da un singolo player commerciale, e quindi sicura da adottare anche in contesti enterprise dove il vendor lock-in è un problema serio.

Quali piattaforme supportano MCP nel 2026

L'ecosistema client si è ampliato molto rispetto al lancio. Ecco le principali piattaforme che supportano MCP a maggio 2026:

Client / Host	Vendor	Tipo	Note
Claude Desktop	Anthropic	App desktop	Integrazione più matura, supporto completo a tools, resources, prompts
Claude Code	Anthropic	CLI sviluppatori	Tool Search attivo per default dal 2026: caricamento lazy fino a -95% di context
ChatGPT Desktop	OpenAI	App desktop	Supporto MCP via Codex e Agents SDK
Cursor	Cursor	IDE AI	Limite di 40 strumenti per server, ma supporta server multipli
Gemini CLI	Google	CLI sviluppatori	Supporto nativo MCP, SDK ufficiale Go in collaborazione con Anthropic
Microsoft Copilot Studio	Microsoft	Piattaforma agenti	Pensato per scenari enterprise, supporta OAuth 2.0 nativamente
Continue, Cline, Goose	Open source	IDE / CLI	Alternative open source, ottime per sviluppo locale

Una novità importante del 2026 è Tool Search, attivo per default in Claude Code: invece di caricare tutte le definizioni dei tool all'avvio, il client carica solo i nomi e recupera lo schema completo on-demand quando serve. Il risultato è una riduzione fino al 95% del consumo di contesto, che permette di avere decine di server MCP connessi senza penalizzare la lunghezza delle conversazioni.

Tutorial: creare un MCP server in Python

Mettiamo le mani in pasta. In questa sezione costruiremo un server MCP completo in Python che espone due tool: uno per leggere un file di testo locale e uno per cercare un termine all'interno. È minimale ma riutilizzabile come scheletro per progetti più complessi.

Prerequisiti

• Python 3.10 o superiore (verifica con python3 --version)
• Il modulo venv per creare un ambiente virtuale isolato
• Un editor di codice (VS Code, PyCharm, qualsiasi cosa)
• Claude Desktop o Claude Code installati per testare il server

Step 1: setup ambiente virtuale

Apri il terminale e crea una nuova cartella per il progetto:

mkdir mcp-tutorial-python
cd mcp-tutorial-python
python3 -m venv .venv
source .venv/bin/activate  # su Windows: .venv\Scripts\activate
pip install fastmcp

FastMCP è il framework Python ufficiale per costruire server MCP rapidamente, con un'API basata su decoratori che ricorda Flask o FastAPI.

Step 2: scrivi il server

Crea un file server.py con il seguente contenuto:

from fastmcp import FastMCP
from pathlib import Path

mcp = FastMCP("File Tools")

@mcp.tool()
def read_file(path: str) -> str:
    """Legge il contenuto di un file di testo dato un path assoluto."""
    file_path = Path(path)
    if not file_path.exists():
        return f"Errore: il file {path} non esiste."
    if not file_path.is_file():
        return f"Errore: {path} non e' un file."
    return file_path.read_text(encoding="utf-8")

@mcp.tool()
def search_in_file(path: str, term: str) -> list[str]:
    """Cerca un termine in un file e restituisce le righe che lo contengono."""
    file_path = Path(path)
    if not file_path.exists():
        return [f"Errore: il file {path} non esiste."]
    matching_lines = []
    for i, line in enumerate(file_path.read_text(encoding="utf-8").splitlines(), 1):
        if term.lower() in line.lower():
            matching_lines.append(f"Riga {i}: {line.strip()}")
    return matching_lines or ["Nessun risultato trovato."]

if __name__ == "__main__":
    mcp.run()

Cosa succede in queste poche righe? Il decoratore @mcp.tool() registra automaticamente la funzione come tool MCP, deduce lo schema dei parametri dai type hint Python e usa la docstring come descrizione che l'LLM vede quando decide se invocare il tool.

Step 3: testa il server localmente

Prima di collegarlo a un client, puoi testare il server con il comando ispettivo integrato:

fastmcp dev server.py

Si apre una UI web che permette di vedere i tool registrati, invocarli manualmente con parametri di prova e ispezionare le risposte. È il modo più veloce per debuggare il server senza passare da Claude Desktop.

Step 4: collega il server a Claude Desktop

Apri il file di configurazione di Claude Desktop. Il path varia per sistema operativo:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

Aggiungi la configurazione del tuo server:

{
  "mcpServers": {
    "file-tools": {
      "command": "/percorso/assoluto/al/python3",
      "args": ["/percorso/assoluto/al/server.py"]
    }
  }
}

Riavvia Claude Desktop. Apri una conversazione e chiedi: "Leggi il file /tmp/test.txt e dimmi cosa contiene." Claude rileverà il tool read_file, ti chiederà conferma per l'esecuzione e ti restituirà il contenuto.

Tutorial: creare un MCP server in TypeScript

Per chi preferisce Node.js, l'SDK TypeScript ufficiale offre la stessa esperienza developer-friendly di FastMCP. Costruiamo lo stesso server di prima ma in TypeScript, in modo da poter scegliere il linguaggio in base al progetto.

Step 1: inizializza il progetto Node

mkdir mcp-tutorial-ts
cd mcp-tutorial-ts
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx
npx tsc --init

Apri tsconfig.json e assicurati che "module" sia impostato su "NodeNext" e "target" su "ES2022" o superiore.

Step 2: scrivi il server TypeScript

Crea un file src/server.ts con questo contenuto:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { readFileSync, existsSync, statSync } from "node:fs";

const server = new McpServer({
  name: "file-tools-ts",
  version: "1.0.0",
});

server.tool(
  "read_file",
  "Legge il contenuto di un file di testo dato un path assoluto.",
  { path: z.string().describe("Path assoluto del file") },
  async ({ path }) => {
    if (!existsSync(path)) {
      return { content: [{ type: "text", text: `Errore: ${path} non esiste.` }] };
    }
    if (!statSync(path).isFile()) {
      return { content: [{ type: "text", text: `Errore: ${path} non e' un file.` }] };
    }
    const content = readFileSync(path, "utf-8");
    return { content: [{ type: "text", text: content }] };
  }
);

server.tool(
  "search_in_file",
  "Cerca un termine in un file e restituisce le righe che lo contengono.",
  {
    path: z.string().describe("Path assoluto del file"),
    term: z.string().describe("Termine da cercare"),
  },
  async ({ path, term }) => {
    if (!existsSync(path)) {
      return { content: [{ type: "text", text: `Errore: ${path} non esiste.` }] };
    }
    const lines = readFileSync(path, "utf-8").split("\n");
    const matches = lines
      .map((line, i) => ({ line, n: i + 1 }))
      .filter(({ line }) => line.toLowerCase().includes(term.toLowerCase()))
      .map(({ line, n }) => `Riga ${n}: ${line.trim()}`);
    const text = matches.length ? matches.join("\n") : "Nessun risultato trovato.";
    return { content: [{ type: "text", text }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

L'SDK TypeScript usa Zod per definire lo schema dei parametri: è più verboso del decoratore Python, ma offre validazione runtime e autocompletamento eccellente nell'editor.

Step 3: avvia il server e collegalo

Aggiungi questo script al tuo package.json:

"scripts": {
  "start": "tsx src/server.ts"
}

Poi, nella configurazione di Claude Desktop, aggiungi:

{
  "mcpServers": {
    "file-tools-ts": {
      "command": "npx",
      "args": ["tsx", "/percorso/assoluto/al/src/server.ts"]
    }
  }
}

Riavvia Claude Desktop e il server è pronto. Per chi vuole approfondire l'ecosistema degli strumenti AI per sviluppatori, ho raccolto i migliori in questa selezione di skill, repository e tips per Claude Code.

Configurare il client: Claude Desktop, Claude Code e Cursor

Ogni client ha piccole specificità nella gestione dei server MCP. Vediamo le differenze pratiche per i tre più diffusi tra freelance e agenzie.

Claude Desktop

È il client più diffuso e ha l'integrazione MCP più matura. La configurazione passa esclusivamente dal file claude_desktop_config.json e i tool diventano disponibili in tutte le conversazioni dopo il riavvio. Il limite pratico senza Tool Search è di circa 10 server con 80 strumenti totali attivi simultaneamente.

Claude Code

Pensato per chi sviluppa, Claude Code aggiunge il Tool Search attivo di default dal 2026. Il vantaggio è enorme: puoi avere connessi decine di server MCP senza preoccuparti del context window, perché le definizioni complete dei tool vengono caricate solo quando l'AI ne ha effettivamente bisogno per un task. Per chi non lo conosce, ho preparato una cheatsheet completa di Claude Code con tutti i comandi e le configurazioni avanzate.

Cursor

Cursor supporta MCP nativamente da metà 2025. Ha un limite di 40 strumenti per singolo server, ma puoi connettere più server in parallelo. La configurazione si fa direttamente dalla UI dell'IDE, non da file JSON, il che velocizza il setup per chi non vuole toccare la riga di comando.

Casi d'uso reali per freelance, agenzie e PMI italiane

Lasciamo la teoria e parliamo di scenari concreti. Ecco dove MCP fa la differenza in progetti reali, soprattutto in contesti italiani dove le PMI hanno gestionali e flussi specifici.

Gestione contenuti e blog

Un server MCP collegato al CMS aziendale permette di chiedere all'AI di pubblicare articoli, aggiornare prodotti o cercare contenuti senza passare dal pannello admin. È particolarmente potente per content team che gestiscono molti siti contemporaneamente.

E-commerce e gestione ordini

Per chi gestisce un negozio online, un MCP server può esporre tool per consultare ordini, stato spedizioni, magazzino e statistiche di vendita. La combinazione con un workflow n8n alle spalle permette di automatizzare risposte ai clienti basate su dati real-time. Se vuoi capire come integrare questi strumenti nel tuo negozio, dai un'occhiata ai miei servizi di sviluppo e-commerce custom.

CRM e gestionali

Esporre un CRM via MCP significa permettere a un assistente AI di creare lead, aggiornare anagrafiche e generare report direttamente dalla chat. Su gestionali italiani come fatturazione elettronica e contabilità, è il modo più veloce per dare all'AI accesso a dati strutturati senza esporre l'intero database.

Documentazione tecnica e knowledge base

Un server MCP che indicizza la documentazione interna trasforma l'AI in un assistente che risponde con il contesto reale dell'azienda, non con generiche conoscenze pre-addestrate. È uno dei casi d'uso con ROI più rapido in contesti aziendali.

Automazione di processi ripetitivi

Per le PMI, esporre via MCP i tool che lo staff usa quotidianamente — dal generatore di preventivi al controllo magazzino — significa avere un agente AI che esegue task multi-step. Ho approfondito questo scenario nella mia guida agli agenti AI per le aziende, dove parlo di costi, piattaforme e implementazione pratica.

Sicurezza MCP: i rischi segnalati dal CERT-AgID

Aprile 2026, il CERT-AgID ha pubblicato uno studio dedicato ai rischi di sicurezza degli LLM connessi tramite MCP. È una lettura obbligata per chi adotta il protocollo in contesti professionali. Ecco i punti chiave.

Il problema della catena prompt → tool → azione

Quando un LLM agentico usa MCP, il confine della sicurezza si sposta. Non basta più chiedersi "cosa risponde l'AI", bisogna chiedersi "quali azioni può compiere". Un prompt malevolo può manipolare l'LLM affinché invochi tool MCP in modo improprio, ad esempio facendo richieste di rete arbitrarie attraverso un server MCP progettato per fini legittimi.

Vulnerabilità da prompt injection

Il rischio più documentato è la prompt injection indiretta: un MCP server che recupera contenuti esterni (pagine web, email, documenti) potrebbe trovare istruzioni nascoste nei dati recuperati che, una volta interpretate dall'LLM, causano l'esecuzione di azioni non autorizzate.

Best practice di sicurezza

• Principio del minimo privilegio: ogni server MCP espone solo i tool strettamente necessari, mai funzionalità "future use".
• Validazione rigorosa degli input: tratta i parametri dei tool come potenzialmente ostili, anche quando vengono dall'LLM stesso.
• Allow-list dei domini per i tool che fanno chiamate di rete, mai consentire URL arbitrari.
• Logging completo: registra ogni invocazione di tool con parametri e risultati, per audit successivi.
• Autenticazione su server remoti: usa OAuth 2.0 per server HTTP esposti pubblicamente, mai chiavi API in chiaro nelle config.
• Sandboxing: per operazioni rischiose come esecuzione di codice o accesso al filesystem, usa container o ambienti isolati.

La regola d'oro: ogni tool che esponi via MCP è un endpoint pubblico ai fini di sicurezza, anche se gira in locale. Trattalo come tale fin dal primo giorno.

MCP vs alternative: function calling, plugin OpenAI, Custom GPT

Prima di MCP esistevano già modi per dare strumenti agli LLM. Capire le differenze ti aiuta a scegliere quando MCP è sovradimensionato e quando è invece l'unica scelta razionale.

Soluzione	Portabilità	Riutilizzabilità	Quando usarla
MCP	Alta (cross-vendor)	Alta (un server, molti client)	Integrazioni durature, multi-client, progetti enterprise
Function calling proprietario (OpenAI, Anthropic API diretta)	Bassa (vincolato al vendor)	Bassa (codice specifico)	Prototipi rapidi, integrazione monolite
Plugin ChatGPT (legacy)	Nulla (deprecati)	Nulla	Solo manutenzione di sistemi esistenti
Custom GPT	Bassa (solo ChatGPT)	Bassa	Use case end-user senza esigenze di portabilità
LangChain Tools	Media	Alta nel framework	Pipeline complesse multi-step in Python

La regola pratica: per qualsiasi integrazione che durerà più di qualche mese e che potrebbe dover passare tra vendor AI diversi, MCP è la scelta giusta. Per prototipi usa-e-getta, function calling diretto è ancora più rapido. Per un confronto pratico tra ambienti di sviluppo AI, ho scritto una comparazione tra Claude Code e Codex di OpenAI basata su settimane di uso reale.

Roadmap MCP 2026: dove sta andando il protocollo

La roadmap ufficiale 2026 della Linux Foundation ha definito quattro priorità su cui lavorano i Working Group:

• Transport scalability: miglioramenti al trasporto HTTP/SSE per gestire server con migliaia di tool e connessioni concorrenti senza degrado delle performance.
• Agent communication: standardizzazione di come più agenti AI possono coordinarsi tra loro tramite server MCP intermediari, abilitando workflow multi-agente.
• Governance maturation: processo formale per le Spec Enhancement Proposals (SEP), con priorità trasparenti e timeline pubbliche.
• Enterprise readiness: estensioni per autenticazione avanzata, audit logging strutturato, multi-tenancy e conformità normativa.

Il messaggio importante: la maggior parte delle novità enterprise arriverà come estensioni opzionali, non come modifiche core al protocollo. Significa che gli MCP server scritti oggi continueranno a funzionare senza modifiche per anni.

Conclusione: perché iniziare oggi con MCP

Il Model Context Protocol non è una moda passeggera. È l'infrastruttura su cui si sta costruendo l'intera generazione successiva di applicazioni AI: dal coding agentico agli assistenti enterprise, dai workflow di produttività personale alle integrazioni in ambito industriale. Avere un MCP server nel tuo toolkit nel 2026 è come avere conoscenze di REST nel 2010: non è opzionale, è la base.

Per chi sviluppa software per i clienti, MCP rappresenta un'occasione concreta per offrire integrazioni AI portabili, che resistono ai cambi di vendor e che si integrano nei sistemi esistenti senza riscrivere tutto. Se vuoi parlarne per un progetto reale o capire come MCP può integrarsi nella tua infrastruttura, contattami per un confronto tecnico: lavoro su MCP da quando è uscito e l'ho implementato in diversi progetti freelance.

Leggi anche

• Claude Code Cheatsheet 2026: Guida Completa per Sviluppatori
• Claude Code Skill: 15 Estensioni, Repo e Tips 2026
• Agenti AI per Aziende: Guida Completa e Pratica
• Claude Code vs Codex: Confronto Definitivo 2026
• Claude Cowork: Guida Completa al Tuo Assistente AI 2026
• Claude Opus 4.7 e Claude Design: novità Anthropic 2026