AI Flowchart
Server Details
Create flowcharts, mind maps, sequence/ER/UML diagrams and charts as editable, presentable boards.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-06-18
- URL
TDQS
Scored across 4 tools
Each tool has a clearly distinct role: code_to_flowchart converts source code, create_diagram generates from text, list_templates lists available templates, and open_template opens one. There is no functional overlap that would cause an agent to misselect among them.
Most names follow a verb_noun snake_case pattern: create_diagram, list_templates, open_template. code_to_flowchart deviates slightly by using a noun_to_noun form, but it remains readable and consistent in casing.
Four tools are well-scoped for a diagram-generation service: two creation paths, one template discovery, and one template opening. The set is neither bloated nor too thin for the stated purpose.
The server covers creation from code and description plus template discovery and opening. It lacks direct tools for retrieving, updating, or deleting existing diagrams, but the returned editable-board links let agents work around those gaps.
Available Tools
4 toolscode_to_flowchartCode to flowchart with dry runAInspect
Turn source code (C, C++, Java, Python or JavaScript, up to 80 lines) into a lab-record style flowchart where every box is linked to its code lines, plus a step-by-step dry run for a sample input (current line, box and variables at each step). Returns a link that opens it ready to play (▶ Explain), the program output and Mermaid code. Uses 1 AI credit.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The program or function, as source code. | |
| language | No | Optional; detected if left out. | |
| sample_input | No | Optional input for the dry run, e.g. "n = 5". Picked automatically if left out. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnly=false, openWorld=true, idempotent=false, destructive=false. The description goes further, disclosing the returned artifacts (a ready-to-play link, the program output, Mermaid code) and the 1-credit cost. It stops short of saying whether the generated link is public or persists, which for an openWorldHint=true tool would be worth stating.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core transformation and then the output artifacts and cost. Dense but each clause carries information (languages, line cap, deliverables, credit cost) with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description compensates by enumerating the return payload (link, output, Mermaid code). Combined with the language list, size cap, optional-param auto-detection and credit cost, an agent has everything needed to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3; the description adds the 80-line limit on `code` and frames `sample_input` as feeding the dry run ('current line, box and variables at each step'), which sharpens what that optional param actually controls beyond the schema's terse 'Input for the dry run.'
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb+resource with scope: 'Turn source code ... into a lab-record style flowchart' with every box linked to its code lines, plus a dry run. It names the supported languages and the 80-line cap, so an agent can immediately tell this apart from the generic sibling create_diagram.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The input type (source code) makes the trigger condition clear, and the 'Uses 1 AI credit' note is a useful cost signal for deciding when to spend it. However, it never explicitly contrasts itself with create_diagram or the template tools, so routing between siblings is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_diagramCreate a diagramAInspect
Create a diagram in AI Flowchart from a plain-English description and get a link that opens it as an editable board (edit, present as an animated slideshow, export PNG/PDF/PowerPoint). Flowcharts, sequence diagrams and mind maps also come back as Mermaid code. Types: flowchart, mindmap, sequence (API / login flows), erdiagram (database), systemdesign (architecture), swimlane, orgchart, uml_class, uml_usecase, uml_state, uml_activity, timeline, gantt (project plan), chart (bar/line/pie… from data you describe). Uses 1 AI credit; advanced types need AI Flowchart Pro.
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | Kind of diagram. | |
| description | Yes | What to draw, in detail: the process, system, data, steps or numbers. Include names and specifics from the conversation. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations confirm this is a non-read-only, open-world, non-idempotent creation, and the description adds material context beyond them: it consumes 1 AI credit and some diagram types require a Pro subscription. It also discloses the return shape (editable board, animated slideshow, PNG/PDF/PowerPoint export, Mermaid code for select types), which is valuable with no output schema. It stops short of 5 by not covering failure modes or auth requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, capability and return disclosed first, then the type taxonomy. Dense with no filler, though the long type list probes the upper bound of a single-sentence enumeration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no separate reference doc, the description covers what the agent needs: inputs, the full type vocabulary, the credit cost and Pro gating, and what comes back. Nothing essential to calling it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the 3 baseline applies, but the description earns more by annotating every enum value with a parenthetical meaning (API/login flows, database, architecture, project plan) and by telling the agent what to put in 'description' (process, system, data, steps, numbers, names and specifics from the conversation). That is real added meaning over the terse schema fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Create) and resource (a diagram in AI Flowchart), plus the input modality (plain-English description) and the return (editable board link). That 'plain-English description' framing cleanly distinguishes it from the sibling code_to_flowchart, which takes code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'from a plain-English description' qualifier implicitly routes code input to code_to_flowchart, and the long type enumeration tells the agent which diagram kinds are supported and what each maps to (e.g. 'gantt (project plan)', 'erdiagram (database)'). It never explicitly names an alternative tool or states when-not to use it, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_templatesList templatesARead-onlyIdempotentInspect
List AI Flowchart's ready-made templates (lab programs, UML and ER for student projects, system designs, charts, app walkthroughs, code programs…). Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Optional board type to filter by, e.g. flowchart, erdiagram, sequence, mindmap, systemdesign, chart, codeflow, walkthrough. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety burden is met. The description adds genuinely new behavioral context: the call consumes no AI credits, which can drive agent decisions. It omits pagination and result-size behavior, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence naming the resource plus a short value tagline; the core purpose is front-loaded and nothing is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-argument list tool with full annotation coverage and no output schema, the description is sufficient — it names the resource, the category vocabulary, and the cost profile. Minor gaps are pagination and whether results are scoped to the user's workspace.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single optional 'type' filter is fully documented in the schema with enum-like examples, so the description need not repeat it. The category list in the description loosely maps to the filter values but adds no syntax beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (AI Flowchart's ready-made templates) and enumerates the template categories so an agent knows what comes back. It does not explicitly differentiate itself from the sibling open_template, but the list-vs-open distinction is inferable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use guidance, no prerequisites, and no reference to alternatives like open_template or create_diagram. The 'Free — no AI credits' note hints at when cost matters but is not framed as usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
open_templateOpen a templateARead-onlyIdempotentInspect
Get a link that opens one of the templates (from list_templates) as a new editable board. Free — no AI credits.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Template id from list_templates. | |
| type | Yes | Template type from list_templates. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds genuinely new context beyond them: the return value is a link, the effect is a new editable board, and the operation consumes no AI credits. Missing details are minor (whether the template itself is consumed, any auth requirement).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero waste, with the primary action and result front-loaded before the cost note. Nothing redundant with the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with no output schema and full annotation coverage, this is sufficient: the description supplies the return value (a link), the prerequisite (list_templates) and the cost profile. An agent has everything needed to select and call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters already say they come from list_templates, so the description's 'from list_templates' phrasing only reinforces the schema. No additional format or validation detail is offered, which is the expected baseline when the schema does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and outcome: get a link that opens a template as a new editable board. It also names the sibling that supplies the inputs (list_templates), so an agent can distinguish it from create_diagram and code_to_flowchart, which produce diagrams rather than link out to templates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clear context: this is the follow-up step to list_templates, and 'Free — no AI credits' signals the cost trade-off versus the AI-generating siblings. There is no explicit when-not or named alternative for other cases, which keeps it below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
code_to_flowchart - First observed
create_diagram - First observed
list_templates - First observed
open_template
Related MCP Connectors
Create workflow, sequence, architecture, and mind map diagrams via AI assistants.
Create, edit and organize hand-drawn diagrams (flowcharts, ER, architecture) from any AI agent.
Create, edit, share and render real-time collaborative diagrams and mindmaps on livediagram.app.
Flowcharts that people and agents edit together on one live canvas, exported as Mermaid.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceCreate visual whiteboards, diagrams, flowcharts, and project plans from AI conversations. 17 MCP tools for board management, element creation, and real-time collaboration.1MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI models and browser users to collaboratively create and edit a shared freeform canvas of positioned cards and directed connections, with tools for adding, updating, linking, and exporting boards as JSON or SVG.-
- AlicenseNot gradedqualityCmaintenanceEnables creating and editing Draw.io diagrams via natural language, supporting shapes, connectors, and multi-line text.2MIT
- FlicenseAqualityCmaintenanceTurns relational schemas into editable entity-relationship diagrams in draw.io, supporting live databases, SQL DDL, YAML/JSON specs, and existing .drawio files, with tools for managing tables, columns, and relations.16-
Glama MCP Gateway
Add one secure layer between your agents and this server.