MCP Server Chart

Instructions

Implementation Reference

• src/utils/callTool.ts:44-111 (handler)

  Generic handler function for executing chart tools. For 'generate_organization_chart', maps to 'organization-chart', validates input schema from Charts.organizationChart.schema, generates chart URL via generateChartUrl, and returns content with URL and spec metadata.

  export async function callTool(tool: string, args: object = {}) {
    logger.info(`Calling tool: ${tool}`);
    const chartType = CHART_TYPE_MAP[tool as keyof typeof CHART_TYPE_MAP];
  
    if (!chartType) {
      logger.error(`Unknown tool: ${tool}`);
      throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${tool}.`);
    }
  
    try {
      // Validate input using Zod before sending to API.
      // Select the appropriate schema based on the chart type.
      const schema = Charts[chartType].schema;
  
      if (schema) {
        // Use safeParse instead of parse and try-catch.
        const result = z.object(schema).safeParse(args);
        if (!result.success) {
          logger.error(`Invalid parameters: ${result.error.message}`);
          throw new McpError(
            ErrorCode.InvalidParams,
            `Invalid parameters: ${result.error.message}`,
          );
        }
      }
  
      const isMapChartTool = [
        "generate_district_map",
        "generate_path_map",
        "generate_pin_map",
      ].includes(tool);
  
      if (isMapChartTool) {
        // For map charts, we use the generateMap function, and return the mcp result.
        const { metadata, ...result } = await generateMap(tool, args);
        return result;
      }
  
      const url = await generateChartUrl(chartType, args);
      logger.info(`Generated chart URL: ${url}`);
  
      return {
        content: [
          {
            type: "text",
            text: url,
          },
        ],
        _meta: {
          description:
            "This is the chart's spec and configuration, which can be renderred to corresponding chart by AntV GPT-Vis chart components.",
          spec: { type: chartType, ...args },
        },
      };
      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
    } catch (error: any) {
      logger.error(
        `Failed to generate chart: ${error.message || "Unknown error"}.`,
      );
      if (error instanceof McpError) throw error;
      if (error instanceof ValidateError)
        throw new McpError(ErrorCode.InvalidParams, error.message);
      throw new McpError(
        ErrorCode.InternalError,
        `Failed to generate chart: ${error?.message || "Unknown error."}`,
      );
    }
  }

• src/charts/organization-chart.ts:60-69 (schema)

  Tool definition including inputSchema (derived from Zod schema via zodToJsonSchema) for MCP tool registration and validation.

  const tool = {
    name: "generate_organization_chart",
    description:
      "Generate an organization chart to visualize the hierarchical structure of an organization, such as, a diagram showing the relationship between a CEO and their direct reports.",
    inputSchema: zodToJsonSchema(schema),
    annotations: {
      title: "Generate Organization Chart",
      readOnlyHint: true,
    },
  };

• src/charts/organization-chart.ts:37-58 (schema)

  Input schema object used to generate inputSchema for the tool, including data (OrganizationChartNodeSchema), orient, style, theme, width, height.

  const schema = {
    data: OrganizationChartNodeSchema.describe(
      "Data for organization chart which is a hierarchical structure, such as, { name: 'CEO', description: 'Chief Executive Officer', children: [{ name: 'CTO', description: 'Chief Technology Officer', children: [{ name: 'Dev Manager', description: 'Development Manager' }] }] }, and the maximum depth is 3.",
    ),
    orient: z
      .enum(["horizontal", "vertical"])
      .default("vertical")
      .describe(
        "Orientation of the organization chart, either horizontal or vertical. Default is vertical, when the level of the chart is more than 3, it is recommended to use horizontal orientation.",
      ),
    style: z
      .object({
        texture: TextureSchema,
      })
      .optional()
      .describe(
        "Style configuration for the chart with a JSON object, optional.",
      ),
    theme: ThemeSchema,
    width: WidthSchema,
    height: HeightSchema,
  };

• src/server.ts:64-77 (registration)

  Sets up MCP request handlers for tools/list and tools/call. ListTools returns enabled chart.tool objects including generate_organization_chart. CallTool invokes callTool with params.

  function setupToolHandlers(server: Server): void {
    logger.info("setting up tool handlers...");
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: getEnabledTools().map((chart) => chart.tool),
    }));
  
    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
    server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
      logger.info("calling tool", request.params.name, request.params.arguments);
  
      return await callTool(request.params.name, request.params.arguments);
    });
    logger.info("tool handlers set up");
  }

• src/charts/index.ts:18-18 (registration)

  Re-exports organizationChart (with schema and tool) as 'organization-chart' so Charts['organization-chart'] is available for schema validation and tool listing.

  export { organizationChart as "organization-chart" } from "./organization-chart";

• src/utils/callTool.ts:24-24 (helper)

  CHART_TYPE_MAP entry mapping tool name 'generate_organization_chart' to chart type 'organization-chart' used in callTool to lookup schema and generate chart.

  generate_organization_chart: "organization-chart",