@agentlify/mcp-server 2.0.0

package/src/index.ts

@@ -0,0 +1,946 @@
+#!/usr/bin/env node
+
+/**
+ * Agentlify MCP Server
+ * Provides AI assistants with access to Agentlify features via Model Context Protocol
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { readFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Agentlify API base URL
+const API_BASE_URL = 'https://agentlify.co/api/mcp';
+const AGENT_API_URL = 'https://agentlify.co/api/agents';
+const HTTP_TIMEOUT_MS = 60000;
+
+// Get API key from environment
+const API_KEY = process.env.AGENTLIFY_API_KEY;
+
+if (!API_KEY) {
+  console.error('Error: AGENTLIFY_API_KEY environment variable is required');
+  process.exit(1);
+}
+
+/**
+ * Call an HTTP endpoint for MCP tools
+ */
+async function callHttpEndpoint(endpointName: string, data: any): Promise<any> {
+  // Convert function name to API endpoint URL
+  // "mcpGetBalanceHttp" -> "get-balance"
+  const apiEndpoint = endpointName
+    .replace('Http', '') // Remove "Http" suffix
+    .replace(/^mcp/, '') // Remove "mcp" prefix
+    .replace(/([A-Z])/g, '-$1') // Add dashes before capitals
+    .toLowerCase() // Convert to lowercase
+    .replace(/^-/, ''); // Remove leading dash
+
+  const response = await fetch(`${API_BASE_URL}/${apiEndpoint}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${API_KEY}`,
+    },
+    body: JSON.stringify(data && typeof data === 'object' ? data : {}),
+    signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`HTTP call failed: ${error}`);
+  }
+
+  try {
+    return (await response.json()) as any;
+  } catch {
+    throw new Error(`HTTP call failed: invalid JSON response from ${apiEndpoint}`);
+  }
+}
+
+/**
+ * Read documentation file
+ */
+async function readDoc(filename: string): Promise<string> {
+  const docPath = join(__dirname, '..', 'docs', filename);
+  return await readFile(docPath, 'utf-8');
+}
+
+/**
+ * Initialize MCP Server
+ */
+const server = new Server(
+  {
+    name: 'agentlify',
+    version: '2.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  },
+);
+
+/**
+ * List available tools
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'create_router',
+        description:
+          'Create a new AI model router with custom configuration. Returns router ID and sample code.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'Router name (e.g., "my-chatbot")',
+            },
+            cost_weight: {
+              type: 'number',
+              description:
+                'Weight for cost optimization (0-1, higher = prioritize cost savings)',
+              default: 0.4,
+            },
+            latency_weight: {
+              type: 'number',
+              description:
+                'Weight for speed optimization (0-1, higher = prioritize low latency)',
+              default: 0.3,
+            },
+            quality_weight: {
+              type: 'number',
+              description:
+                'Weight for quality optimization (0-1, higher = prioritize output quality)',
+              default: 0.2,
+            },
+            carbon_weight: {
+              type: 'number',
+              description:
+                'Weight for carbon footprint optimization (0-1, higher = prioritize low carbon)',
+              default: 0.1,
+            },
+            models: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'List of model IDs to include (empty array means all available models)',
+              default: [],
+            },
+            fallback_enabled: {
+              type: 'boolean',
+              description:
+                'Enable automatic fallbacks if primary model fails (recommended: true)',
+              default: true,
+            },
+            budget_limit: {
+              type: 'number',
+              description: 'Optional maximum cost per token in USD',
+            },
+            enable_caching: {
+              type: 'boolean',
+              description:
+                'Enable response caching to improve speed and reduce costs',
+              default: false,
+            },
+            enable_rate_limit: {
+              type: 'boolean',
+              description:
+                'Enable rate limiting to protect against excessive usage',
+              default: false,
+            },
+            timeout: {
+              type: 'number',
+              description: 'Request timeout in seconds (5-300)',
+              default: 30,
+            },
+            rate_limit: {
+              type: 'number',
+              description:
+                'Maximum requests per minute when rate limiting is enabled',
+              default: 100,
+            },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'test_request',
+        description:
+          'Test a router with a real request. Returns response, cost breakdown, latency, and model used.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            router_id: {
+              type: 'string',
+              description: 'Router ID to test',
+            },
+            messages: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  role: {
+                    type: 'string',
+                    enum: ['system', 'user', 'assistant'],
+                  },
+                  content: { type: 'string' },
+                },
+                required: ['role', 'content'],
+              },
+              description: 'Chat messages to send',
+            },
+            parameters: {
+              type: 'object',
+              description:
+                'Optional parameters (temperature, max_tokens, etc.)',
+            },
+          },
+          required: ['router_id', 'messages'],
+        },
+      },
+      {
+        name: 'get_usage_summary',
+        description:
+          'Get usage statistics and costs for a time range. Returns total cost, requests, top models, and daily breakdown.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            time_range: {
+              type: 'string',
+              enum: ['24h', '7d', '30d'],
+              description: 'Time range for usage summary (default: 7d)',
+            },
+          },
+        },
+      },
+      {
+        name: 'list_models',
+        description:
+          'List all available models with their pricing, capabilities, and providers.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'list_routers',
+        description:
+          'List all routers created by the user with their configuration and status.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'get_balance',
+        description:
+          'Check current credit balance, subscription status, and monthly usage.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'list_agents',
+        description:
+          'List all agents created by the user. Returns agent IDs, names, descriptions, and configuration summary.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            include_inactive: {
+              type: 'boolean',
+              description: 'Include disabled agents (default: false)',
+              default: false,
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum number of agents to return (default: 50, max: 100)',
+              default: 50,
+            },
+            start_after: {
+              type: 'string',
+              description:
+                'Optional pagination cursor from a prior list_agents response',
+            },
+          },
+        },
+      },
+      {
+        name: 'get_agent',
+        description:
+          'Get detailed configuration of a specific agent, including steps, skills, tools, and settings.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description: 'The agent ID to retrieve',
+            },
+          },
+          required: ['agent_id'],
+        },
+      },
+      {
+        name: 'create_agent',
+        description:
+          'Create a new agent with optional steps, skills, tools, and router assignment. Use display_name for human-friendly naming; name is optional slug override.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description:
+                'Optional slug-style ID (e.g., "customer-support-agent"). If omitted, generated from display_name.',
+            },
+            display_name: {
+              type: 'string',
+              description: 'Human-readable name for the agent',
+            },
+            description: {
+              type: 'string',
+              description: 'Optional description of what the agent does',
+            },
+            router_id: {
+              type: 'string',
+              description:
+                'Optional router ID to use for agent execution. If omitted, default routing is used.',
+            },
+            steps: {
+              type: 'array',
+              items: { type: 'object' },
+              description:
+                'Optional workflow step definitions. If omitted, a default single step is created.',
+            },
+            skills: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Optional list of skill IDs enabled for this agent',
+            },
+            builtin_tools: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'Optional built-in tool IDs (e.g. web search, calculator, scraper)',
+            },
+            tools: {
+              type: 'array',
+              items: { type: 'object' },
+              description:
+                'Optional custom tools in OpenAI function tool format with optional webhook metadata',
+            },
+            settings: {
+              type: 'object',
+              description:
+                'Optional execution settings (planning_mode, timeout, tool backend, optimization flags)',
+            },
+            is_active: {
+              type: 'boolean',
+              description: 'Whether the agent should be active immediately',
+              default: true,
+            },
+          },
+          anyOf: [{ required: ['display_name'] }, { required: ['name'] }],
+        },
+      },
+      {
+        name: 'update_agent',
+        description:
+          'Update an existing agent. Pass a partial updates object for safe patching, or provide top-level helper fields.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description: 'Agent ID to update (accepts "agent:<id>" or plain ID)',
+            },
+            updates: {
+              type: 'object',
+              description:
+                'Preferred: partial update payload (display_name, description, router_id, steps, skills, builtin_tools, tools, settings, is_active).',
+            },
+            expected_version: {
+              type: 'number',
+              description:
+                'Optional optimistic-lock version. Update fails if current version differs.',
+            },
+            display_name: {
+              type: 'string',
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            description: {
+              type: 'string',
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            router_id: {
+              type: 'string',
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            steps: {
+              type: 'array',
+              items: { type: 'object' },
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            skills: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            builtin_tools: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            tools: {
+              type: 'array',
+              items: { type: 'object' },
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            settings: {
+              type: 'object',
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+            is_active: {
+              type: 'boolean',
+              description:
+                'Optional shorthand when updates object is not provided',
+            },
+          },
+          required: ['agent_id'],
+        },
+      },
+      {
+        name: 'delete_agent',
+        description:
+          'Delete an agent permanently. Use carefully; this cannot be undone.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description: 'Agent ID to delete (accepts "agent:<id>" or plain ID)',
+            },
+          },
+          required: ['agent_id'],
+        },
+      },
+      {
+        name: 'toggle_agent',
+        description:
+          'Enable or disable an agent without deleting it.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description: 'Agent ID to toggle (accepts "agent:<id>" or plain ID)',
+            },
+            is_active: {
+              type: 'boolean',
+              description: 'Target active state',
+            },
+          },
+          required: ['agent_id', 'is_active'],
+        },
+      },
+      {
+        name: 'duplicate_agent',
+        description:
+          'Clone an existing agent, including steps, skills, and tools.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description:
+                'Source agent ID to duplicate (accepts "agent:<id>" or plain ID)',
+            },
+            new_display_name: {
+              type: 'string',
+              description:
+                'Optional new display name for the copy. Default appends "(Copy)".',
+            },
+          },
+          required: ['agent_id'],
+        },
+      },
+      {
+        name: 'get_agent_usage',
+        description:
+          'Get current agent usage count, plan limit, remaining slots, and plan name.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      {
+        name: 'list_agent_templates',
+        description:
+          'List built-in starter agent templates that can be forked into your account.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: {
+              type: 'string',
+              description: 'Optional template category filter',
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum templates to return (default: 50, max: 100)',
+              default: 50,
+            },
+          },
+        },
+      },
+      {
+        name: 'fork_agent_template',
+        description:
+          'Create a new personal agent from a built-in template.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            template_id: {
+              type: 'string',
+              description: 'Template ID to fork',
+            },
+            new_display_name: {
+              type: 'string',
+              description: 'Optional display name override for the new agent',
+            },
+          },
+          required: ['template_id'],
+        },
+      },
+      {
+        name: 'run_agent',
+        description:
+          'Execute an Agentlify agent with a message. The agent uses intelligent model routing, multi-step reasoning, and built-in skills. Returns the response, cost breakdown, and execution metadata.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description:
+                'The agent ID to run (e.g., "my-agent" or "agent:my-agent")',
+            },
+            messages: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  role: {
+                    type: 'string',
+                    enum: ['system', 'user', 'assistant', 'tool'],
+                  },
+                  content: { type: 'string' },
+                  tool_call_id: {
+                    type: 'string',
+                    description:
+                      'Required when role is "tool": tool call ID being resolved',
+                  },
+                  tool_calls: {
+                    type: 'array',
+                    description:
+                      'Assistant tool calls to preserve during tool-call continuation',
+                  },
+                },
+                required: ['role', 'content'],
+              },
+              description: 'Chat messages to send to the agent',
+            },
+            tools: {
+              type: 'array',
+              items: { type: 'object' },
+              description:
+                'Optional tools in OpenAI function calling format. If the agent needs to use these, the response will include tool_calls.',
+            },
+          },
+          required: ['agent_id', 'messages'],
+        },
+      },
+      {
+        name: 'list_agent_runs',
+        description:
+          'Get execution history for a specific agent. Returns cost, latency, tokens, and status per run.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            agent_id: {
+              type: 'string',
+              description: 'The agent ID to get runs for',
+            },
+            limit: {
+              type: 'number',
+              description:
+                'Maximum number of runs to return (default: 20, max: 100)',
+              default: 20,
+            },
+            status: {
+              type: 'string',
+              description:
+                'Optional run status filter (e.g., "completed", "failed", "running")',
+            },
+            start_date: {
+              type: 'string',
+              description:
+                'Optional ISO start date filter. Only runs started after this date are included.',
+            },
+            end_date: {
+              type: 'string',
+              description:
+                'Optional ISO end date filter. Only runs started before this date are included.',
+            },
+            start_after: {
+              type: 'string',
+              description:
+                'Optional pagination cursor (execution ID) to fetch runs after a previous page.',
+            },
+          },
+          required: ['agent_id'],
+        },
+      },
+      {
+        name: 'get_agent_run_detail',
+        description:
+          'Get full details for a specific agent run, including step timeline, final output, and metrics.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            execution_id: {
+              type: 'string',
+              description: 'Execution ID returned from list_agent_runs',
+            },
+          },
+          required: ['execution_id'],
+        },
+      },
+      {
+        name: 'export_agent_runs',
+        description:
+          'Export agent runs for analytics or debugging. Supports json, jsonl, and csv formats.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            execution_ids: {
+              type: 'array',
+              items: { type: 'string' },
+              description:
+                'Optional list of specific run IDs to export. If omitted, exports by filters.',
+            },
+            format: {
+              type: 'string',
+              enum: ['json', 'jsonl', 'csv'],
+              description: 'Export format (default: json)',
+              default: 'json',
+            },
+            include_steps: {
+              type: 'boolean',
+              description:
+                'Whether to include full step-level details in export payloads',
+              default: true,
+            },
+            agent_id: {
+              type: 'string',
+              description:
+                'Optional agent filter when exporting by query rather than explicit IDs',
+            },
+            limit: {
+              type: 'number',
+              description:
+                'Optional maximum records when exporting by query (default backend behavior applies)',
+            },
+          },
+        },
+      },
+    ],
+  };
+});
+
+/**
+ * Handle MCP Tool calls
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result;
+
+    switch (name) {
+      case 'create_router':
+        result = await callHttpEndpoint('mcpCreateRouterHttp', args);
+        break;
+      case 'test_request':
+        result = await callHttpEndpoint('mcpTestRequestHttp', args);
+        break;
+      case 'get_usage_summary':
+        result = await callHttpEndpoint('mcpGetUsageSummaryHttp', args);
+        break;
+      case 'list_models':
+        result = await callHttpEndpoint('mcpListModelsHttp', args);
+        break;
+      case 'list_routers':
+        result = await callHttpEndpoint('mcpListRoutersHttp', args);
+        break;
+      case 'get_balance':
+        result = await callHttpEndpoint('mcpGetBalanceHttp', args);
+        break;
+      case 'list_agents':
+        result = await callHttpEndpoint('mcpListAgentsHttp', args);
+        break;
+      case 'get_agent':
+        result = await callHttpEndpoint('mcpGetAgentHttp', args);
+        break;
+      case 'create_agent':
+        result = await callHttpEndpoint('mcpCreateAgentHttp', args);
+        break;
+      case 'update_agent':
+        result = await callHttpEndpoint('mcpUpdateAgentHttp', args);
+        break;
+      case 'delete_agent':
+        result = await callHttpEndpoint('mcpDeleteAgentHttp', args);
+        break;
+      case 'toggle_agent':
+        result = await callHttpEndpoint('mcpToggleAgentHttp', args);
+        break;
+      case 'duplicate_agent':
+        result = await callHttpEndpoint('mcpDuplicateAgentHttp', args);
+        break;
+      case 'get_agent_usage':
+        result = await callHttpEndpoint('mcpGetAgentUsageHttp', args);
+        break;
+      case 'list_agent_templates':
+        result = await callHttpEndpoint('mcpListAgentTemplatesHttp', args);
+        break;
+      case 'fork_agent_template':
+        result = await callHttpEndpoint('mcpForkAgentTemplateHttp', args);
+        break;
+      case 'run_agent': {
+        const {
+          agent_id: agentId,
+          messages: agentMessages,
+          tools: agentTools,
+        } = args as any;
+        const agentStartTime = Date.now();
+
+        const agentResponse = await fetch(AGENT_API_URL, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${API_KEY}`,
+          },
+          body: JSON.stringify({
+            agentId:
+              typeof agentId === 'string' && agentId.startsWith('agent:')
+                ? agentId.slice(6)
+                : agentId,
+            messages: agentMessages,
+            ...(agentTools ? { tools: agentTools } : {}),
+          }),
+          signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+        });
+
+        if (!agentResponse.ok) {
+          const errorText = await agentResponse.text();
+          throw new Error(`Agent execution failed: ${errorText}`);
+        }
+
+        const agentData = (await agentResponse.json()) as any;
+        const agentLatency = Date.now() - agentStartTime;
+
+        result = {
+          success: true,
+          response: agentData.choices?.[0]?.message?.content || '',
+          model: agentData.model,
+          requires_tool_execution:
+            agentData.agent_metadata?.requires_tool_execution || false,
+          tool_calls: agentData.choices?.[0]?.message?.tool_calls || null,
+          cost: agentData.cost || 0,
+          cost_breakdown: agentData.costBreakdown || null,
+          usage: agentData.usage || null,
+          agent_metadata: agentData.agent_metadata || null,
+          latency_ms: agentLatency,
+        };
+        break;
+      }
+      case 'list_agent_runs':
+        result = await callHttpEndpoint('mcpListAgentRunsHttp', args);
+        break;
+      case 'get_agent_run_detail':
+        result = await callHttpEndpoint('mcpGetAgentRunDetailHttp', args);
+        break;
+      case 'export_agent_runs':
+        result = await callHttpEndpoint('mcpExportAgentRunsHttp', args);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${(error as Error).message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+/**
+ * List available resources (documentation)
+ */
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: 'agentlify://quickstart',
+        name: '5-Minute Quickstart',
+        mimeType: 'text/markdown',
+        description: 'Get started with Agentlify in 5 minutes',
+      },
+      {
+        uri: 'agentlify://migration/openai',
+        name: 'OpenAI Migration Guide',
+        mimeType: 'text/markdown',
+        description: 'Complete guide for migrating from OpenAI to Agentlify',
+      },
+      {
+        uri: 'agentlify://migration/anthropic',
+        name: 'Anthropic Migration Guide',
+        mimeType: 'text/markdown',
+        description: 'Complete guide for migrating from Anthropic to Agentlify',
+      },
+      {
+        uri: 'agentlify://router-configuration',
+        name: 'Router Configuration Guide',
+        mimeType: 'text/markdown',
+        description: 'How to configure routers for optimal performance',
+      },
+      {
+        uri: 'agentlify://sdk/python',
+        name: 'Python SDK Reference',
+        mimeType: 'text/markdown',
+        description: 'Complete Python SDK documentation',
+      },
+      {
+        uri: 'agentlify://sdk/javascript',
+        name: 'JavaScript/TypeScript SDK',
+        mimeType: 'text/markdown',
+        description: 'Complete JavaScript SDK documentation',
+      },
+      {
+        uri: 'agentlify://routing-strategies',
+        name: 'Routing Strategies Explained',
+        mimeType: 'text/markdown',
+        description: 'Understanding cost, quality, and speed optimization',
+      },
+      {
+        uri: 'agentlify://cost-optimization',
+        name: 'Cost Optimization Guide',
+        mimeType: 'text/markdown',
+        description: 'Top strategies for reducing AI costs',
+      },
+      {
+        uri: 'agentlify://examples/chatbot',
+        name: 'Chatbot Example',
+        mimeType: 'text/markdown',
+        description: 'Complete production chatbot implementation',
+      },
+      {
+        uri: 'agentlify://pricing',
+        name: 'Pricing & Billing',
+        mimeType: 'text/markdown',
+        description: 'Understanding Agentlify pricing',
+      },
+    ],
+  };
+});
+
+/**
+ * Read resource content
+ */
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  const docMap: Record<string, string> = {
+    'agentlify://quickstart': 'quickstart.md',
+    'agentlify://migration/openai': 'migration-openai.md',
+    'agentlify://migration/anthropic': 'migration-anthropic.md',
+    'agentlify://router-configuration': 'router-configuration.md',
+    'agentlify://sdk/python': 'sdk-python.md',
+    'agentlify://sdk/javascript': 'sdk-javascript.md',
+    'agentlify://routing-strategies': 'routing-strategies.md',
+    'agentlify://cost-optimization': 'cost-optimization.md',
+    'agentlify://examples/chatbot': 'example-chatbot.md',
+    'agentlify://pricing': 'pricing.md',
+  };
+
+  const filename = docMap[uri];
+  if (!filename) {
+    throw new Error(`Unknown resource: ${uri}`);
+  }
+
+  try {
+    const content = await readDoc(filename);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: 'text/markdown',
+          text: content,
+        },
+      ],
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to read resource: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+});
+
+/**
+ * Start server
+ */
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Agentlify MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});