Il Tuo Agente AI è Inutile Senza Questo

Perché MCP è l'USB-C dell'Intelligenza Artificiale.

Hai costruito un agente AI. Forse è anche buono. I prompt sono solidi, il modello è veloce e le risposte sembrano naturali.

Poi qualcuno gli chiede di controllare Salesforce per un record cliente. O di recuperare gli ultimi ticket Jira. O di cercare nella documentazione interna.

E il tuo bellissimo agente semplicemente… non può.

Questo è il problema di integrazione che ogni piattaforma AI prima o poi affronta. Il tuo agente ha bisogno di mani. Ha bisogno di occhi sui tuoi sistemi aziendali reali. Senza di essi, stai solo gestendo un chatbot costoso.

La soluzione tradizionale? Scrivere un wrapper API personalizzato per ogni singolo servizio a cui vuoi connetterti. Leggere la loro documentazione, gestire la loro autenticazione, affrontare i loro rate limit, sperare che non cambino gli endpoint il mese prossimo. Poi rifarlo per il servizio successivo. E poi per il successivo ancora.

Il Model Context Protocol cambia completamente questo calcolo.

Cosa Risolve Davvero MCP

Pensa all’USB prima dell’USB-C. Avevi Mini-USB, Micro-USB, connettori proprietari Apple e un cassetto pieno di cavi che funzionavano solo con dispositivi specifici. L’USB-C non ha solo aggiunto un nuovo connettore — ha stabilito uno standard per cui qualsiasi cavo può funzionare con qualsiasi dispositivo.

MCP sta facendo la stessa cosa per le integrazioni degli agenti AI.

Invece di scrivere codice personalizzato per connettere il tuo agente a Salesforce, HubSpot, GitHub o qualsiasi altro servizio, implementi il protocollo una volta (o scarichi un server preconfigurato) e qualsiasi agente compatibile con MCP può parlargli immediatamente.

Il protocollo gestisce il livello di comunicazione. Tu definisci solo cosa fanno i tuoi tool e di quali dati hanno bisogno.

Configurare Integrazioni Multiple

Mastra ha supporto nativo per MCP tramite il suo MCPClient. Puoi connettere sia tool locali (eseguiti come processi figlio) sia servizi remoti (in esecuzione sulla propria infrastruttura).

Ecco una configurazione di produzione realistica che connette Google Maps per il routing, un servizio meteo e una ricerca Wikipedia locale:

import { MCPClient } from '@mastra/mcp';

export const mcpClient = new MCPClient({
  servers: {
    // Local tool (Stdio)
    wikipedia: {
      command: 'npx',
      args: ['-y', 'wikipedia-mcp'],
    },
    // Maps & Navigation (Remote/HTTP)
    googleMaps: {
      url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.GOOGLE_MAPS_API_KEY}`,
        },
      },
    },
    // Weather Service Integration
    weather: {
      url: new URL('https://mcp.weatherapi.dev/v1'),
      requestInit: {
        headers: {
          'X-API-Key': process.env.WEATHER_API_KEY!,
        },
      },
    },
  },
});

Il client gestisce il ciclo di vita della connessione, gestisce lo spawn di processi per i tool locali e mantiene connessioni HTTP per i server remoti. Non tocchi socket o stdio direttamente.

Connettere i Tool agli Agenti

Una volta configurato il client MCP, fornire questi tool a un agente è semplice:

import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { mcpClient } from '../mcp';

export const navigationDirectionsAgent = new Agent({
  id: 'navigation-directions-agent',
  name: 'Navigation & Directions Assistant',
  instructions: `You are a helpful navigation assistant that provides route planning and travel advice.
    - Always confirm the start and destination locations
    - Use Google Maps tools to find optimal routes
    - Check weather conditions along the route
    - Provide estimated travel times and suggest alternatives if weather is poor
    - Include relevant details like traffic, road conditions, and points of interest
    - Keep responses clear and actionable`,
  model: openai('gpt-5'),
  tools: await mcpClient.getTools(), // <--- This is the magic line
});

Quando un utente chiede: “Qual è il percorso migliore da San Francisco a Lake Tahoe, e dovrei preoccuparmi del meteo?”

L’agente legge le definizioni dei tool disponibili, si rende conto di avere accesso ai tool di routing di Google Maps e alle previsioni meteo, li esegue con i parametri corretti e risponde con un percorso ottimale più le condizioni meteo attuali lungo il tragitto.

Non hai scritto una singola riga di codice per l’API di Google Maps o per l’integrazione del servizio meteo.

Autenticazione Per-Utente

C’è un errore di sicurezza facile da fare qui: hardcoded delle credenziali.

Se metti una chiave API di Google Maps nelle variabili d’ambiente e la chiami fatta, ogni utente condivide la stessa quota e gli stessi rate limit. Ancora più importante, se usi servizi che memorizzano le preferenze degli utenti (come posizioni salvate o percorsi preferiti), tutti vedrebbero gli stessi dati. Funziona bene per le demo. È una responsabilità in produzione.

Mastra gestisce questo permettendoti di creare client MCP in modo dinamico con credenziali specifiche per utente:

async function handleUserRequest(userPrompt: string, userCredentials: UserCreds) {
  // Create a client for THIS specific user
  const userMcp = new MCPClient({
    servers: {
      googleMaps: {
        url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
        requestInit: {
          headers: {
            // User's specific API key or token
            Authorization: `Bearer ${userCredentials.mapsApiKey}`,
            'X-User-ID': userCredentials.userId,
          },
        },
      },
    },
  });

  const agent = mastra.getAgent('navigationDirectionsAgent');

  // Inject tools at runtime
  const response = await agent.generate(userPrompt, {
    toolsets: await userMcp.getToolsets(),
  });

  return response;
}

Ogni utente ottiene il proprio toolset isolato con le proprie quote API e preferenze. Le posizioni salvate dell’Utente A restano private, la cronologia dei percorsi dell’Utente B è separata. Ecco come funzionano nella pratica gli agenti SaaS multi-tenant.

Costruire Tool Compositi

A volte è necessario combinare più tool MCP in una singola operazione. Forse vuoi pianificare un percorso che tenga conto sia del traffico in tempo reale sia delle condizioni meteo lungo il tragitto.

Puoi avvolgere i tool MCP in definizioni di tool personalizzate:

export const smartRouteTool = createTool({
  id: 'smart-route-planner',
  description: 'Plans optimal route considering traffic and weather conditions',
  execute: async ({ context, mastra }) => {
    // Get the raw tools
    const tools = await mcpClient.getTools();

    // 1. Get base route from Google Maps
    const routeData = await tools.googleMaps_getDirections.execute({
      context: {
        origin: context.origin,
        destination: context.destination
      }
    });

    // 2. Check weather along the route
    const weatherData = await tools.weather_getForecast.execute({
      context: { coordinates: routeData.waypoints }
    });

    // 3. Return enhanced route with weather warnings
    return {
      ...routeData,
      weatherAlerts: weatherData.alerts,
      recommendation: weatherData.severe ? 'Consider delaying trip' : 'Safe to travel'
    };
  },
});

Questo ti dà un controllo granulare su come esattamente i tool interagiscono, sfruttando comunque il protocollo MCP per il lavoro pesante.

Dove Porta Tutto Questo

Scrivere client API personalizzati per ogni servizio con cui il tuo agente AI deve parlare non è mai stato sostenibile. Scala male, si rompe spesso e lega la tua piattaforma a implementazioni specifiche.

MCP non risolve ogni sfida di integrazione — l’autenticazione resta complessa, il rate limiting conta ancora, e non ogni servizio ha un server MCP. Ma stabilisce una fondazione che rende la costruzione di piattaforme agent significativamente meno dolorosa.

Se stai progettando un sistema AI che deve interagire con servizi esterni, capire MCP probabilmente vale il tuo tempo.

Risorse

Leggi la Serie

LLM Routing
Security & Guardrails
MCP & Tool Integrations (Questo Post)
Workflows & Memory