Cómo usar LlamaIndex.TS para orquestar servidores MCP

En este post, mostraremos cómo orquestar servidores de Protocolo de Contexto Modelo (MCP) utilizandoLlamazares.esen una aplicación TypeScript del mundo real. Utilizaremos elAgentes de viajes de AzureEl proyecto como nuestra base, centrándose en las mejores prácticas para una orquestación segura, escalable y sostenible.

Si está interesado en obtener una visión general del proyecto Azure AI Travel Agents, lea nuestro blog de anuncio!

¿Por qué llamaindex.TS y MCP?

• llamaindex.TS proporciona un marco modular, compostable para la construcción de aplicaciones alimentadas por LLM en TypeScript.
• MCP permite la interoperabilidad de herramientas y la transmisión, lo que lo convierte en ideal para la orquestación de múltiples servicios de IA.

Estructura del proyecto

La orquesta Llamaindex.TS vive ensrc/api/src/orchestrator/llamaindex, con módulos de proveedores para diferentes backends LLM y clientes MCP. Actualmente apoyamos:

• Acerca de Azure
• Modelos de Docker
• Más información sobre Azure AI Foundry Local
• El modelo GitHub
• Ollón

Se siente libre para explorar la base de código yOfrecer más proveedores.

Configurar el cliente MCP con HTTP Streamable

Para interactuar con los servidores MCP, sin utilizar Llamaindex.TS, podemos escribir una implementación personalizada utilizando elStreamableHTTPClientTransportpara una comunicación eficiente, autenticada y streaming.

// filepath: src/api/src/mcp/mcp-http-client.ts
import EventEmitter from 'node:events';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

export class MCPClient extends EventEmitter {
  private client: Client;
  private transport: StreamableHTTPClientTransport;

  constructor(serverName: string, serverUrl: string, accessToken?: string) {
    this.transport = new StreamableHTTPClientTransport({
      url: serverUrl,
      headers: accessToken ? { Authorization: `Bearer ${accessToken}` } : {},
    });
    this.client = new Client(serverName, this.transport);
  }

  async connect() {
    await this.client.initialize();
  }

  async listTools() {
    return this.client.listTools();
  }

  async callTool(name: string, toolArgs: any) {
    return this.client.callTool(name, toolArgs);
  }

  async close() {
    await this.client.closeGracefully();
  }
}

Best Practice:Siempre pasa elAuthorizationHeader para acceso seguro, como se muestra anteriormente.

Llamar una herramienta MCP manualmente

Supongamos que desea obtener recomendaciones de destino del servidor MCP:

import { MCPClient } from '../../mcp/mcp-http-client';

const DESTINATION_SERVER_URL = process.env.MCP_DESTINATION_RECOMMENDATION_URL!;
const ACCESS_TOKEN = process.env.MCP_DESTINATION_RECOMMENDATION_ACCESS_TOKEN;

const mcpClient = new MCPClient('destination-recommendation', DESTINATION_SERVER_URL, ACCESS_TOKEN);

await mcpClient.connect();

const tools = await mcpClient.listTools();
console.log('Available tools:', tools);

const result = await mcpClient.callTool('getDestinationsByPreferences', {
  activity: 'CULTURAL',
  budget: 'MODERATE',
  season: 'SUMMER',
  familyFriendly: true,
});
console.log('Recommended destinations:', result);

await mcpClient.close();

Tip:Siempre cierre el cliente MCP graciosamente para liberar recursos.

Orchestrating LLMs y herramientas de MCP con Llamaindex.TS

ElmcpCliente de@llamaindex/toolsfacilita la conexión a los servidores MCP y la recuperación dinámica de las definiciones de herramientas. A continuación se muestra una muestra de la configuración del orquestrador del proyecto, mostrando cómo usarmcppara recoger herramientas y crear agentes para cada servidor MCP.

He aquí un ejemplo de lo quemcpServerConfigEl objeto puede parecer:

const mcpServerConfig = {
  url: "http://localhost:5007", // MCP server endpoint
  accessToken: process.env.MCP_ECHO_PING_ACCESS_TOKEN, // Secure token from env
  name: "echo-ping", // Logical name for the server
};

Puede utilizar esta configuración con elmcpEl cliente:

import { mcp } from "@llamaindex/tools";
import { agent, multiAgent, ToolCallLLM } from "llamaindex";

// ...existing code...

const mcpServerConfig = mcpToolsConfig["echo-ping"].config;
const tools = await mcp(mcpServerConfig).tools();
const echoAgent = agent({
  name: "EchoAgent",
  systemPrompt:
    "Echo back the received input. Do not respond with anything else. Always call the tools.",
  tools,
  llm,
  verbose,
});
agentsList.push(echoAgent);
handoffTargets.push(echoAgent);
toolsList.push(...tools);

// ...other code...

const travelAgent = agent({
  name: "TravelAgent",
  systemPrompt:
    "Acts as a triage agent to determine the best course of action for the user's query. If you cannot handle the query, please pass it to the next agent. If you can handle the query, please do so.",
  tools: [...toolsList],
  canHandoffTo: handoffTargets
    .map((target) => target.getAgents().map((agent) => agent.name))
    .flat(),
  llm,
  verbose,
});
agentsList.push(travelAgent);

// Create the multi-agent workflow
return multiAgent({
  agents: agentsList,
  rootAgent: travelAgent,
  verbose,
});

Puede repetir este patrón para componer un flujo de trabajo multiagente en el que cada agente es alimentado por herramientas descubiertas en el tiempo de ejecución del servidor MCP.Un ejemplo completo.

Luego puede usar esta instancia LLM para orquestar llamadas a herramientas de MCP, como la planificación de itinerarios o la recomendación de destinos.

Consideraciones de seguridad

• Siempre use tokens de acceso y encabezados seguros.
• Nunca secretes de código duro; use variables ambientales y gestores secretos.

Únete a la comunidad:

Le animamos a unirse a nuestra comunidad de desarrolladores de Azure AI Foundry para compartir sus experiencias, hacer preguntas y obtener soporte:

• aka.ms/foundry/discord Únete a nuestra comunidad de Discord para debates y soporte en tiempo real.
• aka.ms/foundry/forum - Visite nuestro Foro de desarrolladores de Azure AI Foundry para hacer preguntas y compartir sus conocimientos.

Conclusión

Al combinar llamaindex.TS con el transporte HTTP Streamable de MCP, puede orquestar flujos de trabajo de IA poderosos, seguros y escalables en TypeScript.

References:

• Documentación llamaindex.TS
• MCP Streamable HTTP Spec
• Ejemplo de agentes de viajes de Azure