Model Context Protocol (MCP) con Claude: guida completa all'implementazione

Il Model Context Protocol (MCP) è il nuovo standard di Anthropic per connettere gli agenti Claude ai vostri strumenti, database e servizi aziendali. Lanciato ufficialmente a giugno 2026 e integrato in Claude Sonnet 5, MCP permette ai vostri agenti IA di accedere direttamente ai vostri dati senza ricorrere a integrazioni improvvisate o hacky API.

Se state costruendo agenti IA nel 2026, MCP non è più opzionale, è la fondazione. Ecco come implementarlo.

Cos'è davvero il model context protocol?

MCP non è una nuova API per chiamare Claude (avete già quella). È un protocollo di interoperabilità che definisce come un'applicazione client (Claude, Cursor, Grok Build, o la vostra IA personalizzata) si connette a server MCP che espongono strumenti, risorse e dati.

Analogia: MCP sta a Claude come i plugin stanno a un browser. Eccetto che è standardizzato, bidirezionale e pensato per l'IA.

Componenti chiave:

• Client MCP: Claude, il vostro agente IA, o la vostra applicazione
• Server MCP: endpoint che espone strumenti e risorse
• Risorse: dati che il server mette a disposizione (database, file, API)
• Strumenti: funzioni che l'agente può chiamare per completare un'azione
• Prompt: template riutilizzabili per guidare Claude

È esattamente quello che ha fatto Simple Booking a giugno 2026, hanno costruito un server MCP che espone il loro sistema di prenotazione CRS, e ora Claude può direttamente consultare/modificare le prenotazioni alberghiere.

Architettura: come si incastrano le cose

Prima di MCP, l'architettura era caotica:

Claude (tramite API)
    ↓ [manual prompt engineering]
    ↓ [tool_use call]
Application -> [You parse the response] -> Custom integration
    ↓
Database

Con MCP:

Claude (tramite client MCP)
    ↓
MCP Client Protocol (standardizzato JSON-RPC)
    ↓
Il vostro Server MCP
    ↓ [reconnessione automatica]
    ↓
I vostri strumenti (funzioni), risorse (dati), prompt

L'agente Claude può ora:

• Interrogare direttamente le vostre risorse: "Quanti ordini sono in sospeso?" -> richiesta MCP -> il vostro database
• Chiamare i vostri strumenti atomicamente: "Crea una fattura" -> MCP tool call -> la vostra logica aziendale
• Riutilizzare prompt ottimizzati: use_mcp_resource("context_fatturazione") -> template coerente su tutti gli agenti

Come implementare un server MCP minimalista

Il protocollo MCP usa JSON-RPC 2.0 su stdio o HTTP. Ecco un server minimalista in Python che espone un database PostgreSQL:

from MCP.server import Server
from MCP.types import Tool, Resource, TextContent
import asyncio
import psycopg2

app = Server("my-database-server")

# Dichiara una risorsa: l'elenco dei clienti
@app.resource("db://customers")
async def get_customers():
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id, name, email FROM customers LIMIT 100")
    rows = cur.fetchall()
    conn.close()
    
    return TextContent(
        type="text/plain",
        text="\n".join([f"ID: {r[0]}, Name: {r[1]}, Email: {r[2]}" for r in rows])
    )

# Dichiara uno strumento: creare un nuovo ordine
@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO orders (customer_id, items, total, status) VALUES (%s, %s, %s, %s)",
        (customer_id, str(items), total, "pending")
    )
    conn.commit()
    order_id = cur.lastrowid
    conn.close()
    
    return f"Order {order_id} created successfully"

if __name__ == "__main__":
    asyncio.run(app.run())

Sono 30 righe. Nessun parsing manuale, nessun prompt engineering complicato. Claude sa ora che può:

1. Chiamare get_customers per vedere i clienti
2. Chiamare create_order(customer_id, items, total) per creare un ordine

