This server extends draw.io to enable AI agents to create, view, analyze, and export engineering diagrams, with 269 specialized stencils and auto-layout generators for RF, PCB, and EMC workflows.
Open diagrams from XML, CSV, or Mermaid syntax, and load 269 engineering stencil libraries across RF, PCB, EMC, electrical, and wireless domains.
Generate RF block diagrams with auto-layout for 30+ block types (LNA, PA, mixer, filter, antenna, etc.), Friis cascade calculations for gain and noise figure, and injection sources with dashed connections.
Generate EMC test setups using CISPR 25 (radiated/conducted emissions) and ISO 11452 (radiated/BCI immunity) templates, with distance annotations and customizable equipment labels.
Generate PCB stackup cross-sections for 4-layer, 6-layer, or custom stacks, with color-coded layers (copper, prepreg, core, soldermask), material properties (Dk, Df), and thickness annotations supporting FR-4, Rogers, Megtron6, Isola 370HR, etc.
Mark up schematic screenshots with redline circles, revision clouds, delta callouts, arrows, and text notes on a separate annotation layer, with the original image locked as background.
Parse .drawio files to structured JSON, extracting shapes, edges, labels, positions, styles, and connections for analysis.
Export diagrams to SVG or PNG for documentation and sharing.
It integrates with Claude Code, Claude Desktop, and any MCP client as part of the eng-mcp-suite.
Generates engineering diagrams in draw.io from structured prompts, providing tools for creating RF block diagrams, PCB stackups, EMC test setups, and more.
Allows opening draw.io with diagrams described in Mermaid syntax.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@drawio-engineering-mcp create an RF receiver signal chain with antenna, LNA, mixer, and ADC"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Engineering diagrams in draw.io: RF block diagrams, PCB stackups, and EMC test setups generated from structured prompts. Drive it from your IDE, terminal, or AI agent and skip the manual stencil-dragging.
Quick start · Tools · Workflows · Documentation
drawio-engineering-mcp is a Node.js MCP server that gives an AI agent
the ability to create, view, and analyze engineering diagrams in
draw.io. It extends the
official draw.io MCP (@drawio/mcp)
with 10 tools and 269 drag-and-drop engineering symbols across RF,
PCB, EMC, wireless, electrical, and general engineering.
Where the upstream MCP gives you a diagram editor, this one gives you a diagram generator: an RF receiver signal chain with Friis-cascade annotations, a CISPR 25 / ISO 11452 test setup, a 6-layer PCB stackup with material-property labels. All from a one-sentence prompt or structured JSON input.
What it does well:
AI-native via MCP. First-class Model Context Protocol server with 10 tools wired into the draw.io browser app.
269 engineering stencils. RF blocks, amplifiers, filters, antennas, PCB stackup vias, EMC test equipment, wireless protocol badges, connectors, power ICs. All auto-loaded into the draw.io sidebar.
Auto-layout generators. create_rf_block_diagram runs Friis
gain/NF cascade math; create_pcb_stackup renders cross-sections
with material properties; create_emc_test_setup uses CISPR / ISO
templates.
yes Round-trip. read_drawio parses .drawio XML into structured
JSON (shapes, edges, styles) so an agent can analyze an existing
diagram. export_drawio renders to SVG / PNG.
AGPL-3.0-or-later. Built on the official draw.io MCP foundation (Apache-2.0); this server's engineering extensions are AGPL-3.0-or-later.
Related MCP server: draw-io-mcp
git clone https://github.com/RFingAdam/drawio-engineering-mcp.git
cd drawio-engineering-mcp
npm installClaude Code
claude mcp add drawio-engineering -s user -- \
node /path/to/drawio-engineering-mcp/src/index.jsClaude Desktop
{
"mcpServers": {
"drawio-engineering": {
"command": "node",
"args": ["/path/to/drawio-engineering-mcp/src/index.js"]
}
}
}Any MCP client: first prompt
Start a new session and ask:
"Create an RF receiver signal chain with antenna, SAW filter, LNA, mixer with PLL LO, IF filter, and ADC. Show cumulative gain and noise figure."
The agent calls create_rf_block_diagram and opens draw.io with a
color-coded, auto-laid-out diagram annotated with Friis cascade values.
10 MCP tools across 3 categories. Full reference in docs/tools.md.
Tool | Purpose | Key arguments |
| Open draw.io with raw XML content |
|
| Open draw.io with CSV data |
|
| Open draw.io with Mermaid syntax |
|
| Open draw.io with the 269 engineering stencils loaded in the sidebar |
|
Tool | Purpose | Key arguments |
| Auto-layout RF signal chain from JSON (Friis gain/NF cascade) |
|
| CISPR 25 / ISO 11452 EMC test setup diagrams from templates |
|
| PCB cross-section stackup diagrams (4-layer / 6-layer / custom) |
|
| Annotate schematic screenshots with redlines, revision clouds, callouts |
|
Tool | Purpose | Key arguments |
| Parse |
|
| Export diagrams to SVG (or PNG with puppeteer) |
|
269 engineering symbols across 13 libraries, automatically loaded by
open_drawio_engineering into the draw.io sidebar:
Library | Symbols | Contents |
| 30 | Core RF blocks (LNA, PA, mixer, filter, switch, antenna, …) |
| 16 | Amplifier variants (LNA, PA, VGA, driver, buffer, log, limiting) + mixers |
| 17 | BPF, LPF, HPF, notch, cavity, SAW, BAW, DSA, step / variable atten |
| 14 | Circulators, isolators, directional couplers, Wilkinson, hybrid, balun |
| 10 | Crystal, TCXO, OCXO, VCO, PLL, DDS, synthesizer |
| 15 | SPDT, SP4T, transfer, T/R, power detector, ADC, DAC |
| 20 | Dipole, patch, horn, array, MIMO, coax, microstrip, waveguide |
| 20 | LDO, buck, boost, flyback, battery, SoC, FPGA, MCU, QFN, BGA |
| 14 | SMA, U.FL, N-type, BNC, USB-C, RJ45, pin header, B2B |
| 18 | Spectrum analyzer, VNA, scope, LISN, CDN, anechoic chamber |
| 30 | Copper / prepreg / core layers, through / blind / buried / micro vias, impedance traces |
| 27 | Wi-Fi, BLE, LTE, 5G NR, LoRa, Zigbee, Thread, protocol badges, OFDM, QAM |
| 38 | System blocks, rack diagrams, cables, thermal management, R/L/C/transformer |
By default all libraries load. To load only specific ones:
{
"stencils": ["rf-blocks", "ee-connectors", "pcb-stackup-vias"]
}drawio-engineering-mcp fits in the following eng-mcp-suite
workflow bundles:
emc-compliance: pair create_emc_test_setup with
mcp-emc-regulations to generate the test setup diagram for the
exact CISPR / ISO method the limit lookup returned.
pcb-review: generate create_pcb_stackup cross-sections during
a mcp-pcb-emcopilot design review.
rf-design. Use create_rf_block_diagram to visualize the
cascade an LNA / mixer / filter chain produces: Friis numbers
annotated automatically.
Part of eng-mcp-suite.
Use in the emc-compliance, pcb-review, or rf-design workflow bundles.
See the suite manifest for the full list of sibling MCPs and bundle definitions.
Quick Start: install through first call.
Tool reference. Every MCP tool, every argument.
Usage examples: practical end-to-end walkthroughs.
Architecture: how this MCP fits in eng-mcp-suite.
This MCP server is part of
An open umbrella for engineering MCP servers across RF, EMC, PCB, signal integrity, EM simulation, and lab test. Same brand, same docs structure, designed to compose. See the full catalog or jump to a sibling:
Domain | Sibling MCPs |
RF / Transmission lines | |
EMC regulatory | |
PCB / SI | mcp-pcb-emcopilot (private: public soon) |
EM simulation | mcp-openems, mcp-nec2-antenna (private: public soon) |
Diagrams | drawio-engineering-mcp (this repo) |
3D / rendering | |
Remote access | |
Lab gear | copper-mountain-vna-mcp, mcp-rs-spectrum-analyzer, mcp-rs-siggen, mcp-rs-cmw500 |
Extended from the official draw.io MCP server
(@drawio/mcp) by JGraph Ltd.
Contributions are welcome.
Pick a GitHub issue.
Fork + branch (feature/your-thing or fix/your-bug).
Run tests (npm test) if present.
Open a PR: link the issue, request review.
AGPL-3.0-or-later. Relicensed from Apache-2.0 in v1.1.0 to align with the eng-mcp-suite toolkit-wide AGPL move. The upstream draw.io MCP foundation remains Apache-2.0; this server's engineering extensions and added tooling are AGPL-3.0-or-later.
This project is not affiliated with, endorsed by, or sponsored by JGraph Ltd. "draw.io" and "diagrams.net" are trademarks of JGraph Ltd. They are used here only to identify the software this project interoperates with.
The project name and the logo files in this repository are not part of the licensed work. The licence above grants no permission to use them, except as needed to describe the origin of the work.
JGraph Ltd / draw.io: for the
upstream @drawio/mcp and the underlying diagram editor.
The MCP working group: for the Model Context Protocol specification.
Part of eng-mcp-suite: built for RF engineers, PCB designers, EMC labs, and AI agents.
Generates an EMC test setup cross-section diagram from a template and opens it in draw.io. Shows equipment layout with ground plane, EUT on table, antenna on mast, and test instruments.
Available templates: cispr25_re: CISPR 25 Radiated Emissions - semi-anechoic chamber, antenna 1m from EUT, 150 kHz - 2.5 GHz cispr25_ce: CISPR 25 Conducted Emissions - LISN on each power line, 150 kHz - 108 MHz iso11452_2_ri: ISO 11452-2 Radiated Immunity - absorber-lined enclosure, 200 MHz - 18 GHz iso11452_4_ci: ISO 11452-4 Conducted Immunity (BCI) - BCI clamp on harness, 1 MHz - 400 MHz
Each template includes standard equipment, distances, and cable connections. Equipment labels can be overridden. Distance annotations are shown by default.
| Name | Required | Description | Default |
|---|---|---|---|
| template | Yes | EMC test standard template to use | |
| title | No | Diagram title (defaults to template name) | |
| show_distances | No | Show distance annotations between equipment. Default: true | |
| equipment_overrides | No | Override default equipment labels. Keys are equipment names (eut, antenna, spectrum_analyzer, signal_generator, power_amplifier, power_meter, lisn, bci_probe), values are custom label strings. | |
| auto_open | No | Automatically open the diagram in draw.io. Set to false to return XML only. Default: true |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses that the tool generates a diagram from a template, opens in draw.io by default, and supports label overrides and distance annotations. It does not mention side effects or permissions, but adequate for a creation tool.
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?
The description is well-structured with clear sections and bullet points for templates, providing comprehensive information without unnecessary verbosity.
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?
The description covers templates, parameters, and behavior well, but lacks explicit mention of the return value (e.g., XML string or URL) when auto_open is false.
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% per context signals. The description adds value by explaining each template's purpose and listing possible keys for equipment_overrides, going beyond the schema descriptions.
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?
The description clearly states it generates an EMC test setup diagram and opens it in draw.io, distinguishing it from sibling tools like create_rf_block_diagram and create_pcb_stackup.
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 description provides a list of available templates and mentions overrides, but does not explicitly state when to use this tool versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generates a PCB stackup cross-section diagram and opens it in draw.io. Shows each layer as a color-coded horizontal rectangle with labels and material properties.
Available templates: 4layer: Standard 4-Layer (L1 Signal / L2 GND / L3 PWR / L4 Signal, FR-4) 6layer: Standard 6-Layer (L1 Signal / L2 GND / L3-L4 Signal / L5 PWR / L6 Signal, FR-4) custom: Provide your own layers array
Layer types and colors: copper: Signal (red), GND (blue), PWR (orange) - weight in oz prepreg: Light yellow with material properties (Dk, Df) core: Light gray with material properties (Dk, Df) soldermask: Green (outer surfaces)
Available materials: fr4, rogers_4003c, rogers_4350b, megtron6, isola_370hr Copper weights: 0.5oz (17.5um), 1oz (35um), 2oz (70um)
| Name | Required | Description | Default |
|---|---|---|---|
| template | Yes | PCB stackup template. Use 'custom' with the layers parameter for custom stackups. | |
| layers | No | Custom layer array (used when template is 'custom'). Each layer has type, and type-specific properties. | |
| title | No | Diagram title (defaults to template name) | |
| show_dimensions | No | Show thickness and material property annotations. Default: true | |
| board_width_mm | No | Board width in mm (annotation only, does not affect layer width) | |
| auto_open | No | Automatically open the diagram in draw.io. Set to false to return XML only. Default: true |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the output (opens in draw.io, shows layers with colors), mentions available materials and copper weights, and notes the auto_open parameter to control opening behavior. It does not mention potential side effects or cleanup, but it is fairly transparent about the tool's behavior.
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?
The description is well-structured with clear sections for templates, layer types, materials, and copper weights. It is front-loaded with the main action and every sentence adds value without unnecessary words. It is appropriately sized for the complexity of the tool.
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?
Given the complexity (6 parameters, no output schema), the description covers the essential aspects: output type, templates, layer types, materials, and control over opening. It could mention error handling or what happens if custom template is used without layers, but overall it is complete enough for an agent to use the tool effectively.
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 description coverage is 100%, and the description adds significant context beyond the schema. It explains the meaning of templates, layer types and their colors, available materials, and copper weights. This helps the agent understand parameter values and their implications, providing value beyond the parameter descriptions.
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?
The description clearly states the tool generates a PCB stackup cross-section diagram and opens it in draw.io. It specifies the verb 'generates', the resource 'PCB stackup diagram', and the action 'opens in draw.io'. This distinguishes it from sibling tools that deal with other diagram types or export/read operations.
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 description provides clear guidance on when to use the tool (to generate a PCB stackup diagram) and explains available templates (4layer, 6layer, custom) with brief explanations. However, it does not explicitly state when not to use it or compare to alternatives among siblings, though the siblings are different diagram types, so the comparison is implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generates an RF signal chain block diagram from a JSON description and opens it in draw.io. Provide an array of blocks with type, label, and optional RF parameters. The tool auto-layouts blocks left-to-right with signal flow arrows and color-coded shapes. Injection sources (e.g. LO for a mixer) are placed below their target block with dashed arrows. Supports cumulative gain and noise figure annotations using the Friis formula.
Supported block types: Amplifiers: lna, pa, amplifier, driver Filters: bpf, lpf, hpf, notch Mixer: mixer Attenuators: attenuator, dsa Converters: adc, dac Oscillators: vco, oscillator, pll Antenna: antenna Passive: coupler, splitter, combiner, circulator, isolator, balun, duplexer, diplexer Switches: switch, spdt, sp4t Other: detector, custom
Each block object in the chain array accepts: type (required): one of the types above label: display name (defaults to standard abbreviation) sublabel: smaller text below the label (e.g. frequency) gain_db: gain in dB (defaults from component database) nf_db: noise figure in dB (defaults from component database) inject_to: label of the main chain block this injects into (for LO sources, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Array of block objects describing the signal chain in order. Blocks without inject_to form the main chain (left to right). Blocks with inject_to are injection sources placed below their target. | |
| title | No | Diagram title displayed at the top | |
| show_cumulative | No | Show cumulative gain and noise figure annotations below each main chain block (Friis formula). Default: false | |
| signal_flow_arrows | No | Draw signal flow arrows between adjacent main chain blocks. Default: true | |
| auto_open | No | Automatically open the diagram in draw.io. Set to false to return XML only. Default: true |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: auto-layout, signal flow arrows, color-coding, injection sources with dashed arrows, and cumulative gain/NF annotations via Friis formula. It also explains block properties and default behavior, leaving no ambiguity.
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?
The description is well-structured with clear sections: main purpose, layout behavior, block types list, and per-property details. Every sentence adds value without redundancy, and the information is front-loaded.
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?
Given no output schema, the description covers the tool's outcomes (opens in draw.io or returns XML if auto_open is false) and parameter behavior thoroughly. It lacks details on the returned XML format or error scenarios, but remains largely complete for a generation tool.
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%, but the description adds significant meaning beyond schema by explaining layout logic, inject_to placement, defaults from a component database, and the Friis formula for cumulative annotations. This enriches understanding of how parameters affect the output.
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?
The description clearly states the tool generates an RF signal chain block diagram from JSON and opens it in draw.io. It uses a specific verb 'generates' and resource 'RF signal chain block diagram', effectively distinguishing it from sibling tools like create_emc_test_setup or create_pcb_stackup.
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 description explains 'Provide an array of blocks...' and details the layout and supported types, implying when to use the tool for RF block diagrams. However, it does not explicitly contrast with siblings or provide when-not-to-use guidance, though the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Exports a draw.io diagram XML to an SVG or PNG file. For SVG export, the diagram is converted locally without requiring a browser. For PNG export, a headless browser (puppeteer) is used if available. Returns the file path of the exported image.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | The draw.io XML content (mxGraphModel format) to export | |
| format | No | Export format. Default: svg | |
| output_path | No | Output file path. If not specified, a temporary file is created. | |
| width | No | Output width in pixels (PNG only). Default: 800 | |
| height | No | Output height in pixels (PNG only). Default: 600 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full burden. It explains conversion mechanisms but omits potential failures (e.g., if puppeteer unavailable for PNG) and side effects beyond file creation.
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 purpose, no wasted words. Efficiently conveys all key information.
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?
Covers return value, parameter defaults, and format differences. With no output schema, description adequately rounds out understanding. Minor gap: no mention of content validation.
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 has 100% coverage with basic descriptions; description adds behavioral details for format and output_path (default tmp file). Provides value beyond 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?
The description clearly states the verb 'exports' and the specific resource (draw.io diagram XML to SVG or PNG), distinguishing it from sibling tools that open or read drawio files.
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?
Provides context on when to use SVG vs PNG based on browser requirement, but lacks explicit when-not-to-use or alternative tool mentions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Opens a schematic screenshot in draw.io with engineering annotations overlaid. The original image becomes a locked background layer. Annotations (redline circles, revision clouds, delta callouts, arrows, text notes) are placed on a foreground layer. Use this to mark up existing schematics with proposed changes, issues, or review comments. Claude can analyze a screenshot with vision first, then call this tool with coordinates and descriptions for each annotation.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | Yes | Absolute path to the schematic image file (PNG, JPG, etc.) | |
| annotations | Yes | Array of annotations to overlay on the schematic | |
| title | No | Optional title for the markup diagram | |
| image_width | No | Display width of the image in pixels. Default: 800 | |
| image_height | No | Display height of the image in pixels. Default: 600 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the locked background layer and foreground annotations, but lacks details on file handling, saving behavior, or limitations. No annotations are provided, so description carries full burden.
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?
Four sentences, front-loaded with key action, each sentence adds value. Could be slightly shorter but is well-structured and efficient.
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?
Covers workflow (vision first), layering, use case, and annotation types. Omits some behavioral details but is adequate given absence of output schema and annotations.
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%, meeting baseline. Description adds no extra meaning beyond what the schema provides for parameters, such as defaults for w, h, color.
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?
The description specifies 'opens a schematic screenshot in draw.io with engineering annotations' and lists annotation types, clearly distinguishing it from sibling tools like open_drawio_engineering or open_drawio_mermaid.
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?
Explicitly states 'Use this to mark up existing schematics' and suggests analyzing with vision first, providing clear context though not explicitly excluding alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Opens the draw.io editor with a diagram generated from CSV data. The CSV format should follow draw.io's CSV import specification which allows creating org charts, flowcharts, and other diagrams from tabular data.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | The CSV content following draw.io's CSV import format. | |
| lightbox | No | Open in lightbox mode (read-only view). Default: false | |
| dark | No | Dark mode setting. Default: auto |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states 'Opens the draw.io editor' without disclosing side effects, permissions, rate limits, or whether it is read-only or mutating. The lightbox parameter hints at read-only but is not explained.
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?
The description is two sentences with no wasted words. First sentence states purpose, second adds format context. Front-loaded with primary action.
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?
Given no output schema and no annotations, the description could elaborate on return behavior or errors. It adequately covers purpose and parameter context but lacks guidance on what the tool returns or how it behaves.
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% (all 3 parameters have descriptions). The description adds value by referencing 'draw.io's CSV import specification' for the content parameter, providing context beyond the schema. The lightbox and dark parameters are standard.
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?
The description clearly states 'Opens the draw.io editor with a diagram generated from CSV data', providing a specific verb and resource. It also distinguishes from siblings like open_drawio_xml or open_drawio_mermaid by specifying CSV data.
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 description implies use for tabular data via CSV, saying 'allows creating org charts, flowcharts, and other diagrams from tabular data'. This gives context but does not explicitly mention when to use or avoid compared to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Opens the draw.io editor with engineering diagram XML and automatically loads 240+ engineering stencil libraries in the sidebar. Libraries cover RF components (amplifiers, mixers, filters, switches, antennas, oscillators), electrical (power ICs, connectors, test equipment), PCB (stackup layers, vias, impedance), wireless/telecom (protocol badges, spectrum, modulation), and general engineering (system blocks, rack diagrams, cables, thermal management, passive components). Use this instead of open_drawio_xml when creating engineering block diagrams. IMPORTANT: Do NOT use double hyphens (--) inside XML comments.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | The draw.io XML content in mxGraphModel format. This is the diagram content; engineering stencils are loaded automatically in the sidebar. | |
| stencils | No | Which stencil libraries to load. Defaults to all libraries. Available: rf-blocks, rf-amplifiers-mixers, rf-filters-attenuators, rf-passive-components, rf-sources-oscillators, rf-switches-detectors, rf-antennas-txlines, ee-power-ics, ee-connectors, ee-test-equipment-emc, pcb-stackup-vias, wireless-telecom, general-engineering | |
| lightbox | No | Open in lightbox mode (read-only view). Default: false | |
| dark | No | Dark mode setting. Default: auto |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes automatic loading of 240+ stencil libraries and includes a syntax warning. However, lacks details on side effects, authentication needs, or output behavior. With no annotations, more disclosure would improve transparency.
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 plus a note, all essential. Front-loaded with main action, no redundant information.
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?
Covers purpose, usage guidance, and a critical syntax constraint. With no output schema, the description is adequate for an editor-opening tool. Could mention synchronous behavior or return value, but not essential.
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% with parameter descriptions. Description adds context that stencils are loaded automatically in the sidebar and lists library categories, providing meaning beyond the schema enum values.
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?
Clearly states it opens draw.io editor with engineering XML and loads stencil libraries. Distinguishes from sibling tool open_drawio_xml by specifying use for engineering block diagrams.
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?
Explicitly says to use this instead of open_drawio_xml for engineering block diagrams. Provides an important syntax note about avoiding double hyphens in XML comments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Opens the draw.io editor with a diagram generated from Mermaid.js syntax. Supports flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, and more using Mermaid.js syntax.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | The Mermaid.js diagram definition. Example: 'graph TD; A-->B; B-->C;' | |
| lightbox | No | Open in lightbox mode (read-only view). Default: false | |
| dark | No | Dark mode setting. Default: auto |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It does not mention whether the operation is read-only or destructive, or any other side effects. It only states it 'opens' the editor, leaving mutation unclear.
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 that are front-loaded with the primary action and then elaborate on supported types. No redundant information or wasted words.
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?
Given the tool's simplicity and no output schema, the description is fairly complete. It covers the main action and supported types. Minor gap: could mention that it creates a new diagram or allows editing.
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% with descriptions for all three parameters. The description adds no additional context beyond the schema, so it meets the baseline but does not exceed it.
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?
The description clearly states the tool opens the draw.io editor with a diagram from Mermaid.js syntax, listing supported diagram types. This differentiates it from siblings like open_drawio_csv by specifying the input format.
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 description implies usage for Mermaid diagrams but does not explicitly state when to use this tool over alternatives or provide exclusion criteria. Listing supported types gives some guidance, but no contrast with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Opens the draw.io editor with a diagram from XML content. Use this to view, edit, or create diagrams in draw.io format. The XML should be valid draw.io/mxGraph XML format. IMPORTANT: Do NOT use double hyphens (--) inside XML comments, as this is invalid XML and will break the parser. Use single hyphens or rephrase instead.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | The draw.io XML content in mxGraphModel format. | |
| lightbox | No | Open in lightbox mode (read-only view). Default: false | |
| dark | No | Dark mode setting. Default: auto |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. It discloses that XML must be valid and warns about double hyphens. But it does not cover side effects, permissions, or behavior on invalid input beyond the comment issue.
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?
Description is brief: two sentences plus a warning note. It front-loads the purpose and adds critical usage detail concisely. No wasted words.
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?
Given the tool has 3 parameters, no output schema, and no annotations, the description covers the core action and a critical constraint. It lacks details on return behavior or editing specifics, but suffices for the complexity.
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. Description adds value by specifying the XML format requirement and the crucial hyphen rule for comments, going beyond schema descriptions.
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?
The description clearly states the verb 'Opens the draw.io editor' and specifies the resource as 'diagram from XML content'. It explicitly mentions the format (draw.io/mxGraph XML) which distinguishes it from sibling tools like open_drawio_csv or open_drawio_mermaid.
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 description says 'Use this to view, edit, or create diagrams', providing clear context. It also warns about the XML comment hyphen rule. However, it does not mention when to avoid this tool in favor of sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Reads and parses a .drawio or .xml diagram file, returning structured JSON with all shapes, edges, and their properties (labels, positions, styles, connections). Use this to analyze existing diagrams, extract component lists, or understand diagram structure before making modifications. Supports both uncompressed mxGraphModel XML and .drawio file format.
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes | Absolute path to the .drawio or .xml file to read | |
| include_style_details | No | Include parsed style properties for each shape/edge. Default: true | |
| include_geometry | No | Include position and size for each shape. Default: true |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses return format (structured JSON), supported formats (uncompressed mxGraphModel XML and .drawio), and implies read-only behavior. Could further emphasize no file modification, but is adequate.
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 concise sentences with front-loaded action verb 'Reads and parses'. No redundancy or filler. Every sentence adds value: purpose, return format, usage guidance, and format support.
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?
Given no output schema, description explains return format well. For a read-only tool with 3 parameters fully covered in schema, description is sufficiently complete. Could mention error behavior or file existence, but not critical.
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%, baseline 3. Description adds meaning beyond schema by clarifying that include_style_details provides parsed style properties and include_geometry includes position/size. Adds context to file_path (absolute path) and boolean meanings.
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?
Description clearly states it reads and parses .drawio/.xml files, returning structured JSON with shapes, edges, and properties. Distinguishes from siblings like create_* or export_drawio by focusing on reading/analysis.
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?
Explicitly states when to use: analyze existing diagrams, extract component lists, or understand structure before modifications. Does not explicitly mention when not to use or name alternatives, but context of sibling tools implies those are for creation or different formats.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.1.0create_emc_test_setupcreate_pcb_stackupcreate_rf_block_diagramexport_drawiomarkup_schematicopen_drawio_csvopen_drawio_engineeringopen_drawio_mermaidopen_drawio_xmlread_drawioMost tools have clearly distinct purposes, but some overlap exists between open_drawio_engineering and other open_drawio tools. The descriptions differentiate them, but confusion is possible.
All tool names follow a consistent verb_noun pattern (e.g., create_emc_test_setup, export_drawio, read_drawio), making them predictable and easy to understand.
10 tools is well-scoped for the server's purpose of engineering diagram creation and manipulation. Each tool serves a distinct role without being excessive.
The tool set covers creation from multiple formats, export, and reading. Minor gap: no tool for programmatic editing of existing diagrams beyond markup annotations.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Create and edit architecture diagrams from your AI agent; get an SVG and a live editable canvas.
AI agent draws editable hand-drawn diagrams (flowchart, ER, architecture) via MCP, not static images
Create diagrams in chat, rendered as live interactive draw.io diagrams. 10,000+ searchable shapes.
Create, read and live-edit visual boards, Kanban plans, Gantt timelines and diagrams with AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/RFingAdam/drawio-engineering-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
