create_from_mermaid

Convert Mermaid diagrams to Excalidraw elements for collaborative diagramming and visualization.

Instructions

Convert a Mermaid diagram to Excalidraw elements

Input Schema

TableJSON Schema

Name	Required	Description	Default
`mermaidDiagram`	Yes
`config`	No

Implementation Reference

src/mcp/index.ts:463-490 (handler)

Tool registration and inline handler implementation for create_from_mermaid. This is the actual executing code that parses mermaidDiagram and config, calls client.convertMermaid(), and returns success/error messages.

// --- Tool: create_from_mermaid ---
server.tool(
  'create_from_mermaid',
  'Convert a Mermaid diagram to Excalidraw elements',
  {
    mermaidDiagram: z.string().min(1).max(LIMITS.MAX_MERMAID_LENGTH),
    config: z.object({
      startOnLoad: z.boolean().optional(),
      flowchart: z.object({ curve: z.enum(['linear', 'basis']).optional() }).optional(),
      themeVariables: z.object({ fontSize: z.string().max(10).optional() }).optional(),
      maxEdges: z.number().int().min(1).max(1000).optional(),
      maxTextSize: z.number().int().min(1).max(100000).optional(),
    }).optional(),
  },
  async ({ mermaidDiagram, config }) => {
    try {
      await client.convertMermaid(mermaidDiagram, config as Record<string, unknown>);
      return {
        content: [{
          type: 'text',
          text: 'Mermaid conversion broadcast to canvas. Elements will appear when a frontend client is connected.',
        }],
      };
    } catch (err) {
      return { content: [{ type: 'text', text: `Error: ${(err as Error).message}` }], isError: true };
    }
  }
);

src/mcp/schemas/element.ts:194-214 (schema)

Zod schema definition for Mermaid diagram conversion input validation. Defines the structure for mermaidDiagram string and optional config object.

export const MermaidSchema = z
  .object({
    mermaidDiagram: z.string().min(1).max(LIMITS.MAX_MERMAID_LENGTH),
    config: z
      .object({
        startOnLoad: z.boolean().optional(),
        flowchart: z
          .object({})
          .strict()
          .optional(),
        themeVariables: z
          .object({})
          .strict()
          .optional(),
        maxEdges: z.number().int().min(1).max(1000).optional(),
        maxTextSize: z.number().int().min(1).max(100_000).optional(),
      })
      .strict()
      .optional(),
  })
  .strict();

src/mcp/canvas-client.ts:148-162 (helper)

CanvasClient method that performs the actual HTTP POST request to /api/elements/from-mermaid endpoint with the mermaid diagram and config.

async convertMermaid(
  mermaidDiagram: string,
  config?: Record<string, unknown>
): Promise<void> {
  const res = await fetch(`${this.baseUrl}/api/elements/from-mermaid`, {
    method: 'POST',
    headers: this.headers(),
    body: JSON.stringify({ mermaidDiagram, config }),
  });

  if (!res.ok) {
    const body = await res.json().catch(() => ({})) as ApiResponse;
    throw new Error(body.error ?? `Canvas error: ${res.status}`);
  }
}

src/mcp/tools/create-from-mermaid.ts:1-14 (helper)

Alternative exported handler function that uses MermaidSchema for validation and calls client.convertMermaid(). Note: This function is exported but not currently used by the MCP server registration.

import type { CanvasClient } from '../canvas-client.js';
import { MermaidSchema } from '../schemas/element.js';

export async function createFromMermaidTool(
  args: unknown,
  client: CanvasClient
) {
  const { mermaidDiagram, config } = MermaidSchema.parse(args);
  await client.convertMermaid(
    mermaidDiagram,
    config as Record<string, unknown> | undefined
  );
  return { success: true, message: 'Mermaid conversion sent to canvas' };
}

src/mcp/index.ts:572-572 (registration)

Sandbox server registration for capability scanning. This is a noop registration used for Smithery capability detection.

server.tool('create_from_mermaid', 'Convert a Mermaid diagram to Excalidraw elements', { mermaidDiagram: z.string().min(1).max(LIMITS.MAX_MERMAID_LENGTH) }, noop);

excalidraw-mcp-server