Ma attenzione, c'è una trappola. State esponendo direttamente il vostro database. E se Claude avesse un'allucinazione su un customer_id invalido? Dovete aggiungere della validazione:

@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    # Validazione: il cliente esiste davvero?
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id FROM customers WHERE id = %s", (customer_id,))
    if not cur.fetchone():
        return f"Error: customer {customer_id} does not exist"
    
    # Continua con la creazione dell'ordine...

Limitazione onesta: più funzionalità esponete tramite MCP, più dipendete da Claude per prendere buone decisioni. Un agente mal guidato può comunque causare danni. Avete bisogno di:

• Rate limiting sugli strumenti pericolosi
• Logging e audit trail
• Prompt di sistema molto chiari sui vincoli aziendali
• Test di chaos per vedere cosa succede se Claude chiama uno strumento con input strani

Connettere claude sonnet 5 al vostro server MCP

Una volta che il vostro server MCP è in place, lo richiamate tramite l'SDK Claude. Claude Sonnet 5 (lanciato il 30 giugno 2026) ha un supporto MCP nativo integrato.

from anthropic import Anthropic

client = Anthropic()

# Configura il server MCP per questa sessione
mcp_config = {
    "servers": {
        "my_database": {
            "command": "python",
            "args": ["./mcp_server.py"],
            "env": {"DATABASE_URL": "postgresql://..."}
        }
    }
}

response = client.messages.create(
    model="claude-sonnet-5",  # Nuovo, uscito il 30 giugno 2026
    max_tokens=2048,
    tools=[
        # MCP tools are auto-discovered from servers
    ],
    messages=[
        {
            "role": "user",
            "content": "Crea un ordine per il cliente #42: 2x prodotto A, 1x prodotto B. Totale: 150€"
        }
    ]
)

# Claude ora va a:
# 1. Parsare il messaggio dell'utente
# 2. Verificare di avere accesso allo strumento "create_order" tramite MCP
# 3. Chiamare create_order(customer_id=42, items=[...], total=150)
# 4. Ricevere la risposta dal server MCP
# 5. Continuare il dialogo

Claude Sonnet 5 aggiunge anche agentic loop migliorati, può chiamare più strumenti in sequenza senza tornare al vostro codice ogni volta. Utile per: "Recupera gli ordini in sospeso, crea fatture per ognuno, poi invia un'email."

Casi d'uso reali in produzione

1. Integrazioni alberghiere (Simple Booking, giugno 2026)

Simple Booking espone il suo sistema di prenotazione CRS tramite MCP. Le agenzie di viaggio usano Claude per:

• "Quali suite sono disponibili il 15 agosto nell'hotel di Lione?" -> Claude interroga MCP -> risposta in tempo reale
• "Prenota la suite 42 per i Dupont dal 15 al 20 agosto" -> Claude chiama lo strumento di prenotazione

Prima di MCP, erano webhook customizzati. Adesso: un server MCP standardizzato, e qualunque strumento compatibile con MCP può usarlo senza reimplementare l'integrazione.

2. Automazione media buying (Nexxen, giugno 2026)

Nexxen espone i suoi parametri di campagna, budget e audience tramite MCP. Le agenzie costruiscono agenti Claude che:

• Analizzano le performance delle campagne ("I nostri CPM stanno scendendo, perché?")
• Regolano i budget automaticamente ("Alloca il 20% del budget all'audience premium")
• Creano nuove campagne basate su brief testuali

Prima: integrazione Zapier + script custom. Adesso: un server MCP, fatto.

3. Il vostro caso d'uso: gestione di contenuti e-commerce

Avete un negozio Shopify o un sistema di prodotti customizzato. Costruite un server MCP che esponga:

• Risorsa: inventory/sku-123 -> numero di stock
• Risorsa: products/all -> catalogo completo
• Strumento: update_product_description(sku, new_desc) -> aggiorna il vostro database
• Strumento: create_bundle(products, discount) -> crea un bundle
• Prompt: contexto_revisione_catalogo -> istruzioni per Claude quando gli chiedete di rielaborare 100 schede prodotto

