feat: integrate MCP tools with agent and add remote tool support

ciro-maciel · ciro-maciel · commit 62afd696e27f · 2025-04-20T10:06:51.000-03:00
diff --git a/examples/mcp/agent.js b/examples/mcp/agent.js
@@ -1,32 +1,27 @@
-// Exemplo de uso do Agent com MCPTool para validar conexão e troca de mensagens com servidores MCP
-const { Agent } = require('../../src');
+// Exemplo de agente integrado ao MCP server de weather
+const { Agent, Runner } = require('../../src');
 
-// Substitua por URLs reais dos hosts MCP que estejam rodando (pode apontar para localhost:3000)
-const MCP_SERVERS = [
-    'http://localhost:3000',
-    // 'http://localhost:3002'
-];
+(async () => {
+    // URL do MCP server (ajuste conforme necessário)
+    const mcpWeatherUrl = 'http://localhost:3001/sse';
 
-async function main() {
-    // Cria agente com MCPTool
+    // Instancia o agente com integração MCP
     const agent = new Agent({
-        name: 'Agente-MCP-Exemplo',
-        instructions: 'Teste de integração MCP.',
-        mcpServers: MCP_SERVERS
+        name: 'WeatherAgent',
+        instructions: 'Consulte informações meteorológicas usando ferramentas remotas.',
+        mcpServers: [mcpWeatherUrl]
     });
 
-    // Conecta a todos os servidores MCP
-    await agent.mcpTool.connectAll();
-    console.log('Conectado aos servidores MCP:', MCP_SERVERS);
+    // Inicializa o agente e aguarda o carregamento das ferramentas MCP
+    await agent.init();
 
-    // Envia mensagem de teste para cada servidor MCP
-    for (const url of MCP_SERVERS) {
-        const input = 'Mensagem de teste para o servidor MCP: ' + url;
-        const resposta = await agent.mcpTool.sendMessage(url, input);
-        console.log(`Resposta do MCP (${url}):`, resposta);
-    }
-}
+    // Exibe as ferramentas disponíveis
+    console.log('Ferramentas disponíveis:', agent.tools.map(t => t.name));
 
-main().catch(err => {
-    console.error('Erro no exemplo MCP:', err);
-});
+    // Input natural do usuário
+    const input = 'Quais alertas meteorológicos existem para NY?';
+
+    // Executa o agente, que decide qual ferramenta usar
+    const result = await Runner.run(agent, input);
+    console.log('Saída final do agente:', result.finalOutput);
+})();
diff --git a/examples/mcp/client.js b/examples/mcp/client.js
@@ -4,7 +4,6 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 
-
 let client = undefined
 const url = "http://localhost:3001/sse";
 
diff --git a/src/agent.js b/src/agent.js
@@ -1,6 +1,9 @@
 const OpenAIProvider = require('./providers/OpenAIProvider');
 
 
