Esecuzione di codice con MCP: creare agenti AI più efficienti

Il Model Context Protocol (MCP) è uno standard aperto e innovativo, progettato per collegare gli agenti di intelligenza artificiale a sistemi esterni. Tradizionalmente, la connessione degli agenti a strumenti e dati richiedeva un'integrazione personalizzata per ogni singola coppia. Questo approccio creava una frammentazione significativa e uno sforzo duplicato, rendendo estremamente difficile scalare sistemi realmente interconnessi in modo efficiente. MCP risolve questa problematica fornendo un protocollo universale: gli sviluppatori implementano MCP una sola volta nel loro agente, sbloccando così un intero ecosistema di integrazioni disponibili.

Dal suo lancio nel novembre 2024, l'adozione di MCP è stata straordinariamente rapida. La comunità ha già costruito migliaia di server MCP, e gli SDK sono disponibili per tutti i principali linguaggi di programmazione, facilitando l'integrazione per una vasta gamma di sviluppatori. L'industria ha rapidamente riconosciuto il valore di MCP, adottandolo come lo standard de facto per connettere gli agenti a strumenti e dati. Oggi, gli sviluppatori costruiscono routine agenti con accesso a centinaia o migliaia di strumenti distribuiti su decine di server MCP, dimostrando la versatilità e la potenza del protocollo.

Tuttavia, con la crescita esponenziale del numero di strumenti connessi, sono emerse nuove sfide. Caricare tutte le definizioni degli strumenti all'avvio e passare i risultati intermedi attraverso la finestra di contesto rallenta significativamente gli agenti e aumenta i costi operativi. Questo rallentamento è una conseguenza diretta dell'eccessivo consumo di token, che compromette l'efficienza complessiva. In questo articolo, esploreremo come l'esecuzione di codice possa permettere agli agenti di interagire con i server MCP in modo più efficiente, gestendo un numero maggiore di strumenti e, al contempo, utilizzando un minor numero di token.

Il consumo eccessivo di token degli strumenti rende gli agenti meno efficienti

Man mano che l'utilizzo di MCP scala, emergono due schemi comuni che possono aumentare i costi e la latenza degli agenti, limitandone l'efficienza e le capacità operative:

• Le definizioni degli strumenti sovraccaricano la finestra di contesto;
• I risultati intermedi degli strumenti consumano token aggiuntivi.

1. Le definizioni degli strumenti sovraccaricano la finestra di contesto

La maggior parte dei client MCP attuali carica tutte le definizioni degli strumenti all'avvio, direttamente nel contesto del modello, esponendole al modello stesso tramite una sintassi di chiamata diretta. Queste definizioni degli strumenti possono apparire come segue:

gdrive.getDocument
     Description: Retrieves a document from Google Drive
     Parameters:
                documentId (required, string): The ID of the document to retrieve
                fields (optional, string): Specific fields to return
     Returns: Document object with title, body content, metadata, permissions, etc.

salesforce.updateRecord
    Description: Updates a record in Salesforce
    Parameters:
               objectType (required, string): Type of Salesforce object (Lead, Contact, Account, etc.)
               recordId (required, string): The ID of the record to update
               data (required, object): Fields to update with their new values
     Returns: Updated record object with confirmation

Le descrizioni degli strumenti, sebbene necessarie, occupano una quantità considerevole di spazio nella finestra di contesto del modello. Questo aumenta il tempo di risposta e i costi associati all'elaborazione. Nei casi in cui gli agenti sono connessi a migliaia di strumenti, devono elaborare centinaia di migliaia di token solo per leggere le definizioni degli strumenti prima ancora di poter elaborare una singola richiesta. Questo sovraccarico iniziale rallenta l'intero sistema e rende l'uso di agenti su larga scala economicamente proibitivo.

2. I risultati intermedi degli strumenti consumano token aggiuntivi

La maggior parte dei client MCP consente ai modelli di chiamare direttamente gli strumenti MCP. Per esempio, un utente potrebbe chiedere al proprio agente: "Scarica la mia trascrizione della riunione da Google Drive e allegala al lead di Salesforce". In questo scenario, il modello effettuerà chiamate simili a queste:

TOOL CALL: gdrive.getDocument(documentId: "abc123")
        → returns "Discussed Q4 goals...\n[full transcript text]"
           (loaded into model context)

