fusion-electronics-mcp
An MCP server for reading, reviewing, and editing Autodesk Fusion Electronics PCB designs, with checked writes and undo support.
Inspect open designs/libraries and get board, schematic, parts, nets, stackup, and design-rule context.
Review designs with DRC, ERC, schematic checks, routing status, and placement scoring.
Edit schematics: add parts, connect pins, rename/label nets, set variants/values, add sheets, and import KiCad netlists.
Place parts: move/rotate, get placement suggestions, place passives by cluster, and import KiCad placement.
Route boards: single traces/nets, differential pairs, short connections, bus lanes, remaining routes, and autorouting.
Add/modify copper features: pours, vias, stitching, fanouts, keepouts, outlines, text, holes, and clean up stubs/vias.
Check signal integrity: differential pairs, length matching, and IPC-2141 impedance estimates.
Manage libraries: search/create/insert parts, attach 3D models, update designs from libraries, and close libraries.
Produce JLCPCB outputs: BOM/CPL, gerber checks, orientation checks, and design-rule/stackup files.
Push to 3D PCB and check 3D models; save designs or undo edits.
Allows AI agents to read, review, and edit PCB designs in Autodesk Fusion Electronics, covering schematic capture, placement, routing, pours, stitching, design checks, and manufacturing outputs.
Provides tools for importing placement, netlists, and routing from KiCad boards, and for using KiCad footprints (.kicad_mod) when creating custom library parts.
Click on "Deploy 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., "@fusion-electronics-mcp run DRC and ERC on my board and show me a render"
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.
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 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-addinThe 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-mcpClaude 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 doctorLibraries
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_SCHEMATICAny 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:
In Fusion, create an empty electronics library in your project (for example "MCP Library") and save it.
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.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.Open your library in Fusion and have the agent run
insert_library_part,save_design, thenattach_3d_modelwith 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 yourCONN_USBC_24P, say), runadd_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_technologyadds a_DNPone withNC/on the value).get_library_devicesetshows a device set's pins, variants and attributes first.Close the library (
close_library) and place the part withadd_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 forattach_3d_model, which it imports into your Fusion project.One exception, on request:
check_jlc_orientationwithfetch=truedownloads 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=0turns 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's MCP server address |
| per-user data folder | component library (part JSON files) |
| none | frame for new schematic sheets, |
| none | ground symbol for block schematics, |
| none | power symbol for block schematics (its value is set to each rail's name), |
|
| hand keyboard focus back when Fusion takes it |
|
| how long a call waits while another Claude session is using Fusion (only one at a time) |
|
| run DRC before and after every write and report the new errors ( |
|
|
|
| per-user data folder | EasyEDA footprint cache |
|
| 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.mdlists 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 testsdocs/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 toolsadd_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_modelsARead-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_gerbersARead-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_impedanceARead-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_orientationARead-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_matchBRead-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_viasADestructiveIdempotent
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_designADestructiveIdempotent
Close a design. Refuses if it has unsaved changes unless discard_changes is true.
Inputs: name (required), discard_changes.
close_libraryBDestructiveIdempotent
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_impedanceARead-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_bomBRead-onlyIdempotent
JLCPCB-format BOM CSV (plus the excluded-parts CSV), generated from the open board.
Inputs: no named parameters.
export_cplARead-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_quoteBRead-onlyIdempotent
Get a PCB assembly quote (not connected yet: makes no network calls).
Inputs: quantity.
get_board_summaryBRead-onlyIdempotent
Board size, copper layers, part and net counts, net classes and design-rule highlights.
Inputs: no named parameters.
get_contextBRead-onlyIdempotent
Which Electronics documents are open in Fusion and which editor is active.
Inputs: no named parameters.
get_design_rulesARead-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_stackARead-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_partBRead-onlyIdempotent
Full definition of one library part, including metadata (source, maintainer, link).
Inputs: part_id (required).
get_netBRead-onlyIdempotent
One net: its schematic pins (with direction) and its board routing by layer.
Inputs: name (required).
get_partBRead-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_kicadADestructiveIdempotent
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_rulesBRead-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_designsARead-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_pairsBRead-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_netsBRead-onlyIdempotent
Nets (merged across schematic sheets) with pin counts and routed length on the board.
Inputs: limit, filter. Returns: result
list_partsBRead-onlyIdempotent
Parts on the board with placement and JLC attributes. filter matches refdes, value or package.
Inputs: limit, filter. Returns: result
list_poursARead-onlyIdempotent
Copper pours with their live settings: net, layer, thermal relief width, isolate, rank.
Inputs: no named parameters.
move_partADestructiveIdempotent
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_clustersADestructiveIdempotent
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_3dADestructiveIdempotent
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_stubsADestructiveIdempotent
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_netADestructiveIdempotent
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_boardARead-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_reviewBRead-onlyIdempotent
Request a human design review from Groundplane (not connected yet: makes no network calls).
Inputs: notes.
review_schematicBRead-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_upADestructiveIdempotent
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_partBDestructiveIdempotent
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_statusBRead-onlyIdempotent
Unrouted connections, unrouted nets, segment and via counts, routed length.
Inputs: no named parameters.
run_drcBRead-onlyIdempotent
Run Fusion's DRC on the board and return the violations.
Inputs: no named parameters.
run_ercARead-onlyIdempotent
Run Fusion's ERC on the schematic and return the findings.
Inputs: no named parameters.
save_designBDestructiveIdempotent
Save the active document as a new version in Fusion's cloud.
Inputs: description.
score_placementARead-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_libraryCRead-onlyIdempotent
Search this server's component library (library/parts).
Inputs: query (required). Returns: result
set_board_outlineADestructiveIdempotent
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_valueADestructiveIdempotent
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_variantBDestructiveIdempotent
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_thermalsADestructiveIdempotent
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_movesARead-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.
undoADestructiveIdempotent
Undo the last change in the board or schematic editor.
Inputs: editor.
update_from_librariesADestructiveIdempotent
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
Scored across 77 tools
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.
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.
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.
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
Related MCP Connectors
Design, route, check, review and export manufacturable PCBs from plain language; KiCad import.
EasyGerber brings AI printed circuit board (PCB) design, layout, and routing to MCP-compatible assistants. Describe a circuit or start from firmware pin assignments, search published electronic components, and build schematics using catalog parts with their footprints and available 3D models. Create and revise boards, generate layouts with automatic component placement and routing, inspect previews, and check saved layouts for blocking design issues. Export manufacturing ZIPs containing Gerber and drill files, a bill of materials, and component placement data, or download an editable EasyGerber (.egb) file. Start without signing up. Your agent uses one private board reference to create and continue a board, including catalog access, edits, layout, checks, previews, and exports, without a separate guest setup step or token to manage. To keep the board in your account or work with permitted saved personal or organization boards, complete EasyGerber sign-in and OAuth consent, then resume the same task. Account permissions, plan limits, and generation billing apply; support depends on your MCP client and installed integration.
Design and revise PCBs from plain language, track jobs, and retrieve design artifacts.
Your electronics workspace. Explore public PCB projects and inspect schematics, layouts, BOMs and saved versions with your AI assistant.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to interact with 嘉立创 EDA for PCB design tasks including project management, component libraries, rule checking, and manufacturing constraints.-
- FlicenseNot gradedqualityFmaintenanceEnables AI assistants to interact with JLCEDA EDA for schematic/PCB design operations like component placement, wiring, and circuit analysis through natural language.-
- AlicenseCqualityDmaintenanceEnables 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.1001MIT
- AlicenseAqualityDmaintenanceEnables 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.14MIT