+const { MCPManager } = require('./mcp');
+const Tool = require('./tool');
+
 class Agent {
     /**
      * Create a new agent
@@ -48,12 +51,55 @@ class Agent {
         this.outputType = outputType;
         this.handoffDescription = handoffDescription;
 
+        // Inicializa MCPManager se houver MCPs
+        this.mcpServers = Array.isArray(arguments[0]?.mcpServers) ? arguments[0].mcpServers : [];
+        this.mcpManager = this.mcpServers.length > 0 ? new MCPManager(this.mcpServers) : null;
+
         // Initialize the provider
         this.llmProvider = this.initializeProvider(provider, {
             ...providerConfig,
             model: this.model,
             ...this.modelSettings
         });
+
+        // Se houver MCPs, inicializa ferramentas remotas automaticamente (não bloqueia construtor)
+        if (this.mcpManager) {
+            (async () => {
+                await this.initializeMCPTools();
+            })();
+        }
+    }
+
+    /**
+     * Inicializa ferramentas MCP remotas e integra ao array this.tools
+     */
+    /**
+     * Inicializa o agente e aguarda o carregamento das ferramentas MCP (se houver MCPs).
+     * Uso recomendado: await agent.init();
+     * Torna transparente para o usuário a espera pelo carregamento das ferramentas remotas.
+     */
+    async init({ maxTentativas = 10, intervaloMs = 500 } = {}) {
+        if (!this.mcpManager) return; // Não há MCPs, nada a esperar
+        let tentativas = 0;
+        while (this.tools.length === 0 && tentativas < maxTentativas) {
+            await new Promise(r => setTimeout(r, intervaloMs));
+            tentativas++;
+        }
+        if (this.tools.length === 0) {
+            throw new Error('Ferramentas MCP não carregadas após aguardar.');
+        }
+    }
+
+    async initializeMCPTools() {
+        if (!this.mcpManager) return;
+        await this.mcpManager.connectAll();
+        const mcpToolsInfo = await this.mcpManager.listAllTools();
+        // Cria Tool para cada ferramenta MCP
+        const mcpTools = mcpToolsInfo.map(toolInfo =>
+            Tool.fromMCP(toolInfo, this.mcpManager.getClientForTool(toolInfo))
+        );
+        // Integra ferramentas MCP às ferramentas locais
+        this.tools = [...this.tools, ...mcpTools];
     }
 
     /**
diff --git a/src/mcp.js b/src/mcp.js
@@ -0,0 +1,61 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+// Classe para gerenciar conexões e listagem de ferramentas dos MCPs
+export class MCPManager {
+    constructor(servers = []) {
+        this.servers = servers; // Array de URLs dos MCPs
+        this.clients = [];      // Array de clientes MCP conectados
+        this.toolsMap = {};     // Mapeamento toolId -> client
+    }
+
+    async connectAll() {
+        for (const url of this.servers) {
+            let client;
+            let transport;
+            try {
+                client = new Client({ name: 'streamable-http-client', version: '1.0.0' });
+                transport = new StreamableHTTPClientTransport(new URL(url));
+                await client.connect(transport);
+                // Se conectar, adiciona
+                this.clients.push(client);
+                continue;
+            } catch (error) {
+                // Fallback para SSE
+                try {
+                    client = new Client({ name: 'sse-client', version: '1.0.0' });
+                    transport = new SSEClientTransport(new URL(url));
+                    await client.connect(transport);
+                    this.clients.push(client);
+                } catch (err) {
+                    console.error(`Falha ao conectar ao MCP em ${url}:`, err);
+                }
+            }
+        }
+    }
+
+    async listAllTools() {
+        let tools = [];
+        for (const client of this.clients) {
+            try {
+                const response = await client.listTools();
+                // Compatibilidade: pode ser .tools ou array direto
+                const clientTools = Array.isArray(response) ? response : response.tools || [];
+                for (const tool of clientTools) {
+                    // Supondo que tool.name seja único
+                    this.toolsMap[tool.name] = client;
+                    tools.push(tool);
+                }
+            } catch (err) {
+                console.error('Erro ao listar ferramentas do MCP:', err);
+            }
+        }
+        return tools;
+    }
+
+    getClientForTool(toolInfo) {
+        // toolInfo.name é o identificador único
+        return this.toolsMap[toolInfo.name];
+    }
+}
diff --git a/src/runner.js b/src/runner.js
@@ -122,11 +122,11 @@ class Runner {
                                 messages,
                                 handoffAgent.modelSettings
                             );
-                            
+
                             // Set final output and add response to messages
                             finalOutput = handoffResponse.content;
                             messages.push(handoffResponse);
-                            
+
                             // Exit the main loop since we have a final response
                             currentTurn = maxTurns;
                             break;
@@ -173,14 +173,18 @@ class Runner {
             throw new Error(`Max turns (${maxTurns}) exceeded`);
         }
 
-        return new RunResult({
+
+        const result = new RunResult({
             input,
             messages,
             finalOutput,
             lastAgent: currentAgent,
             inputGuardrailResults,
             outputGuardrailResults: []
         });
+        setImmediate(() => process.exit(0));
+        return result;
+
     }
 
     /**
diff --git a/src/tool.js b/src/tool.js
@@ -8,12 +8,41 @@ class Tool {
      * @param {string} options.description - Descrição do que a ferramenta faz
      * @param {Object} [options.parameters={}] - JSON Schema dos parâmetros da ferramenta
      * @param {Function} options.execute - Função a ser executada quando a ferramenta é chamada
+     * @param {boolean} [options.isRemote=false] - Se é uma ferramenta remota MCP
+     * @param {Object} [options.mcpClient] - Cliente MCP associado (se remota)
      */
-    constructor({ name, description, parameters = { type: 'object', properties: {} }, execute }) {
+    constructor({ name, description, parameters = { type: 'object', properties: {} }, execute, isRemote = false, mcpClient = null }) {
         this.name = name;
         this.description = description;
         this.parameters = parameters;
         this._execute = execute;
+        this.isRemote = isRemote;
+        this.mcpClient = mcpClient;
+    }
+
+    /**
+     * Fábrica para criar Tool a partir de toolInfo MCP
+     * @param {Object} toolInfo - Info retornada do MCP
+     * @param {Object} mcpClient - Instância do cliente MCP
+     * @returns {Tool}
+     */
+    static fromMCP(toolInfo, mcpClient) {
+        return new Tool({
+            name: toolInfo.name,
+            description: toolInfo.description,
+            parameters: toolInfo.inputSchema || { type: 'object', properties: {} },
+            isRemote: true,
+            mcpClient,
+            execute: async (args) => {
+                // Executa remotamente via MCP
+                const result = await mcpClient.callTool({
+                    name: toolInfo.name,
+                    arguments: args
+                });
+                // Retorna resultado bruto ou ajusta conforme necessário
+                return result.content ? result.content[0]?.text ?? result : result;
+            }
+        });
     }
 
     /**
