Model Context Protocol (MCP)

Protocole standardisé pour l'accès aux outils LLM et le partage de contexte

Le package MCP fournit une implémentation complète du Model Context Protocol, permettant l'interopérabilité entre les LLMs et les outils, ressources et prompts externes.

Installation

npm install @orka-js/mcp
# or
pnpm add @orka-js/mcp

Fonctionnalités

Client MCP

Connectez-vous à n'importe quel serveur compatible MCP

Serveur MCP

Exposez des outils, ressources et prompts via MCP

Gateway MCP

Routez les requêtes vers plusieurs serveurs upstream

Auto-découverte

Découvrez automatiquement les outils des serveurs connectés

Authentification

Support des clés API pour des connexions sécurisées

Health checks

Surveillance automatique de la santé des upstreams

#Client MCP

Connectez-vous aux serveurs MCP et accédez à leurs outils, ressources et prompts.

import { MCPClient } from '@orka-js/mcp';
 
const client = new MCPClient({
  endpoint: 'http://localhost:3000/mcp',
  apiKey: process.env.MCP_API_KEY,
});
 
await client.connect();
 
// List available tools
const tools = await client.listTools();
console.log('Available tools:', tools.map(t => t.name));
 
// Call a tool
const result = await client.callTool('get_customer', { id: '123' });
console.log('Result:', result);
 
// Read a resource
const contents = await client.readResource('file:///data/config.json');
 
// Get a prompt
const messages = await client.getPrompt('greeting', { name: 'John' });

#Serveur MCP

Exposez vos propres outils, ressources et prompts via le protocole MCP.

import { MCPServer } from '@orka-js/mcp';
 
const server = new MCPServer({
  name: 'my-mcp-server',
  port: 3000,
  apiKey: process.env.MCP_API_KEY,
});
 
// Register a tool
server.tool('get_customer', {
  description: 'Get customer by ID',
  inputSchema: {
    type: 'object',
    properties: {
      id: { type: 'string', description: 'Customer ID' }
    },
    required: ['id']
  }
}, async (args) => {
  const customer = await db.customers.findById(args.id);
  return {
    success: true,
    content: [{ type: 'text', text: JSON.stringify(customer) }]
  };
});
 
// Register a resource
server.resource('file:///data/config.json', {
  name: 'Configuration',
  description: 'Application configuration',
  mimeType: 'application/json'
}, async (uri) => {
  const config = await fs.readFile('./config.json', 'utf-8');
  return [{ type: 'text', text: config }];
});
 
await server.start();

#Gateway MCP

Agrégez plusieurs serveurs MCP derrière un seul endpoint avec équilibrage de charge.

import { MCPGateway } from '@orka-js/mcp';
 
const gateway = new MCPGateway({
  name: 'my-gateway',
  port: 4000,
  upstreams: [
    { name: 'crm', endpoint: 'http://localhost:3001/mcp' },
    { name: 'erp', endpoint: 'http://localhost:3002/mcp' },
    { name: 'docs', endpoint: 'http://localhost:3003/mcp' },
  ],
});
 
await gateway.start();
 
// Check upstream status
const status = gateway.getUpstreamStatus();
console.log('Upstreams:', status);

Intégration avec les Agents

Utilisez les outils MCP avec les agents OrkaJS pour des workflows agentiques puissants.

import { ReActAgent } from '@orka-js/agent';
import { MCPClient } from '@orka-js/mcp';
 
// Connect to MCP server
const mcp = new MCPClient({ endpoint: 'http://localhost:3000/mcp' });
await mcp.connect();
 
// Get tools from MCP
const mcpTools = await mcp.listTools();
 
// Convert MCP tools to OrkaJS tools
const tools = mcpTools.map(t => ({
  name: t.name,
  description: t.description,
  parameters: t.inputSchema.properties,
  execute: async (args) => {
    const result = await mcp.callTool(t.name, args);
    return result.content[0]?.text || '';
  }
}));
 
// Create agent with MCP tools
const agent = new ReActAgent({
  llm,
  tools,
  maxIterations: 10,
});
 
const result = await agent.run('Get customer 123 and summarize their orders');

Exemples Complets

Exemple 1 : Service Météo avec Serveur MCP

Un service météo complet qui expose des outils, ressources et prompts via MCP :

import { MCPServer } from '@orka-js/mcp';
import express from 'express';
 
// Créer le serveur MCP
const server = new MCPServer({
  name: 'weather-service',
  version: '1.0.0',
  description: 'Données météo et prévisions'
});
 
// Ajouter l'outil météo
server.addTool({
  name: 'get_weather',
  description: 'Obtenir la météo actuelle pour un lieu',
  parameters: [
    { name: 'location', type: 'string', description: 'Nom de la ville', required: true },
    { name: 'units', type: 'string', description: 'Unités de température (celsius/fahrenheit)', required: false }
  ],
  execute: async (args) => {
    const { location, units = 'celsius' } = args;
    // Appeler l'API météo
    const weather = await fetchWeatherData(location);
    return {
      output: JSON.stringify({
        location,
        temperature: units === 'celsius' ? weather.temp: (weather.temp * 9/5) + 32,
        condition: weather.condition,
        humidity: weather.humidity,
        units
      })
    };
  }
});
 
