refactor: support sse and streamable

Author: xile611

package.json

@@ -44,7 +44,7 @@
     "inspector": "npx @modelcontextprotocol/inspector build/index.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.15.0",
     "@visactor/generate-vchart": "^2.0.8",
     "@visactor/vutils": "^1.0.7",
     "axios": "^1.10.0",

pnpm-lock.yaml

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { convertZodToJsonSchema } from "../utils/schema";
+import { z } from 'zod';
+import { convertZodToJsonSchema } from '../utils/schema';
 import {
   BackgroundSchema,
   ChartOutputSchema,
@@ -24,7 +24,7 @@ import {
   YAxisTitleSchema,
   YAxisTypeSchema,
   YFieldSchema,
-} from "./common";
+} from './common';
 
 const schema = z.object({
   output: ChartOutputSchema,
@@ -33,12 +33,11 @@ const schema = z.object({
   dataTable: z
     .array(z.any())
     .describe("Scatter chart data, e.g., [{ x: 34, y: 10, category: 'A' }].")
-    .nonempty({ message: "Scatter chart data cannot be empty." }),
-  transpose: z.boolean().optional(),
+    .nonempty({ message: 'Scatter chart data cannot be empty.' }),
 
   xField: YFieldSchema,
   yField: YFieldSchema,
-  sizeField: z.string().nullish().describe("Numeric field for bubble size."),
+  sizeField: z.string().nullish().describe('Numeric field for bubble size.'),
   colorField: ColorFieldSchema,
 
   chartTheme: ThemeSchema,
@@ -64,9 +63,9 @@ const schema = z.object({
 });
 
 const tool = {
-  name: "generate_scatter_chart",
+  name: 'generate_scatter_chart',
   description:
-    "Generate a scatter chart to visually display the distribution, clustering trends, and correlations of data points in two-dimensional or multi-dimensional space. Suitable for analyzing relationships between variables, outlier detection, and similar scenarios.",
+    'Generate a scatter chart to visually display the distribution, clustering trends, and correlations of data points in two-dimensional or multi-dimensional space. Suitable for analyzing relationships between variables, outlier detection, and similar scenarios.',
   inputSchema: convertZodToJsonSchema(schema),
 };
 

src/charts/scatter.ts

@@ -1,154 +1,125 @@
 #!/usr/bin/env node
 
-/**
- * This is a template MCP server that implements a simple notes system.
- * It demonstrates core MCP concepts like resources and tools by allowing:
- * - Listing notes as resources
- * - Reading individual notes
- * - Creating new notes via a tool
- * - Summarizing all notes via a prompt
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  McpError,
-  ErrorCode,
-} from '@modelcontextprotocol/sdk/types.js';
+import { createMCPServer } from './server';
+import { startSSEServer } from './services/sse';
+import { startStdioServer } from './services/stdio';
+import { startStreamableServer } from './services/streamable';
 
-import * as Charts from './charts/index';
-import { generateChartByType } from './utils/generateChart';
+type TransportType = 'stdio' | 'sse' | 'streamable';
 
 /**
- * Create an MCP server with capabilities for resources (to list/read notes),
- * tools (to create new notes), and prompts (to summarize notes).
+ * Simple CLI argument parser (no external dependencies)
  */
-const server = new Server(
-  {
-    name: 'vchart-mcp-server',
-    version: '0.1.3',
-  },
-  {
-    capabilities: {
-      resources: {},
-      tools: {},
-      prompts: {},
-    },
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options: {
+    transport?: TransportType;
+    help?: boolean;
+    port?: number;
+    endpoint?: string;
+  } = {
+    transport: 'stdio' as TransportType,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--transport' || arg === '-t') {
+      const nextArg = args[i + 1];
+      if (nextArg && ['stdio', 'sse', 'streamable'].includes(nextArg)) {
+        options.transport = nextArg as TransportType;
+        i++; // skip next argument
+      }
+    } else if (arg === '--port' || arg === '-p') {
+      const nextArg = args[i + 1];
+      if (nextArg && !isNaN(parseInt(nextArg))) {
+        options.port = parseInt(nextArg);
+        i++; // skip next argument
+      }
+    } else if (arg === '--endpoint' || arg === '-e') {
+      const nextArg = args[i + 1];
+      if (nextArg) {
+        // 确保 endpoint 以 '/' 开头
+        options.endpoint = nextArg.startsWith('/') ? nextArg : `/${nextArg}`;
+        i++; // skip next argument
+      }
+    }
   }
-);
+
+  return options;
+}
 
 /**
- * Handler that lists available tools.
- * Exposes a single "create_note" tool that lets clients create new notes.
+ * Show help information
  */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: Object.values(Charts).map(chart => (chart as any).tool),
-  };
-});
+function showHelp() {
+  console.log(`
+VChart MCP Server v0.1.3
+Chart generation server with multiple transport modes
+
+Usage: node index.js [options]
+
+Options:
+  -t, --transport <type>   Transport type (stdio, sse, streamable) [default: stdio]
+  -p, --port <port>        Port number for HTTP-based transports [default: 3000]
+  -e, --endpoint <path>    Endpoint path for HTTP-based transports [default: /message]
+  -h, --help              Show this help message
+
+Examples:
+  node index.js                                    # Start with stdio transport
+  node index.js -t sse -p 3000                    # Start with SSE transport on port 3000
+  node index.js -t sse -p 3000 -e /api/sse       # Start with SSE transport on custom endpoint
+  node index.js -t streamable -p 3001 -e /stream  # Start with streamable transport on custom endpoint
+`);
+}
 
 /**
- * Handler for the create_note tool.
- * Creates a new note with the provided title and content, and returns success message.
+ * Main CLI application
  */