Esempio concreto: dite a Claude "Rivedi tutte le descrizioni dei prodotti e correggi gli errori, migliora la SEO, aggiungi le dimensioni in cm". Claude:

1. Interroga products/all tramite MCP
2. Analizza le 200 descrizioni
3. Per ogni prodotto, chiama update_product_description(sku, new_desc)
4. Fa un report

Tempo umano: 10 minuti di supervisione. Prima: un'intera giornata per il vostro team.

Gestione dei permessi e sicurezza

Un rischio maggiore: se Claude ha accesso a tutti i vostri strumenti, potrebbe chiamare una funzione pericolosa. Aggiungete controlli:

1. Delimitate gli strumenti per caso d'uso

# Invece di esporre "delete_order" globalmente
@app.tool("delete_order", scopes=["admin_only"])
async def delete_order(order_id: int):
    # Richiede un permesso speciale
    pass

2. Rate limiting

from functools import wraps

def rate_limit(max_calls=10, period=60):
    def decorator(func):
        calls = []
        async def wrapper(*args, **kwargs):
            now = time.time()
            calls = [c for c in calls if c > now - period]
            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")
            calls.append(now)
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.tool("create_order")
@rate_limit(max_calls=50, period=3600)
async def create_order(...):
    pass

3. Logging esaustivo

import logging

logger = logging.getLogger("mcp_audit")

@app.tool("delete_order")
async def delete_order(order_id: int):
    logger.warning(f"Claude called delete_order({order_id}) - action requires approval")
    # Opzionale: chiedere un'approvazione umana prima di eliminare
    return "Deletion queued for human approval"

Distribuire un server MCP in produzione

Due approcci:

1. Stdio (per lo sviluppo veloce)

Il vostro server MCP viene eseguito come processo figlio del client Claude. Semplice, ma limitato per la scalabilità.

{
  "servers": {
    "my_server": {
      "command": "python",
      "args": ["./mcp_server.py"]
    }
  }
}

2. HTTP con autenticazione (per la produzione)

{
  "servers": {
    "my_server": {
      "url": "HTTPS://MCP.mycompany.com",
      "auth": {
        "type": "bearer",
        "token": "sk_live_..."
      }
    }
  }
}

Il vostro server MCP rimane in ascolto su un endpoint HTTPS protetto, con certificati SSL e rate limiting al gateway.

Distribuzione consigliata:

• Server MCP: Docker su ECS/K8s, dietro un load balancer
• Database: PostgreSQL o MongoDB, rigorosamente in VPC privato
• Monitoring: CloudWatch, log strutturati JSON, alert su errori
• Versioning: versionare le vostre risorse e strumenti MCP (es: /API/v1/resources)

{
  "servers": {
    "database": { "command": "python", "args": ["./db_mcp.py"] },
    "email": { "command": "node", "args": ["./email_mcp.js"] },
    "shopify": { "url": "HTTPS://MCP.shopify.com" }
  }
}

Conclusione

Il Model Context Protocol risolve un problema reale: prima del 2026, ogni integrazione di agente IA era una customizzazione one-shot. Ora, è standardizzato.

Tre punti chiave da ricordare:

1. MCP è il nuovo standard per gli agenti IA nel 2026, sostituisce i hacky custom API
2. Implementare un server MCP è semplice, 50 righe di codice per esporre i vostri strumenti e dati
3. Claude Sonnet 5 ha il miglior supporto MCP nativo, se state costruendo un agente oggi, è il modello giusto

State costruendo un agente IA per il vostro business? Cominciate esponendo i vostri dati e strumenti critici tramite MCP. Poi collegateli a Claude Sonnet 5. In una settimana, automatizzate quello che prima richiedeva un intero giorno.

Avete bisogno di aiuto per implementare MCP da voi? Possiamo audit della vostra architettura attuale e proporvi un piano d'integrazione. Contattateci.