Merge pull request #1 from riligar/2025-04-18_mcp

feat: MCP integration

Author: ciro-maciel

README.md

@@ -10,20 +10,22 @@ The RiLiGar Agents SDK is a robust JavaScript library designed to streamline the
 - **Agent Management System**: Sophisticated agent lifecycle and interaction handling
 - **Voice Integration**: Native support for voice-based interactions
 - **Advanced Tracing**: Comprehensive system for monitoring and debugging agent behaviors
-- **MCP Protocol**: Implementation of Message Control Protocol v1.0 featuring:
-  - Secure handshake mechanism
-  - Capability exchange
-  - Synchronous and asynchronous messaging
-  - Streaming support
-  - Robust error handling
+- **MCP Protocol**: Implementation of Message Control Protocol 
 
 ## Resources
 
-- [OpenAI](https://platform.openai.com/logs)
-- [Anthropic](https://www.anthropic.com/api)
+- [OpenAI](https://platform.openai.com)
+  - [Library](https://github.com/openai/openai-node)
+- [Anthropic](https://console.anthropic.com/)
+  - [SDK](https://github.com/anthropics/anthropic-sdk-typescript)
 - [Google](https://ai.google.dev/gemini-api/)
+  - [SDK](https://www.npmjs.com/package/@google/genai)
 - [Meta](https://www.llama.com/)
-- [ModelContext](https://modelcontextprotocol.io/introduction)
+
+- [Model Context Protocol](https://modelcontextprotocol.io)
+  - [Documentation](https://modelcontextprotocol.info/docs/)
+  - [TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
+  - [Inspector](https://github.com/modelcontextprotocol/inspector)
 
 
 ## Installation
@@ -32,6 +34,14 @@ The RiLiGar Agents SDK is a robust JavaScript library designed to streamline the
 npm install @riligar/agents-sdk
 ```
 
+### MCP Protocol
+
+The RiLiGar Agents SDK implements the Message Control Protocol (MCP) for reliable agent communication and management. MCP is a secure and efficient protocol that ensures secure and reliable communication between agents and their environment.
+
+```bash
+npx -y @modelcontextprotocol/inspector npm start
+```
+
 ## Usage
 
 ```js

bun.lock

@@ -1,11 +1,8 @@
 // guardrail-example.js
-const { Agent, Runner, functionTool, inputGuardrail, outputGuardrail } = require('../src/index');
-
-// Set your OpenAI API key
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const { Agent, Runner, Tool, Guardrail } = require('../src/index');
 
 // Create an input guardrail that checks if the input contains inappropriate content
-const inappropriateContentGuardrail = inputGuardrail({
+const inappropriateContentGuardrail = new Guardrail.InputGuardrail({
     name: "inappropriate_content_filter",
     check: async (context, agent, input) => {
         // In a real implementation, you might use a content moderation API
@@ -29,11 +26,11 @@ const inappropriateContentGuardrail = inputGuardrail({
 });
 
 // Create an output guardrail that ensures the response isn't too short
-const minimumLengthGuardrail = outputGuardrail({
+const minimumLengthGuardrail = new Guardrail.OutputGuardrail({
     name: "minimum_length_check",
     check: async (context, agent, output) => {
         const minimumLength = 20; // characters
-        
+
         // Safely handle null/undefined output
         if (!output) {
             return {
@@ -65,7 +62,7 @@ const minimumLengthGuardrail = outputGuardrail({
 });
 
 // Create a tool for our agent
-const getWeather = functionTool({
+const getWeather = new Tool({
     name: "get_weather",
     description: "Get the current weather for a city",
     parameters: {

examples/guardrail.js

@@ -1,69 +1,39 @@
 const { Agent, Runner } = require('../src/index');
 
-// Set your OpenAI API key
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
-
-// Provider configuration
-const providerConfig = {
-    apiKey: OPENAI_API_KEY
-};
-
 async function main() {
     // Create the Spanish agent with explicit configuration
     const spanishAgent = new Agent({
         name: "Spanish_Agent",  // Use underscore for consistency
-        instructions: "You are a helpful assistant that only speaks Spanish. Always respond in Spanish to any questions or requests.",
-        model: "gpt-4",
-        provider: "openai",
-        providerConfig,
-        modelSettings: {
-            temperature: 0.7,
-            max_tokens: 500
-        }
+        instructions: "You are a helpful assistant that only speaks Spanish. Always respond in Spanish to any questions or requests."
     });
 
     // Create the English agent with explicit configuration
     const englishAgent = new Agent({
         name: "English_Agent",  // Use underscore for consistency
-        instructions: "You are a helpful assistant that only speaks English. Always respond in English to any questions or requests.",
-        model: "gpt-4",
-        provider: "openai",
-        providerConfig,
-        modelSettings: {
-            temperature: 0.7,
-            max_tokens: 500
-        }
+        instructions: "You are a helpful assistant that only speaks English. Always respond in English to any questions or requests."
     });
 
     // Create the triage agent with explicit configuration
     const triageAgent = new Agent({
         name: "Triage_Agent",  // Use underscore for consistency
         instructions: `You are a language triage agent. Your task is to analyze messages and route them to the appropriate language agent.
-
-Rules:
-1. For Spanish messages -> Use transfer_to_Spanish_Agent
-2. For English messages -> Use transfer_to_English_Agent
-3. DO NOT respond to the user directly
-4. ALWAYS use the appropriate transfer function
-5. If you detect Spanish, IMMEDIATELY call transfer_to_Spanish_Agent
-6. If you detect English, IMMEDIATELY call transfer_to_English_Agent`,
-        handoffs: [spanishAgent, englishAgent],
-        model: "gpt-4",
-        provider: "openai",
-        providerConfig,
-        modelSettings: {
-            temperature: 0.7,
-            max_tokens: 500
-        }
+            Rules:
+            1. For Spanish messages -> Use transfer_to_Spanish_Agent
+            2. For English messages -> Use transfer_to_English_Agent
+            3. DO NOT respond to the user directly
+            4. ALWAYS use the appropriate transfer function
+            5. If you detect Spanish, IMMEDIATELY call transfer_to_Spanish_Agent
+            6. If you detect English, IMMEDIATELY call transfer_to_English_Agent`,
+        handoffs: [spanishAgent, englishAgent]
     });
 
     try {
         console.log('Sending message to triage agent...');
         const result = await Runner.run(triageAgent, "Hola, ¿cómo estás?", {
-            maxTurns: 3,  // Allow for triage + response
+            // maxTurns: 1,  // Allow for triage + response
             context: { debug: true }
         });
-        
+
         console.log('\nFinal response:', result.finalOutput);
         console.log('Last agent:', result.lastAgent.name);
         console.log('\nMessage history:');

examples/handoffs.js

@@ -1,8 +1,5 @@
 const { Agent, Runner } = require('../src/index');
 
-// Set your OpenAI API key
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
-
 async function main() {
     const agent = new Agent({
         name: "Assistant",

examples/hello.js

@@ -0,0 +1,27 @@
+// Exemplo de agente integrado ao MCP server de weather
+const { Agent, Runner } = require('../../src');
+
+(async () => {
+    // URL do MCP server (ajuste conforme necessário)
+    const mcpWeatherUrl = 'http://localhost:3001/sse';
+
+    // Instancia o agente com integração MCP
+    const agent = new Agent({
+        name: 'WeatherAgent',
+        instructions: 'Consulte informações meteorológicas usando ferramentas remotas.',
+        mcpServers: [mcpWeatherUrl]
+    });
+
+    // Inicializa o agente e aguarda o carregamento das ferramentas MCP
+    await agent.init();
+
+    // Exibe as ferramentas disponíveis
+    console.log('Ferramentas disponíveis:', agent.tools.map(t => t.name));
+
+    // 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);
+})();

examples/mcp/agent.js

@@ -0,0 +1,52 @@
+// https://github.com/modelcontextprotocol/typescript-sdk?tab=readme-ov-file#backwards-compatibility
+// https://github.com/modelcontextprotocol/quickstart-resources/blob/main/mcp-client-typescript/index.ts
+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";
+
+const baseUrl = new URL(url);
+try {
+    client = new Client({
+        name: 'streamable-http-client',
+        version: '1.0.0'
+    });
+    const transport = new StreamableHTTPClientTransport(
+        new URL(baseUrl)
+    );
+    await client.connect(transport);
+    console.log("Connected using Streamable HTTP transport");
+} catch (error) {
+    // If that fails with a 4xx error, try the older SSE transport
+    console.log("Streamable HTTP connection failed, falling back to SSE transport");
+    client = new Client({
+        name: 'sse-client',
+        version: '1.0.0'
+    });
+    const sseTransport = new SSEClientTransport(baseUrl);
+    await client.connect(sseTransport);
+    console.log("Connected using SSE transport");
+}
+
+
+const tools = await client.listTools();
+// console.log("Tools:", tools)
+console.log("Tools:", tools.tools.map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+})))
+
+// call echo tool
+const result = await client.callTool({
+    name: 'get-alerts',
+    arguments: {
+        state: 'NY'
+    }
+});
+console.log("Result:", result.content[0].text.length);
+
+process.exit(0);
+

examples/mcp/client.js

@@ -0,0 +1,71 @@
+
+import express, { Request, Response } from "express";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { z } from "zod";
+
+export const server = new McpServer({
+    name: "echo",
+    version: "1.0.0"
+});
+
+server.resource(
+    "echo",
+    new ResourceTemplate("echo://{message}", { list: undefined }),
+    async (uri, { message }) => ({
+        contents: [{
+            uri: uri.href,
+            text: `Resource echo: ${message}`
+        }]
+    })
+);
+
+server.tool(
+    "echo",
+    { message: z.string() },
+    async ({ message }) => ({
+        content: [{ type: "text", text: `Tool echo: ${message}` }]
+    })
+);
+
+server.prompt(
+    "echo",
+    { message: z.string() },
+    ({ message }) => ({
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `Please process this message: ${message}`
+            }
+        }]
+    })
+);
+
+
+const app = express();
+const transports: { [sessionId: string]: SSEServerTransport } = {};
+
+app.get("/sse", async (_: Request, res: Response) => {
+    const transport = new SSEServerTransport('/messages', res);
+    transports[transport.sessionId] = transport;
+    res.on("close", () => {
+        delete transports[transport.sessionId];
+    });
+    await server.connect(transport);
+});
+
+app.post("/messages", async (req: Request, res: Response) => {
+    const sessionId = req.query.sessionId as string;
+    const transport = transports[sessionId];
+    if (transport) {
+        await transport.handlePostMessage(req, res);
+    } else {
+        res.status(400).send('No transport found for sessionId');
+    }
+});
+
+app.listen(3000, () => {
+    console.error("MCP Server running with sse transport");
+});
+