Como usar o Llamaindex.ts para orquestrar servidores MCP

Nesta postagem, demonstraremos como orquestrar servidores de protocolo de contexto de modelo (MCP) usando o llamaindex.ts em um aplicativo digital do mundo real. Usaremos o projeto de agentes de viagens do Azure AI como nossa base, focando as melhores práticas para orquestração segura, escalável e sustentável. Sinta -se à vontade para estrelar o repositório para ser notificado das últimas alterações.

Se você estiver interessado em uma visão geral do projeto Azure AI Travel Agents, leia nosso blog de anúncios!

Por que Llamaindex.ts e MCP?

• Llamaindex.ts Fornece uma estrutura modular e composta para a construção de aplicativos movidos a LLM no TypeScript.
• MCP Ativa a interoperabilidade e o streaming da ferramenta, tornando -o ideal para orquestrar vários serviços de IA.

Estrutura do projeto

O orquestrador Llandeindex.ts vive em src/api/src/orchestrator/llamaindexcom módulos de provedores para diferentes back -ends LLM e clientes MCP. Atualmente, apoiamos:

• Azure Openai
• Modelos Docker
• Azure AI Foundry Local
• Modelo Github
• Ollama

Sinta -se à vontade para explorar a base de código e sugerir mais fornecedores.

Configurando o cliente MCP com HTTP transmissível

Para interagir com os servidores MCP, sem usar o Llamaindex.ts, podemos escrever uma implementação personalizada usando o StreamableHTTPClientTransport para comunicação eficiente, autenticada e de 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();
  }
}

Melhor prática: Sempre passe o Authorization Cabeçalho para acesso seguro, como mostrado acima.

Suponha que você queira obter recomendações de destino do 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();

Dica: Sempre feche o cliente MCP graciosamente para liberar recursos.

Orquestratando as ferramentas LLMS e MCP com Llandeindex.ts

O mcp cliente de @llamaindex/tools facilita a conexão aos servidores MCP e recupere as definições da ferramenta dinamicamente. Abaixo está uma amostra da configuração do orquestrador do projeto, mostrando como usar mcp Para buscar ferramentas e criar agentes para cada servidor MCP.

Aqui está um exemplo do que um mcpServerConfig Objeto pode parecer:

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

Você pode então usar esta configuração com o mcp 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,
});

Você pode repetir esse padrão para compor um fluxo de trabalho multi-agente, onde cada agente é alimentado pelas ferramentas descobertas em tempo de execução do servidor MCP. Veja o projeto para um exemplo completo.

Você pode usar esta instância LLM para orquestrar chamadas para ferramentas MCP, como planejamento de itinerário ou recomendação de destino.

Considerações de segurança

• Sempre use tokens de acesso e cabeçalhos seguros.
• Nunca segredos de código hardcodes; Use variáveis ​​de ambiente e gerentes secretos.

Incentivamos você a se juntar à nossa comunidade de desenvolvedores de fundição do Azure AI para compartilhar suas experiências, fazer perguntas e obter suporte:

Conclusão

Ao combinar o Llamaindex.ts com o transporte HTTP transmissível do MCP, você pode orquestrar fluxos de trabalho poderosos, seguros e escaláveis ​​da IA ​​no TypeScript. O projeto Azure AI Travel Agents fornece um modelo robusto para construir seu próprio orquestrador.

Referências: