MCP — Model Context Protocol

Cos'è MCP e perché esiste

Il Model Context Protocol (MCP) è un protocollo aperto, pubblicato da Anthropic a fine 2024, che standardizza il modo in cui le applicazioni AI si connettono a fonti di dati e strumenti esterni. Pensalo come un protocollo universale — anziché costruire integrazioni custom per ogni servizio (GitHub, Slack, database, filesystem...), MCP definisce un'interfaccia comune.

Il problema che risolve è concreto: ogni provider AI ha il suo formato per il "tool use" (OpenAI ha function calling, Anthropic ha tool use, Google ha function declarations). Ogni integrazione va costruita da zero. MCP propone un layer di astrazione condiviso.

Architettura: Host, Client, Server

MCP segue un'architettura client-server con tre ruoli:

• Host — l'applicazione che l'utente usa (Claude Desktop, un IDE, una CLI). L'host ospita uno o più client MCP
• Client — il componente che gestisce la connessione con un server MCP. Ogni client parla con un solo server
• Server — il servizio che espone strumenti, risorse o prompt. Esempio: un MCP server per GitHub che espone tool come create_issue, list_repos

Il protocollo è basato su JSON-RPC 2.0. Ogni messaggio è un oggetto JSON con method, params e id. Il client invia richieste, il server risponde.

Transport: come comunicano client e server

MCP supporta diversi meccanismi di trasporto:

stdio

Il server gira come processo figlio dell'host. Comunicano via stdin/stdout. Semplice, locale, zero configurazione di rete. Ideale per tool da sviluppatore.

// Configurazione MCP in Claude Desktop (claude_desktop_config.json)
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/docs"]
    }
  }
}json

HTTP + SSE (Server-Sent Events)

Il client si connette via HTTP. Il server invia aggiornamenti in tempo reale tramite SSE. Adatto per server remoti e deployment cloud.

Streamable HTTP

La versione più recente del transport. Supporta streaming bidirezionale su HTTP, senza la necessità di una connessione SSE persistente. Più robusto per ambienti serverless.

Capabilities: cosa può esporre un server

Un MCP server può esporre quattro tipi di capability:

Tools

Azioni che il modello può invocare. Ogni tool ha un nome, una descrizione e uno schema JSON per i parametri. Esempio: create_issue su GitHub, send_email, query_database.

# Definizione di un tool MCP in Python
from mcp.server import Server
from mcp.types import Tool

server = Server("weather-server")

@server.tool()
async def get_weather(city: str) -> str:
    """Ottieni il meteo corrente per una città."""
    # Logica per chiamare API meteo
    data = await fetch_weather_api(city)
    return f"{city}: {data['temp']}°C, {data['description']}"python

Resources

Dati strutturati che il modello può leggere. Simili a endpoint REST readonly. Esempio: il contenuto di un file, una pagina di documentazione, un record del database. Le risorse hanno URI e possono essere aggiornate dinamicamente.

Prompts

Template di prompt riutilizzabili che il server espone. L'host può mostrarli all'utente come scorciatoie. Esempio: un prompt "Analizza questo codice" con parametri per il linguaggio e il livello di dettaglio.

Sampling

Permette al server di chiedere al modello AI di generare testo. Utile per server che hanno bisogno di ragionamento AI come parte della loro logica. Ad esempio, un server di code review che usa il modello per analizzare il diff.

Come creare un MCP server

Creare un MCP server è sorprendentemente semplice. Ecco un esempio completo in Python:

# server.py — MCP server per note
from mcp.server import Server
from mcp.server.stdio import stdio_server
import json

server = Server("notes-server")
notes = {}

@server.tool()
async def add_note(title: str, content: str) -> str:
    """Aggiungi una nuova nota."""
    notes[title] = content
    return f"Nota '{title}' salvata."

@server.tool()
async def list_notes() -> str:
    """Lista tutte le note salvate."""
    if not notes:
        return "Nessuna nota salvata."
    return json.dumps(notes, indent=2)

@server.tool()
async def search_notes(query: str) -> str:
    """Cerca nelle note per parola chiave."""
    results = {
        k: v for k, v in notes.items()
        if query.lower() in k.lower() or query.lower() in v.lower()
    }
    return json.dumps(results, indent=2) if results else "Nessun risultato."

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())python

Per TypeScript, il processo è analogo con @modelcontextprotocol/sdk:

// server.ts — MCP server in TypeScript
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-server",
  version: "1.0.0"
}, {
  capabilities: { tools: {} }
});

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "greet",
    description: "Saluta qualcuno per nome",
    inputSchema: {
      type: "object",
      properties: { name: { type: "string" } },
      required: ["name"]
    }
  }]
}));

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

MCP server popolari

La lista completa è in crescita costante. Il MCP Registry (in fase di sviluppo) sarà il repository centrale per scoprire e installare server MCP.

Sicurezza e permessi

MCP introduce diverse meccaniche di sicurezza:

• Principle of Least Privilege — ogni server ha accesso solo a ciò che serve. Un server filesystem può accedere solo alle directory configurate.
• Conferma umana — l'host può richiedere conferma all'utente prima di eseguire operazioni sensibili (write, delete, invio messaggi)
• Input sanitization — il server deve validare tutti i parametri ricevuti dal modello
• Rate limiting — protezione contro l'uso eccessivo di risorse

MCP vs function calling tradizionale

MCP non sostituisce il function calling — lo standardizza. Un server MCP può essere usato con qualsiasi host che supporta il protocollo, senza riscrivere l'integrazione. Piattaforme come ChipsBuilder (un website builder AI) e ChipsBot (piattaforma per creare chatbot) utilizzano già questo pattern per connettere l'AI a strumenti e dati di dominio.

Il futuro dello standard

MCP sta evolvendo rapidamente. Le direzioni principali:

• Registry centralizzato — un "npm" per i server MCP, con discovery, versioning e review
• Autenticazione OAuth — supporto nativo per autenticazione delegata
• Multi-tenant — un singolo server che serve più utenti con permessi diversi
• Adozione cross-provider — OpenAI, Google e altri stanno valutando il supporto MCP
• Server compositi — server che aggregano e orchestrano altri server

La scommessa di MCP è che il valore di un ecosistema aperto supera i vantaggi di soluzioni proprietarie. Se riesce, ogni tool costruito per un host funzionerà con tutti gli altri — un moltiplicatore enorme per l'ecosistema AI.

Per approfondire

• Scopri come MCP si integra nei sistemi agentici nella sezione Orchestrazione
• Vedi come ChipsBot usa MCP per connettere bot specialisti nel caso studio
• Combina MCP con RAG per dare ai tool accesso a conoscenza specifica