// Ajouter l'outil de prévisions
server.addTool({
  name: 'get_forecast',
  description: 'Obtenir les prévisions sur 5 jours',
  parameters: [
    { name: 'location', type: 'string', description: 'Nom de la ville', required: true }
  ],
  execute: async (args) => {
    const forecast = await fetchForecast(args.location);
    return { output: JSON.stringify(forecast) };
  }
});
 
// Ajouter une ressource météo
server.addResource({
  uri: 'weather://current',
  name: 'Données Météo Actuelles',
  description: 'Informations météo en temps réel',
  mimeType: 'application/json',
  read: async () => {
    const data = await fetchGlobalWeather();
    return { content: JSON.stringify(data) };
  }
});
 
// Ajouter un template de prompt météo
server.addPrompt({
  name: 'weather_report',
  description: 'Générer un rapport météo',
  arguments: [
    { name: 'location', description: 'Nom de la ville', required: true }
  ],
  template: async (args) => ({
    messages: [
      {
        role: 'system',
        content: 'Vous êtes un météorologue professionnel fournissant des rapports météo.'
      },
      {
        role: 'user',
        content: `Fournissez un rapport météo détaillé pour ${args.location}. Incluez les conditions actuelles, les prévisions et des recommandations.`
      }
    ]
  })
});
 
// Démarrer le serveur MCP
const app = express();
server.attach(app);
app.listen(3001, () => {
  console.log('Serveur MCP Météo en cours d\'exécution sur le port 3001');
});
 
async function fetchWeatherData(location: string) {
  // Implémentation
  return { temp: 22, condition: 'Ensoleillé', humidity: 65 };
}
 
async function fetchForecast(location: string) {
  // Implémentation
  return { days: [] };
}
 
async function fetchGlobalWeather() {
  // Implémentation
  return { regions: [] };
}

Exemple 2 : Gateway Multi-Services

Agréger plusieurs serveurs MCP via une seule gateway :

import { MCPGateway } from '@orka-js/mcp';
import express from 'express';
 
// Créer la gateway
const gateway = new MCPGateway({
  name: 'enterprise-gateway',
  version: '1.0.0'
});
 
// Ajouter les services upstream
gateway.addUpstream({
  name: 'weather-service',
  url: 'http://localhost:3001',
  healthCheck: '/health'
});
 
gateway.addUpstream({
  name: 'database-service',
  url: 'http://localhost:3002',
  healthCheck: '/health'
});
 
gateway.addUpstream({
  name: 'analytics-service',
  url: 'http://localhost:3003',
  healthCheck: '/health'
});
 
// Démarrer la gateway
const app = express();
gateway.attach(app);
 
app.listen(4000, () => {
  console.log('Gateway MCP en cours d\'exécution sur le port 4000');
  console.log('Agrégation des services : météo, base de données, analytics');
});
 
// Utilisation client
import { MCPClient } from '@orka-js/mcp';
 
const client = new MCPClient({
  serverUrl: 'http://localhost:4000'
});
 
await client.connect();
 
// Lister tous les outils de tous les services
const tools = await client.listTools();
console.log('Outils disponibles:', tools.map(t => t.name));
 
// Appeler un outil de n'importe quel service
const weather = await client.callTool('get_weather', {
  location: 'Paris'
});
 
const dbQuery = await client.callTool('query_database', {
  sql: 'SELECT * FROM users LIMIT 10'
});
 
const analytics = await client.callTool('get_metrics', {
  period: 'last_7_days'
});

Exemple 3 : Agent avec Outils MCP

Créer un agent intelligent qui utilise les outils MCP dynamiquement :

import { MCPClient } from '@orka-js/mcp';
import { ReActAgent } from '@orka-js/agent';
import { OpenAIAdapter } from '@orka-js/openai';
 
// Se connecter à la gateway MCP
const mcpClient = new MCPClient({
  serverUrl: 'http://localhost:4000'
});
await mcpClient.connect();
 
// Obtenir tous les outils disponibles
const mcpTools = await mcpClient.listTools();
 
// Convertir les outils MCP en outils d'agent
const agentTools = mcpTools.map(tool => ({
  name: tool.name,
  description: tool.description,
  parameters: tool.inputSchema.properties,
  execute: async (args: Record<string, unknown>) => {
    const result = await mcpClient.callTool(tool.name, args);
    return { output: result.content };
  }
}));
 
// Créer un agent avec les outils MCP
const llm = new OpenAIAdapter({
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4'
});
 
const agent = new ReActAgent(
  {
    goal: 'Aider les utilisateurs avec la météo, les requêtes de base de données et les analytics',
    tools: agentTools,
    maxSteps: 10
  },
  llm
);
 
// Utiliser l'agent
const result = await agent.run(
  'Quelle est la météo à Paris et combien d\'utilisateurs se sont inscrits ces 7 derniers jours ?'
);
 
console.log('Réponse de l\'agent:', result.output);
console.log('Étapes effectuées:', result.steps?.length);
console.log('Outils utilisés:', result.steps?.map(s => s.action?.tool));
 
// Exemple de sortie :
// Réponse de l'agent: "La météo à Paris est actuellement de 22°C et ensoleillée. 
//                      Au cours des 7 derniers jours, 1 234 nouveaux utilisateurs se sont inscrits."
// Étapes effectuées: 4
// Outils utilisés: ['get_weather', 'query_database', 'get_metrics']