Skip to main content
Glama
fusion-electronics-mcp

fusion-electronics-mcp

fusion-electronics-mcp

An MCP server that lets AI agents read, review and edit PCB designs in Autodesk Fusion Electronics: schematic capture, placement, impedance-controlled routing, pours and stitching, design checks, and JLCPCB manufacturing outputs.

Every change is verified by reading the design back from Fusion and is undone if the result does not match. Each tool call is one undo step in Fusion, and nothing is saved until you ask.

A dual CRPS power-supply backplane designed in Fusion through the MCP

A dual CRPS power-supply backplane built in Fusion through this server: schematic drawn as blocks from a netlist, passives placed by rule, routed with power pours kept whole, GND stitched, silkscreen and 3D models checked.

What it can do

  • Review: board and schematic summaries, parts, nets, DRC and ERC, a schematic review (unconnected power pins, boxes drawn as nets, stray wires, nets that need labels), a picture of the board (render_board), and annular rings of every via and through-hole pad (check_annular_ring), and solder mask openings that merge or leave too thin a dam (check_solder_mask).

  • Signal integrity: differential pairs, length matching, and impedance estimates (IPC-2141 closed form) against the design's real layer stackup; same-layer pour too close to 50 ohm and USB traces (check_pour_clearance).

  • Schematic capture: place parts, connect pins (labels added automatically), rename nets or single segments, add sheets with your frame. Draw a whole schematic from a KiCad board as reviewable blocks: each IC or connector with its passives wired to it, labels only where a net leaves the block, rails as power symbols, with a preview before anything is drawn.

  • Placement: move and rotate parts, import placement or netlists from a KiCad board, score placements and suggest moves, and place passives around the part they serve by rule (place_clusters: pull-ups and series parts on their pin's escape line, decaps first, bridges along the package edge, LED and FET chains following the part they hang off), previewed before moving. Check placement (courtyards, pad gaps, silkscreen, tidiness), move parts in batches as one undo step, line series parts up on their pads (place_inline) and tidy to a grid without touching critical parts.

  • Net classes and rules: list, create (as a rule file you load) and assign net classes; teardrop and pair rules; JLCPCB limits; DRC after every write reporting only new errors.

  • Length and current: length groups through series parts with cited typical tolerances, coupled detours for matching, trace widths from a net's current and the weakest part's rating.

  • Routing, in the order a person routes a board: pours (with priority ranks), a GND via beside every ground pad (ground_vias), all the short pin-to-pin hops at once (route_close), buses laid as ordered parallel lanes along a path you choose (lay_bus), then everything left with a router that rips up and reroutes when blocked (route_remaining). Routes are 45-degree, keep out of connector pin fields, avoid cutting power pours, and are smoothed; every write is checked (connections made, no layer change without a via). Also single connections or nets (route_trace, route_net), impedance- controlled differential pairs (route_pair), via stitching that keeps off parts and other nets' pours, copying a KiCad board's routing (import_routing_from_kicad), and Fusion's autorouter. Routing is still in development: these tools route boards and pours today, step by step with you reviewing each stage, but routing a whole board on its own, start to finish, is not there yet.

  • Parts and libraries: build parts from a JSON definition into a Fusion library (pads and pin connections verified), attach 3D models (refused if the body would sit upside down), update a design from its libraries (re-pulling parts Fusion's own update leaves on an old 3D model), push the board to its 3D PCB and check every part's model is on the right side.

  • Design rules and stackups: every JLCPCB impedance stackup (16 four-layer, 14 six-layer, built from JLC's published tables) plus a 2-layer 1.6 mm set, each as a .edru (rules and stackup) and a .estackup, to load in Fusion's DRC dialog or Layer Stack Manager (list_design_rules). Rules meet JLCPCB's published minimums, with a 0.3 mm minimum drill (smaller costs more at JLC; lower it in the file if you need to).

  • JLCPCB: BOM and CPL (pick and place) files; placement orientation checked against the footprint JLC places each part with (still check JLC's placement preview before ordering, see below); a check of your gerber zip against the design (every layer, the outline, every drilled hole, paste and mask on every SMD pad).

fusion-electronics-mcp tools lists all 106 tools.

Related MCP server: JLCEDA MCP Server

Requirements

  • Autodesk Fusion (desktop) with Electronics, on Windows or macOS

  • Python 3.12 or newer

  • An MCP client, for example Claude Code or Claude Desktop

Install

pip install "fusion-electronics-mcp[render] @ git+https://github.com/groundplane-studio/fusion-electronics-mcp"

The [render] extra adds matplotlib for render_board; leave it out if you do not need board pictures.

Connect it to Fusion

Install the bundled add-in and run it from Utilities > Add-Ins in Fusion (tick Run on Startup):

fusion-electronics-mcp install-addin

The add-in listens on 127.0.0.1 only, behind a per-session token.

Without the add-in, the server can fall back to Fusion's own MCP server (Preferences > General > API > Fusion MCP Server). That works for reading and most edits, but on current Fusion builds it does not save libraries, it stops answering after about a minute, and it cancels Fusion's dialogs, so saving and pushing to the 3D PCB need the add-in.

Add it to your MCP client

Claude Code:

claude mcp add fusion-electronics -- fusion-electronics-mcp

Claude Desktop (claude_desktop_config.json; use the full path to the command if it is not on your PATH):

{
  "mcpServers": {
    "fusion-electronics": { "command": "fusion-electronics-mcp" }
  }
}

Check the setup

With Fusion running:

fusion-electronics-mcp doctor

Libraries

Groundplane's libraries (optional)

groundplane-studio/fusion-libraries has the libraries we design with: passives with a variant per value and its JLCPCB part number, schematic frames and power symbols, and our active parts and connectors. Upload the .flbr files to a Fusion project (Data Panel > Upload) and add them to a design from the Library Manager. Then point the server's schematic tools at the frames and power symbols:

FUSION_MCP_SHEET_FRAME=FRAME_B_L@GPLIB_SCHEMATIC
FUSION_MCP_GROUND_SYMBOL=GND_EARTH@GPLIB_SCHEMATIC
FUSION_MCP_POWER_SYMBOL=12V@GPLIB_SCHEMATIC

Any library works: these settings only name the devices to use.

Your own parts library

For parts no library has, the server keeps part definitions (JSON files) in its component library folder and builds them into a Fusion library of yours:

  1. In Fusion, create an empty electronics library in your project (for example "MCP Library") and save it.

  2. Get the part's footprint as a KiCad .kicad_mod: from KiCad's libraries, or JLCPCB's own footprint and 3D model with easyeda2kicad (easyeda2kicad --full --lcsc_id=C2040; a separate program, AGPL-3.0). Fetch one part at a time with a pause between parts: EasyEDA refuses bursts (HTTP 403), so if it does, wait a while and try again.

  3. Ask your agent to create the part (create_library_part: footprint, name, value, JLCPCB number, pin names). Two-pin passives get the same symbols as the rest of your schematic; other parts get a box with named pins.

  4. Open your library in Fusion and have the agent run insert_library_part, save_design, then attach_3d_model with the part's STEP file. A model that would sit upside down is refused. To add the footprint to a device set you already have instead (another connector under your CONN_USBC_24P, say), run add_library_variant: it draws only the package and adds it as a new variant on the existing symbol, with the attributes you give each technology (dnp_technology adds a _DNP one with NC/ on the value). get_library_deviceset shows a device set's pins, variants and attributes first.

  5. Close the library (close_library) and place the part with add_part.

Footprints keep plated slots ((drill oval ...) becomes a Fusion slot pad) and unplated slots (milled on layer 46). >NAME / >VALUE are 0.8128 mm, vector, ratio 8 %, bottom-left, above the footprint's top-left corner. Fusion 2706.1.14 crashes in Create 3D Package, so attach_3d_model refuses on that build unless accept_crash_risk=true: save the library first.

Part definitions live in %LOCALAPPDATA%\fusion-electronics-mcp\library\parts on Windows (FUSION_MCP_LIBRARY to change), so you can keep them in git.

Using it

Open a design in Fusion, then ask your agent things like:

  • "Review the schematic and list anything that looks wrong."

  • "Check the impedance and length matching of the USB and Ethernet pairs."

  • "Route USB_DP/USB_DN as a 90 ohm pair from J2 to J4, matched to 0.1 mm."

  • "Add a GND pour on both inner layers and stitch it, keeping vias 0.6 mm from the pairs."

  • "Export the JLCPCB BOM and CPL, and check the gerber zip in my Downloads."

Gerbers: Fusion's CAM cannot be driven from outside, so export the gerber zip from Fusion's CAM Processor yourself; check_gerbers then checks it against the design before you upload it.

Before you order from JLCPCB

check_jlc_orientation compares each part's footprint with the one JLCPCB places it with and writes the rotation and offset corrections into the CPL. Parts it cannot match with confidence (pads that are named differently, polarity it cannot tell) are listed under needs_review rather than guessed. It is a check, not a guarantee: footprints JLCPCB has never published, or has changed, are not covered.

So before you pay for assembly, open JLCPCB's component placement preview on the order page and look at every part: pin 1 and polarity marks (diodes, LEDs, electrolytics, ICs, connectors) must line up with the board's markings, and every part must sit on its pads. Rotate any that do not right there, then put the same correction on the part in your library (JLC-ROTATION, JLC-X-OFFSET, JLC-Y-OFFSET) so the next order comes out right.

Safety and privacy

  • No telemetry. The server talks to Fusion on 127.0.0.1 only.

  • The add-in only does design edits. It listens on 127.0.0.1 only, answers only requests carrying the per-session token it writes to your user folder, and runs only Fusion design commands from a fixed list (no RUN, SCRIPT, SYSTEM, file or export commands), so an agent cannot use it to run programs. The one local file it reads is a STEP model you name for attach_3d_model, which it imports into your Fusion project.

  • One exception, on request: check_jlc_orientation with fetch=true downloads footprints from easyeda.com (cached forever, at least 15 s between requests). Nothing else leaves your machine. The service tools (request_design_review, get_assembly_quote) are stubs and make no network calls.

  • Fusion's questions get safe answers. Fusion asks things with pop-up dialogs; a watchdog answers the ones a tool expects and cancels the rest (Cancel / No, never Yes). Windows only so far: on macOS a dialog waits for you.

  • Your keyboard stays yours. If Fusion grabs focus while a tool runs, focus goes back to the window you were typing in (FUSION_MCP_KEEP_FOCUS=0 turns this off).

  • When you are in the middle of a command in Fusion, edits wait for you (Fusion refuses them) instead of cancelling your command.

Configuration

Variable

Default

Purpose

FUSION_MCP_TRANSPORT

auto

addin, builtin (Fusion's MCP server), or auto (the add-in when it is running, else the built-in server)

FUSION_MCP_BUILTIN_URL

http://127.0.0.1:27182/mcp

Fusion's MCP server address

FUSION_MCP_LIBRARY

per-user data folder

component library (part JSON files)

FUSION_MCP_SHEET_FRAME

none

frame for new schematic sheets, DEVICE@LIBRARY

FUSION_MCP_GROUND_SYMBOL

none

ground symbol for block schematics, DEVICE@LIBRARY

FUSION_MCP_POWER_SYMBOL

none

power symbol for block schematics (its value is set to each rail's name), DEVICE@LIBRARY

FUSION_MCP_KEEP_FOCUS

1

hand keyboard focus back when Fusion takes it

FUSION_MCP_LOCK_WAIT_S

30

how long a call waits while another Claude session is using Fusion (only one at a time)

FUSION_MCP_DRC_AFTER_WRITES

1

run DRC before and after every write and report the new errors (0 to turn off)

FUSION_MCP_UNDO_ON_NEW_DRC

0

1 also undoes a write that adds copper DRC errors

FUSION_MCP_EASYEDA_CACHE

per-user data folder

EasyEDA footprint cache

FUSION_MCP_EASYEDA_INTERVAL_S

15

minimum seconds between EasyEDA requests

The per-user data folder is %LOCALAPPDATA%\fusion-electronics-mcp on Windows and ~/Library/Application Support/fusion-electronics-mcp on macOS.

Known limits

  • Routing is still in development. Boards and pours can be routed with the tools above, one stage at a time, but fully automatic routing of a whole board is still being worked on: expect to guide it and review each stage.

  • Gerbers are exported from Fusion's CAM dialog by hand (checked by the tool).

  • Impedance figures are closed-form estimates, typically within about 10%; confirm critical pairs with your fab's calculator.

  • The dialog watchdog and focus guard are Windows-only so far.

  • Built and tested against Fusion 2705.1.15. Fusion's undocumented command interface can change between releases; docs/architecture.md lists the behaviours the tools depend on.

Development

git clone https://github.com/groundplane-studio/fusion-electronics-mcp
cd fusion-electronics-mcp
pip install -e ".[render]"
python -m unittest discover -s tests

docs/architecture.md explains how the server, Fusion and the add-in fit together. tests/live/ holds scripts that drive a running Fusion.

About

Made by Ground Plane Studio, a hardware development team: industrial design, electronics, firmware and manufacturing, from concept to production. Want a board designed, reviewed or brought to production? Get in touch.

Disclosure

  • Not affiliated with Autodesk. Autodesk, Fusion and EAGLE are trademarks of Autodesk, Inc. This is an independent project, not made, endorsed or supported by Autodesk. The same goes for JLCPCB and EasyEDA.

  • Built with AI. Most of the code was written with Claude Code, directed, reviewed and tested on real boards by the engineers at Ground Plane Studio. The tools that edit a design check the result and undo the change when it does not match, and there is a large automated test suite, but treat it like any tool you did not write yourself.

  • No warranty. It is provided as is (see LICENSE). An agent can get a design wrong. Check every board yourself (DRC, ERC, your fab's previews) before you order, keep your designs versioned, and remember that what you send to fabrication is your call.

License

MIT. See LICENSE.

Available Tools

77 tools
add_holeB

Add a non-plated hole on the board (e.g. a mounting hole).

Inputs: x_mm (required), y_mm (required), drill_mm (required).

add_keepoutA

Circular keepout (e.g. around a mounting hole): no copper on 'top' / 'bottom' and no 'vias' inside it. Pours and the autorouter respect it. Uses EAGLE restrict layers 41/42/43.

Inputs: x_mm (required), y_mm (required), radius_mm (required), layers.

add_partB

Place a device (device set + variant name, e.g. 'RES_0603_10K_1%_1/10W') from a Fusion library into the schematic. The part is forward-annotated onto the board. sheet may be an existing sheet or the next new one (sheets + 1).

Inputs: ref (required), x_mm (required), y_mm (required), device (required), +3 more.

add_pourA

Add a copper pour (polygon) on a net, e.g. a GND plane. Without points it follows the board outline (inset_mm = 0): the copper-to-edge distance then comes from the design rule for board edge clearance, as EAGLE intends. Note the outline wire is width_mm wide and centred on the vertices, so an inset moves copper only inset - width/2 from the edge. isolate_mm is the clearance to other copper. thermal_width_mm is the width of the thermal-relief spokes joining pads to the pour (Fusion's default is a thin 0.1524 mm; the gap comes from the design rule slThermalIsolate). rank sets priority where pours of different nets overlap on a layer: rank 1 wins and is cut out of higher ranks (e.g. output islands rank 1 inside a rank 3 GND plane). Respects keepouts (add_keepout); filled immediately.

Inputs: net (required), rank, layer, inset_mm, +4 more.

add_textA

Add board text, e.g. silkscreen pin labels. layer: top_silk, bottom_silk, top_doc, bottom_doc or a layer number. Vector font; size_mm is the character height and ratio_pct the stroke as % of it (JLC needs >= 1.0 mm text and >= 0.153 mm strokes: the defaults). Bottom layers are mirrored so they read correctly from the bottom. align: center, bottom-left, ... Keep text off pads: fabs clip silk over exposed copper.

Inputs: text (required), x_mm (required), y_mm (required), align, +4 more.

add_traceC

Route a trace through the given points [[x, y], ...] (mm). layer: 'top', 'bottom', 'inner1'.. or a layer number.

Inputs: net (required), layer (required), width_mm (required), points_mm (required).

add_viaC

Add a through via on a net at (x, y) mm. The pad diameter follows the design's restring rules.

Inputs: net (required), x_mm (required), y_mm (required), drill_mm.

attach_3d_modelA

Give a package in the OPEN library a 3D model from a STEP file. The model is placed in the footprint's frame (KiCad library models need no offset; pass offset_mm [x, y, z] and rotation_deg [rx, ry, rz] when a model's origin differs), saved as a 3D package document in the project's folder, and linked to the package. Checks that the model sits over the pads.

The model must stand on the board: more of it above the board than below (pins may go through), else nothing is saved and the call fails (allow_below_board=true for a part that really hangs below, e.g. a through-board connector): fix rotation_deg (KiCad's 3D rotation signs are the opposite of Fusion's; vendor STEPs are often Y-up and need +90 about X). If the package already has a 3D model, the new model's file gets a versioned name (_V2, ...) so the files in folder stay distinguishable. Boards that already use the package keep their old model until refreshed: save the library (save_design), then on each board run update_from_libraries(refresh_parts=[one part per device]) and push_3d.

Inputs: package (required), step_path (required), name, folder, +3 more.

autorouteA

Route unrouted connections with an autorouter, keeping existing traces (route critical nets, power and pours first). engine='fusion' runs Fusion's own autorouter and applies its best variant (most complete, then fewest vias). Without nets, routes everything left. route_past_planes: when a copper layer holding a pour (an inner GND plane) is not enabled for routing, Fusion asks whether to run anyway; true answers Yes (signals stay off the plane and the pour refills around new vias), false stops. top_router: Fusion's TopRouter variant can hang at the share already routed and block the job; off by default for the job (the design's autorouter settings are restored afterwards). Returns routing metrics before and after.

Inputs: nets, engine, timeout_s, top_router, +1 more.

check_3d_modelsA
Read-onlyIdempotent

Check the open 3D PCB: every part's height range against the board's, listing parts whose model sits on the wrong side (a top-side part hanging below the board, or the reverse).

Inputs: no named parameters.

check_gerbersA
Read-onlyIdempotent

Check a CAM output (zip or folder of gerbers + Excellon drills) against the open design: complete layer set (copper count = stackup, mask, silk incl. bottom when the board has bottom text, paste where there are SMD pads, outline, drill), outline size, every drilled hole of the design (pads, vias, holes) present with the right diameter and position and nothing extra, and pad flash counts per layer. Run it on the zip before uploading to the fab.

Inputs: path (required).

check_impedanceA
Read-onlyIdempotent

Estimate every differential pair's impedance on its routed layer using the real stackup, and compare with the target. Also flags pairs whose P-N gap is tighter than their net class's copper clearance rule (a common cause of mass DRC errors). Estimates are IPC-2141 closed form, typically within ~10% of a field solver; use a solver or the fab's calculator for sign-off.

Inputs: stackup_file, tolerance_pct, target_diff_ohm.

check_jlc_orientationA
Read-onlyIdempotent

Compare each placed part's footprint with the one JLC places it with (EasyEDA's, by the part's JLCPCB code) and derive the CPL rotation/offset that lines them up: pads matched by name (geometry when names differ, flagged ambiguous so a person confirms polarity). fetch=true downloads missing footprints from easyeda.com (the only internet access this server makes: cached forever, >= 15 s between requests); otherwise only the local cache is used. Pads are matched by pin FUNCTION (K/A, FB/EN...) when both footprints name their pins, so a part whose libraries number pads differently is not turned around.

Inputs: refs, fetch.

check_length_matchB
Read-onlyIdempotent

Compare routed lengths of a group of nets (e.g. a bus or lanes) against the longest.

Inputs: nets (required), tolerance_mm (required).

clean_viasA
DestructiveIdempotent

Delete a net's vias that now violate clearance to a pad (any net) or to another net's copper, e.g. stitching vias left under a part that moved. Run stitch_vias again afterwards to refill.

Inputs: net.

close_designA
DestructiveIdempotent

Close a design. Refuses if it has unsaved changes unless discard_changes is true.

Inputs: name (required), discard_changes.

close_libraryB
DestructiveIdempotent

Close an open (saved) library document so its parts can be placed.

Inputs: name (required).

connect_pinsA

Connect schematic pins into a named net. Pins are PART.PIN or PART.PAD. Each pin gets a short named wire stub with a net label (labels=false to omit), so no wire crosses other parts and every piece of the net is visibly named. Refuses to join two existing nets unless allow_merge is true.

Inputs: net (required), pins (required), labels, allow_merge.

create_library_partA

Create a part in this server's component library from a KiCad footprint (.kicad_mod): from KiCad's own libraries, or JLCPCB's footprint for a part exported with easyeda2kicad --full --lcsc_id=C... (set jlc_native=true for those: no rotation correction needed at JLC). The symbol is generated: two-pin passives get the standard symbols (resistor, capacitor, diode, LED, ...), anything else a box with its pins (pin_names maps pad -> pin name, pads sharing a name join one pin; directions maps pin name -> in/out/io/pwr/pas/oc). jlc_code (C-number) fills JLCPCB, and MF/MP from cached EasyEDA data when not given. Then open your Fusion library and run insert_library_part, save_design, attach_3d_model (with the part's STEP file).

Inputs: value (required), prefix (required), part_id (required), deviceset (required), +9 more.

estimate_impedanceA
Read-onlyIdempotent

Closed-form (IPC-2141) impedance estimate for a hypothetical trace. geometry: microstrip (dielectric_mm = height to the reference plane) or stripline (plane-to-plane). get_layer_stack gives the real thicknesses and Er; check_impedance does this for every routed pair.

Inputs: er (required), width_mm (required), dielectric_mm (required), gap_mm, +2 more.

export_bomB
Read-onlyIdempotent

JLCPCB-format BOM CSV (plus the excluded-parts CSV), generated from the open board.

Inputs: no named parameters.

export_cplA
Read-onlyIdempotent

JLCPCB-format pick-and-place (CPL) CSV. JLC places each part with its own (EasyEDA) footprint, whose zero orientation and origin can differ from ours (KiCad-sourced connectors and ICs typically). With jlc_orientation, parts whose footprint data is in the local EasyEDA cache get the derived rotation/offset applied (library JLC-ROTATION / JLC-X-OFFSET / JLC-Y-OFFSET attributes still win); ambiguous derivations are listed for review instead. Never uses the network: fill the cache with check_jlc_orientation(fetch=true).

Inputs: jlc_orientation.

fanout_padA

Fanout via for one pad: a short trace from the pad to the nearest valid via spot (clear of other nets, every pad, holes, keepouts and the edge; never via-in-pad). Typical uses: connect a GND pad that routing cut off from its pour, or power-pin fanout before autorouting.

Inputs: pad (required), ref (required), layer, max_dist_mm, +1 more.

get_assembly_quoteB
Read-onlyIdempotent

Get a PCB assembly quote (not connected yet: makes no network calls).

Inputs: quantity.

get_board_summaryB
Read-onlyIdempotent

Board size, copper layers, part and net counts, net classes and design-rule highlights.

Inputs: no named parameters.

get_contextB
Read-onlyIdempotent

Which Electronics documents are open in Fusion and which editor is active.

Inputs: no named parameters.

get_design_rulesA
Read-onlyIdempotent

Key design rules of the open board (clearances, minimum width and drill, edge clearance, via restring), read from Fusion's own V2 rules. Warns when they are still Fusion's new-design defaults, which are too loose/tight for most fabs (e.g. 40 mil edge clearance).

Inputs: no named parameters.

get_layer_stackA
Read-onlyIdempotent

The layer stackup: copper and dielectric thicknesses, dielectric constants (Er) and materials. Read from the open design's Fusion design rules, or from stackup_file (.estackup or .edru).

Inputs: stackup_file.

get_library_partB
Read-onlyIdempotent

Full definition of one library part, including metadata (source, maintainer, link).

Inputs: part_id (required).

get_netB
Read-onlyIdempotent

One net: its schematic pins (with direction) and its board routing by layer.

Inputs: name (required).

get_partB
Read-onlyIdempotent

Everything about one part: board placement, schematic device, attributes, and each pin's net.

Inputs: ref (required).

ground_viasB

A via next to every SMD pad on a plane net (GND by default): a short trace from the pad to the nearest clear via spot (never via-in-pad), tying the pad to the plane on the other layer. Planned one pad at a time so the vias keep clear of each other; all written as one undo step. skip: pads to leave out ('U1.4'). Through-hole pads are skipped (they reach both layers).

Inputs: net, skip, dry_run, max_dist_mm, +1 more.

import_netlist_from_kicadA

Build the schematic of a KiCad board in this design. part_map maps a KiCad refdes OR footprint name to 'DEVICE@LIBRARY' (device = device set + variant), e.g. {"R1": "RES_0402_1K_1%@MY_PASSIVES", "RJ45-TH_RJSAE538402": "CONN_RJ45_2X1_HC-RJ45-059A@MCP Library"}. Mounting holes (no pads) are skipped; add them on the board with add_hole.

style="blocks" (default) draws a reviewable schematic: each IC/connector with its passives wired to it (series parts inline, caps and pull-ups hanging off the net, LED/FET drivers stacked), labels only on nets that leave a block, ground and rails as power symbols, blocks packed onto framed sheets. It needs ground_symbol and power_symbol ('DEVICE@LIBRARY'; a power symbol whose net name follows its value, e.g. GPLIB's bars) or FUSION_MCP_GROUND_SYMBOL / FUSION_MCP_POWER_SYMBOL, and frame or FUSION_MCP_SHEET_FRAME for new sheets. pad_map translates KiCad pad names to library pad names where they differ, by refdes or footprint ({"D_SMB": {"1": "C", "2": "A"}}; one-pad parts map themselves). preview_only=true lays it out and writes an HTML preview without drawing it (parts are added once to read their symbols, then removed). Every pin is checked afterwards. style="grid" places parts in rows with a labelled stub on every pin (the old behaviour). dry_run=true reports the plan without changing anything.

Inputs: part_map (required), pcb_path (required), skip, frame, +7 more.

import_placement_from_kicadA
DestructiveIdempotent

Place this board's parts where a KiCad board (.kicad_pcb) has them: position, rotation and side, matched by reference designator. KiCad's frame is converted (origin at the board's bottom-left, y up; bottom parts at angle R become mirrored 180 - R). All moves run in one verified command (one undo step) in Ignore Violators mode, so parts may sit over each other on opposite sides. dry_run=true only reports the moves. Routing is not imported.

fit_pads (default): each part is placed so its pads land on the KiCad board's pads (matched by pad name, least squares), not by footprint origin and angle: a Fusion footprint whose origin or pin-1 orientation differs (JLC's SOT-23-6 is turned 180 degrees from KiCad's, a header's origin is pin 1 in one and the centre in the other) still lands right. Parts whose pads sit more than 0.1 mm from KiCad's after the fit are listed under footprint_differs.

Inputs: pcb_path (required), skip, dry_run, fit_pads.

import_routing_from_kicadA

Copy a KiCad board's tracks, arcs and vias into this board (same frame as import_placement_from_kicad: origin at the board's bottom-left, y up), as one undo step. Run import_placement_from_kicad first so pads line up. nets limits it to those nets; vias=false skips vias. Every segment is checked against the board read back from Fusion. Pours are not copied (use add_pour). Import BEFORE adding pours: with pours on the board Fusion refills them after every via, and 490 vias kept it busy for over 40 minutes (2705.1.15). dry_run=true only counts what would be drawn.

Inputs: pcb_path (required), nets, vias, dry_run.

insert_library_partA

Build a library part into the Fusion library open in the library editor. Afterwards call save_design, then close_library, before placing it with add_part (placing from a library that is still open can crash Fusion).

Two-pin passives (resistors, capacitors, inductors, ferrites, fuses, crystals, diodes, LEDs, TVS) are drawn with this server's standard symbols, not the symbol the part came with from EasyEDA or KiCad, so every schematic reads the same; set "style": false in the part to keep its own symbol, or name a style ("res", "cap", "cap_pol", "inductor", "ferrite", "fuse", "crystal", "diode", "schottky", "zener", "led", "tvs", "tvs_bidir").

Inputs: part_id (required).

label_netsC

Add a net label to every piece of a net that is drawn separately from the rest without a label (the convention: same net, not visibly connected, must be named). Limit with nets.

Inputs: nets.

lay_busA

Lay a bus: one lane per net, side by side along a path you choose ([[x, y], ...], 45-degree corners), lane 0 on the path and lane i offset i * pitch to the LEFT of travel, each lane trimmed to the stretch its own pins span. Order nets so the taps at the ends cross as little as possible. Then join each pin to its lane with route_net (taps; vias where a tap must cross other lanes). Checked against other nets' copper, holes, keepouts and the lanes' own pitch; nothing is written if a lane conflicts. dry_run=true (default) returns the plan and a picture.

Inputs: nets (required), path_mm (required), layer, dry_run, +2 more.

list_design_rulesB
Read-onlyIdempotent

Design-rule (.edru) and stackup (.estackup) files shipped with this server for common fab processes (every JLCPCB 4- and 6-layer impedance stackup, and a 2-layer 1.6 mm board; built from JLC's published tables by tools/gen_jlc_stackups.py): copper layers, board thickness, dielectrics (thickness, Er) and the key clearances of each. Fusion cannot load rules from a script: load a .edru in the DRC dialog (Rules > Load; it carries its stackup too) or a .estackup in the Layer Stack Manager. copy_to copies the files into a folder you can reach from Fusion's file dialog (e.g. Downloads).

Inputs: copy_to.

list_designsA
Read-onlyIdempotent

Electronics designs and libraries in the active Fusion project's top folder, or in one folder path ('Live tests', 'Parts/Connectors'); folders are not searched recursively (walking a big project's folder tree froze Fusion).

Inputs: folder.

list_diff_pairsB
Read-onlyIdempotent

Differential pairs (by _P/_N style names) with per-side length, skew, width, gap and vias. The skew limit defaults to the design's dpMaxLengthDifference rule.

Inputs: max_skew_mm. Returns: result

list_netsB
Read-onlyIdempotent

Nets (merged across schematic sheets) with pin counts and routed length on the board.

Inputs: limit, filter. Returns: result

list_partsB
Read-onlyIdempotent

Parts on the board with placement and JLC attributes. filter matches refdes, value or package.

Inputs: limit, filter. Returns: result

list_poursA
Read-onlyIdempotent

Copper pours with their live settings: net, layer, thermal relief width, isolate, rank.

Inputs: no named parameters.

move_partA
DestructiveIdempotent

Move a board part so its origin is at (x, y) mm.

Inputs: ref (required), x_mm (required), y_mm (required).

new_designA

Create a new electronics design with a schematic and a board. With name, it is saved right away into the active project (optionally inside folder, created if missing).

Inputs: name, folder.

new_sheetA

Add a schematic sheet with your standard frame and set its headline (sheet description). frame is 'DEVICE@LIBRARY'; default from FUSION_MCP_SHEET_FRAME, or none. Fusion does not add a frame to new sheets by itself. Pass sheet to set up an EXISTING sheet instead (e.g. sheet 1 of a new design). Returns the sheet number and the frame's drawing area.

Inputs: frame, sheet, title.

open_designB

Open a design (schematic + board) from the active project and make it current.

Inputs: name (required), folder.

open_libraryC

Open a Fusion library (.flbr) from the active project in the library editor.

Inputs: name (required), folder.

place_clustersA
DestructiveIdempotent

Place passives around the part they serve, by rule (the user's patterns: pin -> part -> rail and series parts along the pin's escape, tees too, decaps standing across the column first, bridges along the package edge, chains such as LED + resistor following the part they hang off; connector pins at a board edge escape into the board). Main parts (ICs, connectors) and fixed never move; keep lists members to leave where they are (hand-made power stages, deliberate rows). dry_run=true (default) returns the moves and a before/after picture; then run with dry_run=false to move them (one undo step). Traces on moved parts' nets are not moved: rip them up first (not pour nets) and re-route with route_close.

Inputs: keep, fixed, dry_run.

push_3dA
DestructiveIdempotent

Bring the board's changes into its 3D PCB (creating the 3D PCB the first time, answering Fusion's Push dialog), then check every part's model is on its own side of the board: a top-side part mostly below the board (a model with the wrong up axis) is listed under wrong_side. The first push needs the add-in transport (the built-in server ends a script by cancelling any command still open).

Inputs: no named parameters.

remove_stubsA
DestructiveIdempotent

Fix trace stubs. A stub whose loose end lies on a same-net pad (Fusion re-anchors trace ends off-centre when a part rotates) is SNAPPED to the pad centre; a truly dangling end is cut back to the last place something joins the segment (a tap, a via), or the segment is deleted when nothing joins it before its other end. Fusion's DRC does not report every stub (a bus lane's tail past its last tap passes it), so with geometric=true (default) the board's copper is also checked directly. Every change is verified, and the run stops if the number of unrouted connections goes up, so a real connection is never removed.

Inputs: geometric, max_rounds.

rename_netA
DestructiveIdempotent

Rename a schematic net (all sheets where it has wires). Renaming onto a name that already exists merges the two nets, which is refused unless allow_merge is true. only_segment_with_pin: 'REF.PIN' renames just the wire segment on that pin (e.g. a labelled stub), moving that pin to new_name and leaving the rest of the net as it is; how to swap two pins' nets: rename one stub to a temporary name, the other stub across, then the temporary one.

Inputs: new_name (required), old_name (required), allow_merge, only_segment_with_pin.

render_boardA
Read-onlyIdempotent

Picture of the board as Fusion has it now (from a fresh export): outline, pads, holes, keepouts, part names, traces (top red solid, bottom blue dashed), vias, pour outlines. highlight_nets: regex of nets to colour and label at their pads. region_mm: [x0, y0, x1, y1] to zoom. plan: a route_pair plan (from dry_run) drawn on top before writing it. Returns the PNG and where it was saved. Needs matplotlib (optional install).

Inputs: plan, traces, out_path, region_mm, +1 more.

request_design_reviewB
Read-onlyIdempotent

Request a human design review from Groundplane (not connected yet: makes no network calls).

Inputs: notes.

review_schematicB
Read-onlyIdempotent

Schematic review: offline rules (unconnected power pins, single-pin nets, output conflicts, undriven nets, missing JLC codes, empty values) plus Fusion's ERC.

Inputs: include_erc.

rip_upA
DestructiveIdempotent

Remove routed traces and vias (they become unrouted connections again). Polygons/pours are kept, BUT a ripped-up net's pours stay unfilled afterwards (RATSNEST does not refill them on 2705.1.15): avoid ripping up nets that have pours, or re-add their pours after.

Inputs: nets.

rotate_partB
DestructiveIdempotent

Set a board part's absolute rotation (degrees) and side (bottom=true places it on the bottom).

Inputs: ref (required), angle (required), bottom.

route_closeB

Route every short connection at once: each airwire up to max_len_mm (local hops: passives to their pins, LED + resistor, bootstrap caps), shortest first, with route_trace's router and no vias by default. widths: {net regex: mm} for power nets (e.g. {"^3V3|^12V|^SW$": 0.5}). Planned one after another on a working copy (each sees the ones before), written as one undo step and checked. Connections it cannot make cleanly are listed and left for later.

Inputs: widths, dry_run, width_mm, allow_vias, +1 more.

route_netB

Route a whole net with route_trace's router, one airwire at a time, shortest first: each connection starts at a pad still unconnected and ends on the nearer of its partner pad or any copper the net already has (a tap), so the net grows as a tidy tree. Each step is written and checked before the next is planned; stops when the net has no airwires (pours count as copper). dry_run=true (default) plans only the first connection and returns its picture.

Inputs: net (required), layer, dry_run, width_mm, +3 more.

route_pairA

Route a differential pair as two coupled traces along a centreline you choose.

centreline_mm: [[x, y], ...] for the middle of the pair, from near the start pads to near the end pads; use 45-degree bends. Each trace is the centreline offset by (width + gap) / 2 with mitred corners, so the gap holds through bends, plus a short 45-degree fan-in to its pad. Which side is P is set by the start pads. If the end pads are the other way round the result says crossed=true: either approach the end pads from the other direction (no via), or pass a tail for one trace, [[x, y], {"via": [x, y]}, [x, y]], which changes layer at the via. p_head_mm / n_head_mm: explicit path from a trace's start pad to the trunk, for pins the automatic 45-degree fan-in cannot reach cleanly (e.g. through a gap in a pin row). Every 90-degree corner (typically where a trace leaves a pin) becomes two 45-degree bends, chamfer_mm along each leg (0 keeps hard corners). The shorter trace gets rounded bumps until the skew is within max_skew_mm. Nothing is written if the plan has conflicts (copper of other nets, holes, keepouts, the partner trace) or dry_run=true; the plan is returned either way.

Inputs: n_net (required), p_net (required), gap_mm (required), width_mm (required), +12 more.

route_remainingA

The free-router step (after pours, GND vias, close hops, fan-outs and bus lanes): route every connection still unrouted, shortest first, with rip-up and reroute when one is blocked (only traces laid in this run are ever ripped; existing routing stays). Routes are 45-degree, keep clear of connector pin fields, and cost extra to run through other nets' power pours (a via is usually cheaper). widths: {net regex: mm} for power nets. Nets with pours are left to their pours unless include_pour_nets. dry_run=true (default) plans offline and returns a picture; dry_run=false writes it all as one undo step, checked (airwires drop, no layer change without a via).

Inputs: nets, widths, dry_run, width_mm, +2 more.

route_traceA

Route one connection between two pads (PART.PAD, e.g. 'J1.A19' to 'J9.5') the way a person would: straight runs, 45-degree corners (no 90s), around other nets' copper with the design's clearance (or clearance_mm), keepouts and the board edge, ending exactly on the pad centres. layer: 'top' / 'bottom' to prefer one layer, 'any' to let it choose; vias only where needed (allow_vias=false forbids them). dry_run=true (default) returns the plan and a picture without writing; run again with dry_run=false to draw it (checked against the board afterwards).

Inputs: to_pad (required), from_pad (required), layer, dry_run, +6 more.

routing_statusB
Read-onlyIdempotent

Unrouted connections, unrouted nets, segment and via counts, routed length.

Inputs: no named parameters.

run_drcB
Read-onlyIdempotent

Run Fusion's DRC on the board and return the violations.

Inputs: no named parameters.

run_ercA
Read-onlyIdempotent

Run Fusion's ERC on the schematic and return the findings.

Inputs: no named parameters.

save_designB
DestructiveIdempotent

Save the active document as a new version in Fusion's cloud.

Inputs: description.

score_placementA
Read-onlyIdempotent

Placement quality without routing: ratsnest length (MST per net over pad centres), number of crossing air wires between nets, and the worst nets. Lower is better. Pour nets (GND) are excluded by default. Use it before and after placement changes.

Inputs: exclude_nets, crossing_weight_mm.

search_libraryC
Read-onlyIdempotent

Search this server's component library (library/parts).

Inputs: query (required). Returns: result

set_board_outlineA
DestructiveIdempotent

Draw a rectangular board outline (Dimension layer 20). New Fusion designs come with a default outline; pass replace=true to remove the existing outline first.

Inputs: width_mm (required), height_mm (required), x0_mm, y0_mm, +1 more.

set_part_valueA
DestructiveIdempotent

Set a part's value. Only for device sets with user-definable values; for fixed-value library parts (e.g. passives with one variant per value) use set_part_variant instead.

Inputs: ref (required), value (required).

set_part_variantB
DestructiveIdempotent

Switch a part to another device variant of its device set (how variant-based passive libraries change value; the variant's JLC code and attributes follow). Example variant: '_680R_1%_1/10W'.

Inputs: ref (required), device_variant (required).

set_pour_thermalsA
DestructiveIdempotent

Set the thermal-relief spoke width of a net's existing pours (all its pours, or one layer). Each pour is picked on its outline with the other copper layers hidden, then the view is restored.

Inputs: net (required), width_mm (required), layer.

stitch_viasA

Via stitching for a net's pours: vias on a grid wherever they clear other nets' copper, every pad (no via-in-pad), holes, keepouts and the board edge, using the design's clearance and drill rules. keep_away_mm: {net regex: mm} keeps vias further from some nets' copper, e.g. {"^ETH|^USB_D": 0.6} to keep ground as far from impedance pairs as their pours are. under_parts: refdes regex of parts vias may go under, e.g. "J[0-9]+" for big through-hole connectors: under the body (an overhang to the board edge) but not in the pin field (the pads' box + 2 mm); other parts stay via-free. One call places them all (one undo step). dry_run=true only plans.

Inputs: net, dry_run, drill_mm, max_vias, +3 more.

suggest_placement_movesA
Read-onlyIdempotent

Ranked single-part moves that lower the placement score (shorter ratsnest, fewer crossings), searched within radius_mm of each part, inside the board and clear of same-side parts. fixed lists parts that must not move (connectors, mechanical parts). Nothing is changed: apply the ones that make sense with move_part, then score again.

Inputs: top, fixed, radius_mm, exclude_nets.

undoA
DestructiveIdempotent

Undo the last change in the board or schematic editor.

Inputs: editor.

update_from_librariesA
DestructiveIdempotent

Update the open design from all its libraries (Fusion's 'Update all'): brings in library changes such as attributes (e.g. JLC-ROTATION / JLC-X-OFFSET / JLC-Y-OFFSET) and 3D packages. Save the library and close it first.

'Update all' can leave parts on an old 3D model and report nothing to do (seen when a package's model was replaced). refresh_parts (reference designators, one per device is enough, e.g. ["J3", "J9"]) re-pulls those parts' devices from their library with REPLACE, accepting Fusion's "a different version of device set ... update?" question (every part of that device follows). Returns the attribute changes and every part's 3D model afterwards, listing parts with none.

Inputs: refresh_parts.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 77 tools

    Disambiguation4/5

    The tool set has several overlapping families—routing (route_trace/route_net/route_close/route_remaining/autoroute), via placement (add_via/stitch_vias/fanout_pad/ground_vias/clean_vias), and schematic checks (run_erc/review_schematic)—so an agent must rely on detailed descriptions to choose correctly. Most tools target distinct resources/actions, but the boundaries between workflow steps are not always self-evident.

    Naming Consistency5/5

    All tool names use snake_case and follow a predictable verb_noun or verb_phrase pattern (list_parts, get_net, add_via, route_trace). Minor single-word names (undo, autoroute) and noun phrases (routing_status) are consistent with the overall convention, with no mixed casing or verb styles.

    Tool Count1/5

    77 tools is far beyond the typical 3–15 range and matches the rubric’s 50+ extreme-mismatch anchor. Although the domain is broad, many tools are granular variants (multiple routers, multiple via placers, three KiCad importers) that could be consolidated with mode parameters, increasing selection cost for an agent.

    Completeness4/5

    The surface covers design creation, schematic capture, board layout, routing, pours, DRC/ERC, fabrication exports, library management, 3D, and KiCad import—very comprehensive. However, targeted deletion tools are missing for parts, nets, pours, keepouts, holes, and text, and there is no create-library operation; undo offers rollback but not direct removal.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI agents to interact with 嘉立创 EDA for PCB design tasks including project management, component libraries, rule checking, and manufacturing constraints.
      -
    • A
      license
      C
      quality
      D
      maintenance
      Enables LLMs to inspect, edit, analyze, and render PCB layouts in real-time using the KiCad IPC API, providing tools for board configuration, footprints, tracks, zones, nets, text, shapes, dimensions, exports, screenshots, and CLI automation.
      100
      1
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to read and modify KiCAD PCB designs through the KiCAD IPC API, providing tools for board queries, footprint placement, track creation, DRC, and export.
      14
      MIT