Vai al contenuto principale
Italiano— Scegli una lingua
Menu

MCP e Connettori: Lo Standard Universale

Lezione 16 di 20 Sviluppatore
In questa pagina
  1. MCP e Connettori: Lo Standard Universale
  2. Il Problema Risolto da MCP
  3. Architettura MCP
  4. Utilizzo dei Connettori OpenAI
  5. Creazione di un Server MCP in Python
  6. Esposizione delle Risorse MCP
  7. Collegamento di un Server MCP alle API Responses
  8. Pattern: Hub Multi-Connettore
  9. Sicurezza e Autenticazione
  10. Punti chiave

MCP e Connettori: Lo Standard Universale

Il Model Context Protocol (MCP) è uno standard aperto che permette ai modelli di interagire con servizi esterni attraverso un protocollo unificato. I Connettori OpenAI implementano questo standard per collegare direttamente i modelli a strumenti di terze parti all’interno delle API Responses.

Il Problema Risolto da MCP

Il problema centrale è la moltiplicazione delle integrazioni: collegare N modelli a M servizi richiede N×M integrazioni personalizzate, scritte e mantenute separatamente. Ogni nuovo servizio ti costringe a ripetere il lavoro per ogni applicazione e ogni modifica alle API rischia di rompere più integrazioni.

MCP trasforma questo prodotto in una somma: il servizio espone le sue capacità una volta sola usando il protocollo e qualsiasi client compatibile le consuma. È la stessa logica dietro i driver delle stampanti o il Language Server Protocol (LSP) negli editor di codice: la standardizzazione non rende le integrazioni più potenti, le rende economicamente sostenibili.

# Prima di MCP: integrazione manuale per ogni servizio
tools = [
    # Funzione per Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funzione per Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funzione per Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... decine di funzioni da mantenere
]

Con MCP, ogni servizio espone le sue capacità tramite un protocollo standard e il modello le consuma direttamente.

Architettura MCP

Il protocollo definisce tre concetti:

  • Server MCP: Un servizio che espone strumenti, risorse e prompt
  • Client MCP: Il sistema che consuma le capacità del server
  • Trasporto: Il canale di comunicazione tra client e server
# Un server MCP espone:
# - Strumenti: Azioni che il modello può eseguire
# - Risorse: Dati che il modello può leggere
# - Prompt: Template di prompt predefiniti

Utilizzo dei Connettori OpenAI

I Connettori sono server MCP già ospitati e mantenuti: li dichiari, ti autentichi e li consumi. Questo è il punto di ingresso naturale: non c’è bisogno di scrivere un server MCP per parlare con un servizio comune che qualcuno ha già collegato.

from openai import OpenAI

client = OpenAI()

# Esempio concettuale: connettore a un servizio esterno
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Crea un ticket Jira per il bug della homepage",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Il parametro require_approval controlla la validazione umana:

  • "always": Ogni azione richiede approvazione
  • "never": Esecuzione automatica

Creazione di un Server MCP in Python

Scrivere il proprio server diventa utile non appena un servizio interno deve essere raggiungibile da più applicazioni. La logica è la stessa di un’API interna: la scrivi una volta sola, in modo pulito, con le proprie regole di accesso, e ogni applicazione ne beneficia senza reinventare il livello di integrazione.

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

server = Server("my-crm")

@server.tool()
async def search_client(term: str, field: str = "name") -> str:
    """Cerca un cliente nel CRM interno.

    Args:
        term: Il termine di ricerca (nome, email o ID)
        field: Il campo in cui cercare (name, email, id)
    """
    # La tua logica di business
    results = await crm_database.search(term, field=field)
    return json.dumps([{
        "id": r.id,
        "name": r.name,
        "email": r.email,
        "company": r.company
    } for r in results])

@server.tool()
async def create_opportunity(
    client_id: str,
    title: str,
    amount: float,
    probability: int
) -> str:
    """Crea un'opportunità di vendita nel CRM.

    Args:
        client_id: Identificativo del cliente
        title: Titolo dell'opportunità
        amount: Importo stimato in euro
        probability: Probabilità di chiusura (0-100)
    """
    opp = await crm_database.create_opportunity(
        client_id=client_id,
        title=title,
        amount=amount,
        probability=probability
    )
    return json.dumps({"id": opp.id, "status": "created"})

Esposizione delle Risorse MCP

MCP distingue tra strumenti, che fanno qualcosa, e risorse, che forniscono qualcosa da leggere. Questa distinzione è importante perché definisce il rischio: una risorsa viene consultata senza effetti collaterali, mentre uno strumento può modificare lo stato del mondo. I controlli di approvazione si concentrano naturalmente su questi ultimi.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Stato attuale della pipeline di vendita."""
    pipeline = await crm_database.get_pipeline()
    return json.dumps({
        "total_opportunities": pipeline.count,
        "total_value": pipeline.total_value,
        "by_stage": {
            "prospecting": pipeline.prospecting,
            "qualification": pipeline.qualification,
            "proposal": pipeline.proposal,
            "negotiation": pipeline.negotiation,
            "closing": pipeline.closing
        }
    })

@server.resource("crm://client/{client_id}")
async def client_profile(client_id: str) -> str:
    """Profilo completo di un cliente."""
    client = await crm_database.get_client(client_id)
    return json.dumps({
        "name": client.name,
        "email": client.email,
        "purchase_history": client.purchases,
        "satisfaction_score": client.nps
    })

Collegamento di un Server MCP alle API Responses

# Configurazione del connettore MCP nella chiamata API
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Qual è lo stato della nostra pipeline di vendita? "
          "Crea un'opportunità per il cliente CLI-789: "
          "migrazione cloud, 50000 euro, 70% di probabilità.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Pattern: Hub Multi-Connettore

È qui che lo standard brilla davvero: più server dichiarati fianco a fianco, con il modello che compone azioni tra di loro—leggendo un ticket qui, cercando un cliente là, scrivendo una risposta altrove. Senza un protocollo comune, questo stesso flusso richiederebbe tre integrazioni specifiche e la loro manutenzione continua.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Controlla i ticket Jira aperti, invia un riepilogo su Slack "
          "e aggiorna la dashboard di Notion",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.example.com/jira",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "slack",
            "server_url": "https://mcp.example.com/slack",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "notion",
            "server_url": "https://mcp.example.com/notion",
            "require_approval": "always"
        }
    ]
)

Sicurezza e Autenticazione

# I server MCP gestiscono l'autenticazione tramite header
# o token nell'URL di configurazione

# Best practice: usa sempre require_approval per le azioni di scrittura
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Validazione umana
        "allowed_tools": ["search_client", "client_profile"],  # Limita gli strumenti
    }
]

Punti chiave

  • MCP è uno standard aperto per collegare i modelli a servizi esterni
  • I Connettori OpenAI integrano MCP direttamente nelle API Responses
  • Costruisci i tuoi server MCP per esporre servizi interni
  • Usa require_approval per controllare la validazione umana
  • Collega più server MCP in una singola chiamata per flussi di lavoro trasversali