477 lectures
477 lectures

Comment utiliser LlamaIndex.TS pour orchestrer les serveurs MCP

par Wassim Chegham4m2025/07/08
Read on Terminal Reader

Trop long; Pour lire

Dans ce post, nous allons démontrer comment orchestrer des serveurs de protocole de contexte de modèle (MCP) dans une application TypeScript du monde réel.Nous utilisons le projet [Azure AI Travel Agents] comme base, en mettant l'accent sur les meilleures pratiques pour une orchestration sécurisée, évolutive et maintenable.
featured image - Comment utiliser LlamaIndex.TS pour orchestrer les serveurs MCP
Wassim Chegham HackerNoon profile picture
0-item

Dans ce post, nous allons démontrer comment orchestrer des serveurs de protocole de contexte de modèle (MCP) en utilisantRésumé de l'indice.tsdans une application TypeScript du monde réel. Nous utiliserons leLes agences de voyages Azureprojet comme notre base, en mettant l'accent sur les meilleures pratiques pour une orchestration sécurisée, évolutive et entretenue.


Si vous êtes intéressé par un aperçu du projet Azure AI Travel Agents, veuillez lire notre blog d’annonce!

Blog annonce

Pourquoi llamaindex.TS et MCP ?

  • llamaindex.TS fournit un cadre modulaire, composable pour la construction d'applications alimentées par LLM dans TypeScript.
  • MCP permet l'interopérabilité des outils et le streaming, ce qui en fait l'idéal pour orchestrer plusieurs services d'IA.

Structure du projet

L’orchestre Llamaindex.TS vit ensrc/api/src/orchestrator/llamaindex, avec des modules de fournisseur pour différents backends LLM et clients MCP. Nous supportons actuellement:

  • Ouvrir Azure
  • Modèles Docker
  • Azure AI Foundry local
  • Modèle GitHub
  • Ollé


Sentez-vous libre d'explorer la base de codes etProposer plus de fournisseurs.


Configuration du client MCP avec HTTP Streamable

Pour interagir avec les serveurs MCP, sans utiliser Llamaindex.TS, nous pouvons écrire une mise en œuvre personnalisée en utilisant leStreamableHTTPClientTransportpour une communication efficace, authentifiée et en 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:Toujours passer leAuthorizationen-tête pour un accès sécurisé, comme indiqué ci-dessus.

Appeler un outil MCP manuellement

Supposons que vous vouliez obtenir des recommandations de destination du serveur 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:Fermez toujours gracieusement le client MCP pour libérer des ressources.


Orchestrer des LLM et des outils MCP avec Llamaindex.TS

Lemcpclient de@llamaindex/toolsfacilite la connexion aux serveurs MCP et la récupération dynamique des définitions d'outils. Ci-dessous un échantillon de la configuration de l'orchestrateur du projet, montrant comment utilisermcpObtenir des outils et créer des agents pour chaque serveur MCP.


Voici un exemple de ce quemcpServerConfigL’objet peut ressembler à :

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
};


Vous pouvez ensuite utiliser cette configuration avec lemcpLe client :

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,
});

Vous pouvez répéter ce modèle pour composer un flux de travail multi-agent où chaque agent est alimenté par des outils découverts à l'heure d'exécution du serveur MCP.Un exemple complet.


Vous pouvez ensuite utiliser cette instance LLM pour orchestrer les appels aux outils MCP, tels que la planification d'itinéraire ou la recommandation de destination.


Considérations de sécurité

  • Utilisez toujours des jetons d'accès et des en-têtes sécurisés.
  • N'utilisez jamais de secrets de code dur; utilisez des variables d'environnement et des gestionnaires secrets.

Rejoignez la communauté :

Nous vous encourageons à rejoindre notre communauté de développeurs Azure AI Foundry pour partager vos expériences, poser des questions et obtenir du soutien :

  • aka.ms/foundry/discord Rejoignez notre communauté Discord pour des discussions et un soutien en temps réel.
  • aka.ms/foundry/forum - Visitez notre forum des développeurs Azure AI Foundry pour poser des questions et partager vos connaissances.

Conclusion

En combinant llamaindex.TS avec le transport HTTP en flux de MCP, vous pouvez orchestrer des workflows d'IA puissants, sécurisés et évolutifs dans TypeScript. Le projet Azure AI Travel Agents fournit un modèle robuste pour construire votre propre orchestreur.


References:

  • La documentation de llamaindex.TS
  • MCP Streamable HTTP Spec
  • Échantillon d'agents de voyage Azure AI


Trending Topics

blockchaincryptocurrencyhackernoon-top-storyprogrammingsoftware-developmenttechnologystartuphackernoon-booksBitcoinbooks