TOOL CALL: salesforce.updateRecord(
            objectType: "SalesMeeting",
            recordId: "00Q5f000001abcXYZ",
            data: { "Notes": "Discussed Q4 goals...\n[full transcript text written out]" }
        )
        (model needs to write entire transcript into context again)

Come si può notare, ogni risultato intermedio deve passare attraverso il modello. In questo esempio, l'intero testo della trascrizione della chiamata fluisce attraverso il modello due volte. Per una riunione di vendita di due ore, ciò potrebbe significare elaborare un'ulteriore quantità di 50.000 token. Documenti ancora più grandi possono addirittura superare i limiti della finestra di contesto, interrompendo completamente il flusso di lavoro e compromettendo l'efficienza dell'agente. Inoltre, con documenti di grandi dimensioni o strutture di dati complesse, i modelli possono essere più inclini a commettere errori durante la copia dei dati tra le chiamate agli strumenti. L'approccio attuale, in cui il client MCP carica le definizioni degli strumenti nella finestra di contesto del modello e orchestra un ciclo di messaggi dove ogni chiamata di strumento e ogni risultato passano attraverso il modello tra le operazioni, è intrinsecamente inefficiente per scenari complessi e ad alto volume di dati.

L'esecuzione di codice con MCP migliora l'efficienza del contesto

Con gli ambienti di esecuzione del codice che stanno diventando sempre più comuni per gli agenti, una soluzione efficace a questi problemi è presentare i server MCP come API di codice anziché chiamate dirette a strumenti. L'agente può quindi scrivere codice per interagire con i server MCP. Questo approccio affronta entrambe le sfide precedentemente menzionate: gli agenti possono caricare solo gli strumenti di cui hanno bisogno al momento opportuno e possono elaborare i dati direttamente nell'ambiente di esecuzione prima di passare i risultati finali al modello. Questo riduce drasticamente la quantità di informazioni che devono transitare attraverso la finestra di contesto del modello.

Esistono diversi modi per implementare questa soluzione. Un approccio comune consiste nel generare una struttura di file ad albero che rappresenti tutti gli strumenti disponibili dai server MCP connessi. Ecco un'implementazione che utilizza TypeScript come esempio:

servers
├── google-drive
│   ├── getDocument.ts
│   ├── ... (other tools)
│   └── index.ts
├── salesforce
│   ├── updateRecord.ts
│   ├── ... (other tools)
│   └── index.ts
└── ... (other servers)

In questa struttura, ogni strumento corrisponde a un file specifico, organizzato all'interno delle directory dei rispettivi server. Ad esempio, un file per recuperare un documento da Google Drive potrebbe apparire così:

// ./servers/google-drive/getDocument.ts
import { callMCPTool } from "../../../client.js";

interface GetDocumentInput {
  documentId: string;
}

interface GetDocumentResponse {
  content: string;
}

/* Read a document from Google Drive */
export async function getDocument(input: GetDocumentInput): Promise {
  return callMCPTool('google_drive__get_document', input);
}

Utilizzando questo approccio, l'esempio di Google Drive a Salesforce menzionato in precedenza può essere riscritto come codice, offrendo maggiore chiarezza e, soprattutto, efficienza. L'agente non necessita più di passare l'intera trascrizione attraverso la finestra di contesto due volte. Invece, l'elaborazione avviene nell'ambiente di esecuzione del codice:

// Read transcript from Google Docs and add to Salesforce prospect
import * as gdrive from './servers/google-drive';
import * as salesforce from './servers/salesforce';

const transcript = (await gdrive.getDocument({ documentId: 'abc123' })).content;
await salesforce.updateRecord({
  objectType: 'SalesMeeting',
  recordId: '00Q5f000001abcXYZ',
  data: { Notes: transcript }
});

Con questa metodologia, l'agente scopre gli strumenti esplorando il filesystem: elenca la directory ./servers/ per trovare i server disponibili (come google-drive e salesforce), quindi legge i file specifici dello strumento di cui ha bisogno (come getDocument.ts e updateRecord.ts) per comprenderne l'interfaccia. Ciò consente all'agente di caricare solo le definizioni necessarie per l'attività corrente, riducendo drasticamente il consumo di token. Questo approccio ha dimostrato di ridurre l'utilizzo dei token da 150.000 a soli 2.000 token, ottenendo un risparmio di tempo e costi del 98,7%. Cloudflare ha pubblicato scoperte simili, riferendosi all'esecuzione di codice con MCP come "Code Mode". L'intuizione fondamentale è la stessa: i LLM (Large Language Models) sono estremamente abili nella scrittura di codice e gli sviluppatori dovrebbero sfruttare questa forza per costruire agenti che interagiscono con i server MCP in modo più efficiente.