-server.setRequestHandler(CallToolRequestSchema, async request => {
-  const toolName = request.params.name;
-  const chartType = Object.keys(Charts).find(
-    key => (Charts as any)[key].tool.name === toolName
-  );
+async function main() {
+  const options = parseArgs();
 
-  if (!chartType) {
-    throw new McpError(
-      ErrorCode.MethodNotFound,
-      `Unknown tool: ${request.params.name}.`
-    );
+  if (options.help) {
+    showHelp();
+    return;
   }
 
   try {
-    // Validate input using Zod before sending to API.
-    const args = request.params.arguments || {};
-
-    // Select the appropriate schema based on the chart type.
-    const schema = Charts[chartType as keyof typeof Charts].schema;
-
-    if (schema) {
-      // Use safeParse instead of parse and try-catch.
-      const result = schema.safeParse(args);
-      if (!result.success) {
-        throw new McpError(
-          ErrorCode.InvalidParams,
-          `Invalid parameters: ${result.error.message}`
+    switch (options.transport) {
+      case 'stdio':
+        await startStdioServer(createMCPServer());
+        break;
+      case 'sse':
+        await startSSEServer(createMCPServer(), options.endpoint, options.port);
+        break;
+      case 'streamable':
+        await startStreamableServer(
+          createMCPServer,
+          options.endpoint,
+          options.port
         );
-      }
-    }
-
-    const res = await generateChartByType(chartType, args);
-
-    if (res && (res as any).spec) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify((res as any).spec, null, 2),
-          },
-        ],
-      };
-    }
-
-    if (res && (res as any).image) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: (res as any).image,
-          },
-        ],
-      };
-    }
-
-    if (res && (res as any).html) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: (res as any).html,
-          },
-        ],
-      };
+        break;
+      default:
+        console.error(`Unknown transport type: ${options.transport}`);
+        process.exit(1);
     }
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: 'Failed to generate chart',
-        },
-      ],
-    };
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  } catch (error: any) {
-    if (error instanceof McpError) {
-      throw error;
-    }
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Failed to generate chart: ${error?.message || 'Unknown error.'}`
-    );
+  } catch (error) {
+    console.error('Server error:', error);
+    process.exit(1);
   }
-});
-
-/**
- * Start the server using stdio transport.
- * This allows the server to communicate via standard input/output streams.
- */
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
 }
 
 main().catch(error => {
-  console.error('Server error:', error);
+  console.error('Failed to start server:', error);
   process.exit(1);
 });
+
+export {
+  createMCPServer,
+  startStdioServer,
+  startSSEServer,
+  startStreamableServer,
+};