Benefici dell'esecuzione di codice con MCP

L'adozione dell'esecuzione di codice con MCP offre numerosi vantaggi che consentono agli agenti di utilizzare il contesto in modo significativamente più efficiente. Questi benefici includono il caricamento degli strumenti su richiesta, il filtraggio dei dati prima che raggiungano il modello e l'esecuzione di logiche complesse in un unico passaggio. Inoltre, questo approccio porta con sé importanti vantaggi in termini di sicurezza e gestione dello stato.

Divulgazione progressiva

I modelli di intelligenza artificiale sono eccezionalmente bravi a navigare nei filesystem e nelle strutture di dati gerarchiche. Presentare gli strumenti come codice su un filesystem permette ai modelli di leggere le definizioni degli strumenti su richiesta, anziché doverle leggere tutte all'avvio. Questo riduce il carico iniziale sulla finestra di contesto. In alternativa, è possibile aggiungere uno strumento search_tools al server per trovare definizioni pertinenti in modo dinamico. Ad esempio, quando si lavora con il server Salesforce ipotetico utilizzato in precedenza, l'agente può cercare "salesforce" e caricare solo gli strumenti specifici necessari per l'attività corrente. Includere un parametro per il livello di dettaglio nello strumento search_tools, che consente all'agente di selezionare la granularità delle informazioni richieste (come solo il nome, nome e descrizione, o la definizione completa con schemi), aiuta ulteriormente l'agente a conservare il contesto e a trovare gli strumenti in modo più efficiente, ottimizzando l'uso dei token.

Risultati degli strumenti efficienti in termini di contesto

Quando si lavora con set di dati di grandi dimensioni, gli agenti possono filtrare e trasformare i risultati direttamente nel codice prima di restituirli al modello. Questo è un vantaggio cruciale per l'efficienza. Consideriamo il recupero di un foglio di calcolo con 10.000 righe:

// Senza esecuzione di codice - tutte le righe fluiscono attraverso il contesto
TOOL CALL: gdrive.getSheet(sheetId: 'abc123')
        → returns 10,000 rows in context to filter manually

// Con esecuzione di codice - filtra nell'ambiente di esecuzione
const allRows = await gdrive.getSheet({ sheetId: 'abc123' });
const pendingOrders = allRows.filter(row => 
  row["Status"] === 'pending'
);
console.log(`Found ${pendingOrders.length} pending orders`);
console.log(pendingOrders);

Senza l'esecuzione di codice, l'intero foglio di calcolo con 10.000 righe verrebbe caricato nella finestra di contesto del modello, costringendo il modello a spendere token e tempo per filtrare manualmente i dati. Con l'esecuzione di codice, l'agente può eseguire la logica di filtraggio direttamente nell'ambiente di esecuzione. Questo significa che solo il set di dati filtrato e pertinente – in questo caso, solo gli ordini in sospeso – viene passato al modello, riducendo drasticamente il consumo di token e migliorando la velocità di risposta. Questa capacità di manipolare i dati esternamente al modello non solo conserva il contesto, ma minimizza anche il rischio di errori che possono verificarsi quando i modelli devono elaborare e ricopiare grandi volumi di dati.

Oltre a questi benefici, l'esecuzione di codice con MCP offre vantaggi significativi anche in termini di sicurezza e gestione dello stato. Eseguire il codice in un ambiente controllato e isolato può migliorare la sicurezza, prevenendo l'esecuzione di codice malevolo direttamente nel contesto del modello e consentendo una migliore gestione degli accessi e delle autorizzazioni. La gestione dello stato diventa più robusta, poiché le operazioni complesse possono essere gestite e monitorate all'interno dell'ambiente di esecuzione, piuttosto che affidarsi esclusivamente alla finestra di contesto, che è intrinsecamente volatile e limitata. Questi aspetti combinati rendono l'esecuzione di codice con MCP una soluzione potente e scalabile per la costruzione di agenti AI di nuova generazione.