copperflow
Allows importing electronic parts and footprints from EasyEDA by LCSC part number into the local library, with imported parts marked as unverified.
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., "@copperflow move R1 to pcbX 4.5 and add a trace from R1.1 to C2.2"
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.
copperflow
A PCB design program you and your AI agent use together. The agent places, routes, checks and exports the board through MCP, with or without a window open; you work in the same files in the editor, and every change it makes is one step you can undo. Schematic, PCB, autorouting, DRC, Gerbers, BOM and a 3D view, on your own computer.
Website ·
Download the desktop app ·
Connect your agent ·
npm install -g copperflow
Circuits are TSX files with elements such as <board>, <resistor> and <trace>, which
copperflow builds and draws with its own engine. You and your agent work on them together:
the agent changes the circuit through an MCP server, and every change is one undo step;
you lock the parts you have placed, and the agent cannot move or change them;
you leave marks such as "route ground here", and the agent reads them;
edits are written back as minimal text changes, so the rest of your code stays as you wrote it.
Everything runs locally. There is no chat inside copperflow: use the agent you already use, for example Claude Code or Claude Desktop, through MCP.
Status: 0.5, early. The core, the MCP server, the CLI, the editor, the desktop app, the parts library, placement, routing and the fabrication export work. Expect rough edges; see docs/design.md.
Quick start
Requires Node.js 22 or newer.
npm install -g copperflowTo work on copperflow itself, install it from source instead:
git clone https://github.com/kurpeeren/copperflow.git
cd copperflow
npm install
npm run build
npm linkTry it on the example board (in the source tree):
copperflow summary --root examples/usb-c-ldo index.circuit.tsxcopperflow check (and the agent's check_circuit) runs copperflow's own rule checks and nothing else, so no other tool needs to be installed:
the electrical rules check (ERC): pins left unconnected, outputs driven together, nets without a power source and so on;
the placement design-rule check (DRC): overlapping courtyards, parts off the board, pads and holes too close to each other;
problems in the code and the model, the same ones the Studio shows: a footprint it cannot make (
footprint), a pin that does not exist (unknown-pin) or that several pins share (ambiguous-pin), an instance that overrides its library part (library-override) and so on.
Design rules live in rules.yaml at the project root: a fabrication profile (JLCPCB 2-layer by default), net classes and global nets. The usb-c-ldo example shows a small one, and skills/copperflow/references/design-rules.md explains the format and every check.
The CLI groups findings by code, with their positions; the agent's check_circuit lists them one per line, errors first. Any error fails the check (exit code 1). Copper checks (clearance between nets, track width, via drill and ring, board edge, keepouts, shorts) cover the tracks and vias in the layout file.
Connect Claude Code
From your circuit project:
claude mcp add copperflow -- copperflow mcpThe agent learns the workflow from the guide that comes with the server (the guide tool), so
nothing else is needed. To have the same text as a Claude Code skill, in .claude/skills/copperflow:
copperflow skillcopperflow skill --global installs it once for every project. Steps for other agents are at
https://copperflow.kurpeeren.com/connect.html.
Any other MCP client can run copperflow mcp over stdio from the project folder
(or pass --root <dir>).
Without installing, the same server starts through npx: give npx -y copperflow mcp wherever a
client asks for the command. The first start takes about a quarter of a minute while npm fetches
the package.
An agent that can run commands can set copperflow up for itself: the steps are at https://copperflow.kurpeeren.com/llms.txt as plain text. Most programs load their MCP servers when a session starts, so the tools appear in the next session, not in the one that added them.
copperflow connect claude-desktop adds the server to Claude Desktop's config (it keeps every other
setting and leaves a backup of the original); copperflow connect claude-code prints the line for
Claude Code.
While a tool runs long (autoroute, autoplace, the exports, a 3D picture) the server sends MCP
progress notifications, so a client that shows them says "Routing: 3 of 8 connections". When the
Studio is open on the same project, every tool call also shows in a strip under its toolbar, and
open_studio brings that window to the front instead of opening another.
Desktop app (Windows, macOS, Linux)
The latest release has the app with its own
runtime, so no Node.js or npm is needed: copperflow-Setup.exe for Windows (installs for the current
user), copperflow-mac-arm64.dmg or copperflow-mac-x64.dmg for macOS, and
copperflow-linux-x86_64.AppImage or copperflow-linux-amd64.deb for Linux. It opens to a start screen
(recent projects, open a folder, a new project) and then the Studio of that folder; File → Projects… goes
back, and the Files tab of Project Design shows the folder file by file, with a preview of its text and
pictures. The same program is the MCP server: the start screen's Connect writes it into
Claude Desktop, and Copy the command gives the line for Claude Code. An agent works headless; when
the window has its project open, the agent's changes and what it is doing appear there as it goes.
The apps are not signed with a developer certificate yet: Windows shows "Windows protected your PC" the
first time (More info, then Run anyway), and macOS asks once in System Settings, Privacy & Security (Open
Anyway). The release carries each file's SHA-256 beside it. Every version tag builds all of them
(.github/workflows/desktop.yml). To build one from source: npm run build, then in desktop/, npm ci
and npm run dist (Windows), npm run dist:mac or npm run dist:linux; the files are in desktop/out/.
Open the visual editor
copperflow studio --root examples/usb-c-ldoThen open the address it prints. The address carries a key for this session, so other web pages and other programs on your computer cannot use the editor's API.
A connected agent opens it for you: ask it to open copperflow and it calls open_studio, which
starts the editor for the project if none runs and opens it in your browser. An editor started
that way stops by itself an hour after the last tab closes; copperflow studio stop stops it at once.
The schematic and the PCB are drawn from the design copperflow's engine builds, with copperflow's own footprints and schematic symbols. The PCB shows the ratsnest, a straight line for each connection still to be made, until it is routed by hand or by the router. A third tab, 3D, shows the board as it will be made with its parts on it (see Pictures and 3D).
The window is laid out like a desktop EDA editor:
The menu bar (File, Edit, View, Place, Design, Route, Layout, Tools, Export, Settings, Help) runs every command Studio has, and shows the ones still to come greyed out, with the stage or round that brings them. The build status sits at its right end; click it to see the checks.
The toolbar under it holds the open document's tools: undo, zoom and fit, the schematic's Place tools (component, wire, net label, ground, power), rotate, Check DRC and the PCB's unit, and at its right end the snap grid, the PCB's layer switches and Keep these positions.
The strip at the left edge opens Project Design or Common Library. Project Design has four tabs: Page (the project's circuit files, each with its Schematic and PCB), Net (every net; click one to highlight it in both views), Component (the parts) and Object (the connections).
The strip at the right edge opens Properties: the selected part in Basic, Footprint, Position, Connections, Library and Notes sections, or, with nothing selected, the build, the notes for the agent and the bill of materials, which it exports with the datasheets.
Document tabs above the canvas switch between the open file's Schematic and PCB.
The strip at the bottom opens Library, Log (the history, with undo), DRC (the build's errors and warnings, which are ringed on the canvas; click one to go to it) and Find Results.
The mouse, in both views:
Click a part to select it; Shift or Ctrl and click adds it or takes it out.
Drag the background to draw a selection box: left to right takes the parts inside it, right to left the parts it touches; with Shift or Ctrl held it adds to the selection.
Drag a part to move it, or a selected part to move the whole selection; parts snap to the grid (0.1, 0.5 or 1 mm on the PCB).
Drag with the right (or middle) button to pan, and scroll to zoom.
Double click a part to edit it in Properties.
Place → Note box, then drag a box, leaves a note for the agent.
Press R to rotate and Delete to remove, lock parts, change values in Properties, draw wires in the
schematic as in KiCad (click a free pin, or press W over a pin, click the sheet for corners on the grid,
then click a pin, a net label or a wire; Esc cancels) and undo changes.
Drag a net label or a ground or power symbol in the schematic and its wire follows, written as schematicRouteHints on the trace (Esc cancels the drag).
The Place tools in the schematic toolbar (Net label, Ground flag, Power flag) put a label on a pin you click, written as a trace with one corner, and stay armed until Esc (while one is armed, dragging the background pans); Tab names a label before you click.
A double click on a net label renames its net everywhere; on a ground or power flag it asks first.
Design → Highlight net lights every net of the selected part.
Keys, ignored while you type in a field:
WorAlt+Wwires,Alt+Nplaces a net label,SpaceorRrotates,Deleteremoves,ForKfitsHhighlights the net under the pointer,Shift+Hclears itQswitches the PCB between mm and mil (display only),Shift+Fsearches the libraryOn the PCB
Urounds the corners of the selected tracks (Edit → Fillet tracks; with nothing selected, every track after a confirm) andShift+Ustraightens them again; Design → Design rules sets the radius[,]and\hide and show the left, right and bottom panels; the bottom panel comes back on the tab it hadCtrl+Zundoes the last change,Ctrl+Ogoes to the circuit files under Project Design → PageCtrl+Aselects every part,Ctrl+Fopens the find box (Enter lists what matches in Find Results)The arrow keys move the selection one grid step,
Shiftand an arrow ten stepsWith several parts selected,
SpaceorRturns them together about the centre of the selectionA right click without moving opens the context menu on a part, a net label or the empty canvas;
Shift+F10or the menu key opens it on the selected part from the keyboardEscclears the selection and puts the tools awayIn the menu bar the arrow keys move between the menus and their items, Enter or Space runs an item and Esc closes the menu; in every row of tabs the arrow keys move between the tabs. Help → Keys lists every key.
Every edit is written back into the circuit file and shows at once. When the agent changes the file, the editor updates by itself.
The Library, in Common Library and in the bottom strip, places parts from your library or the built-in parts (resistor, capacitor, LED and so on). Selecting a library part shows its maker, MPN, supplier number, datasheet and checklist in Properties, and lets you mark it verified. Library → New part… writes a part from its datasheet with a live footprint preview, and Library → Import by LCSC number… fetches one from EasyEDA; both leave it not verified.
Related MCP server: quartet
How it works
The editable subset. copperflow only writes back to code it can read without running it:
a part needs a string-literal name, and a prop is editable when its value is a literal such
as pcbX={4.5} or resistance="10k". Parts inside .map() or with spread props, and
expressions such as pcbX={x + 2}, are shown as read-only. Nothing else is restricted.
Locks and marks. They live next to the circuit in board.circuit.annotations.json, so
they stay out of the circuit code and git keeps them. Only you lock and unlock. The agent's tools
refuse to touch locked parts, and every summary reports a locked part that was changed some
other way.
Parts library. Chips and connectors live in parts/<id>/part.yaml in your project: pins
with names and electrical types, a footprint, MPN and supplier numbers. The footprint is either a
string such as sot23_5, from which copperflow makes the pads (the strings it knows are listed in
editable-subset.md, and
copperflow packages [words] browses the standard packages by name, with pads and size), or
footprint.yaml, a file next to part.yaml with every pad transcribed from the datasheet's
recommended land pattern; the example's USB-C connector has one. copperflow generates the part's
component from part.yaml. The agent creates parts from datasheets, or copperflow parts import C7950 fetches one by its LCSC number from EasyEDA (see licences for what the
source allows: personal, non-commercial use only; parts with letter-numbered pins such as BGAs are
refused); they stay not verified
until you check verification.md, which covers footprint.yaml too, and run
copperflow parts verify. An imported footprint keeps EasyEDA's orientation, which is JLCPCB's,
so pick-and-place needs no correction; place it at pcbRotation -90 to match a generated footprint
of the same package.
BOM and datasheet package. copperflow bom groups parts by value, footprint and part
number; copperflow package writes the BOM, the local datasheets and every library part's
verification status into one folder. Both read the design copperflow builds from the circuit code,
so parts made in loops are counted, and supplier numbers come from the code and the library; there
is no --build option.
History. Every change made through copperflow is stored in .copperflow/history/ with
who made it. copperflow undo reverts the newest change; the agent can undo only its own.
The agent sees what you undid and does not repeat it.
Beyond drawing
Checking a part against its datasheet. Verify on a library part opens a screen in the Studio: the footprint drawn with its dimensions, each pin as a row to tick, and the recorded datasheet beside them. The part can be marked verified only when every item is ticked, and only a person can do it.
What a change did. copperflow history <id> (the agent's recent_changes { id }) says what one
change did: parts added, removed and moved, nets and copper; --since <id> covers everything after
it. copperflow render <file> --change <id> draws it on the board, and each row of the Studio's Log
has Show.
Ready to order. copperflow bom ends with whether the board is ready to order bare and ready for
assembly, and names the lines with no supplier part number. No price or stock is checked.
Pin map for firmware. copperflow pins <file> lists which net is on each pin of the chips and
connectors, as a table, CSV or a C header (--format c); copperflow package writes them too.
Fabrication files. copperflow export <file> writes the Gerbers, drills, pick-and-place file and
BOM for JLCPCB into <name>-fab/ and a zip, with <name>.step for a mechanical CAD program and a
picture of each side of the board. A circuit with errors is refused.
Pictures and 3D. copperflow render <file> --view board draws the bare board as made: every
fabrication layer is drawn by itself, from the same data the Gerbers are written from, and they are
put together as mask, finish, print and holes, in the maker's usual colours (--mask, --finish,
--silk). --view 3d and the Studio's 3D tab lay that picture on the board and stand the parts on
it. copperflow glb <file> writes that same board and its parts as a GLB file, a 3D model a viewer, a
3D editor or a web page opens and turns; copperflow step <file> writes the STEP file alone. Both
write a board that is not finished too. copperflow html <file> (MCP export_html) writes the whole design as
one web page to hand to someone: every schematic page, the PCB view, the board as made top and bottom,
3D from three angles and the BOM as a table, with the fabrication zip, the GLB, the STEP file and the
BOM as CSV inside it as downloads. It opens from disk with no network; a design with errors is written
too, without the fabrication files, and says why. The parts are simple shapes, not their real models, in the 3D
view, the GLB file and the STEP file; a part's height comes from its height in part.yaml, else a
typical figure for its package, else 1 mm, and the view says which.
Fast lines. Net classes in rules.yaml take an impedance, a differential pair with its gap and
skew, a longest length and length-matched groups; the checks report a pair that runs apart or differs
in length, and copperflow impedance gives widths and gaps for the board's stack. The figures are
estimates, and the router does not route pairs together or tune lengths yet. See
design-rules.md.
Simulation. copperflow simulate (the agent's simulate) finds the DC operating point from ideal
sources and simple part models: no time, no frequency, no temperature, no tolerance, and chips are not
modelled. A sheet's card can hold cases ("at 24 V in, the output is between 3.0 and 3.5 V") that it
runs; copperflow spice writes the same circuit as a SPICE netlist for another simulator.
A board from KiCad. copperflow import kicad board.kicad_pcb (the agent's import_board, or
File, Import board in the Studio) makes a new circuit from a KiCad 6 or newer board: its outline,
parts, nets, tracks, vias and pours. The parts arrive as library parts, not verified.
MCP tools
Tool | What it does |
| Lists the |
| Compact by default (a line per part and net, locks, marks, lock violations); |
| Sets literal props: position, rotation, value, footprint; |
| Removes a part and its traces |
| Connects or disconnects two ports or nets |
| Runs copperflow's own ERC and placement DRC: counts, then up to 20 findings, one line each; |
| Writes a whole new circuit from a netlist in one call: parts (a built-in |
| Places the parts nobody placed or locked (or only |
| Shrinks or grows a rectangular board to the parts' courtyards plus |
| Sets the board's outline, mounting holes and keepouts from a DXF drawing in the project folder, as one change; a |
| Routes the unrouted connections (the whole board, some nets, some parts or one instance) and names each one it could not route with the reason; or removes the router's copper |
| A copper pour of a net on one layer, or a non-plated mounting hole, each as one change |
| The DC operating point of a circuit or a sheet: set nets to volts, close switches, energise relay coils; with a sheet and no values it runs the sheet's cases |
| Moves parts into a sub-sheet with ports, and writes a sheet's card: what it does, its ports and its cases |
| The shelf of modules and the libraries: read one, bring one into the project, save a described sheet |
| Writes the fabrication files, the STEP model and the board's pictures; refused when the circuit has errors |
| Writes the board and its parts as one 3D model file, STEP for mechanical CAD or GLB for a 3D viewer; an unfinished board too |
| Writes the design as one web page (schematic, board, 3D, BOM, with the fabrication and model files inside) to hand to a person; opens offline |
| Records the datasheet a part came from; and the copperflow skill's texts for an agent that has no skills |
| Several edits in one call, applied as one change (one history entry); stops at the first refused edit and writes nothing |
| Connects many pins to named nets in one call, e.g. |
| Draws one track of a net by hand from a pad, track or via of that net, as one change; refused when a point lands on another net's copper; the answer lists the copper violations it introduced |
| Places a via (net from the copper under it, size from the net class and the fabrication ring) or removes tracks and vias by id (or one segment of a track by |
| Rounds the square corners of tracks (by id, or every track) into short chords on an arc of the design rules' fillet radius, or puts rounded corners back, each as one change; a corner too close to other copper, a pad, a keepout or the board edge, or with legs too short, stays square and is counted |
| Per net: tracks, vias, length and unrouted connections, then copper violations by rule (at most 60 lines) |
| The board in about 60 lines (size, one line per part, longest connections with both pads' places, overlaps, edge, pours; |
| Starts the Studio for the project if none runs, opens it in your browser and answers with the address |
| A PNG of the board or of one schematic page, drawn by the Studio's own code; |
| Shows the parts library and a part's data and checklist |
| Adds a part from a datasheet: pins, footprint string or footprint file, MPN, suppliers |
| Fetches one part by its LCSC number from EasyEDA into |
| Adds a library or built-in part to a circuit, with its import |
| Bill of materials, with whether the board is ready to order; folder with BOM, datasheets, part status and pin maps |
| Recent changes by you and the agent, including undos; |
| Undoes one of the agent's own changes |
There is no unlock tool and no verify tool on purpose.
CLI
copperflow mcp start the MCP server on stdio
copperflow studio [--port n] [--idle-minutes n]
open the visual editor at http://127.0.0.1:4777 (or a free port);
with --idle-minutes it stops after n minutes with no tab open
copperflow studio stop stop the Studio of this folder
copperflow skill [--global] copy the copperflow skills into .claude/skills of this folder
(or of your home folder), for agents that read skills
copperflow summary <file> print a circuit summary
copperflow check <file> list the errors and warnings of copperflow's own rule checks
copperflow lock <file> <part...> lock parts so the agent cannot change them
copperflow unlock <file> <part...> unlock parts
copperflow mark <file> <text> [--pcb x,y | --sch x,y]
leave a note for the agent
copperflow unmark <file> <id> remove a note
copperflow parts list the parts library
copperflow parts build regenerate part components after editing part.yaml
copperflow parts verify <id> --by <name> --against <datasheet, page>
mark a part as checked against its datasheet
copperflow parts import <C-number> [--id <id>] [--replace]
fetch a part by its LCSC number from EasyEDA into parts/,
not verified (needs the internet; see docs/licences.md)
copperflow modules list the shelf of modules (COPPERFLOW_MODULES, default ~/.copperflow/modules)
copperflow modules verify <name> --by <name>
mark a module (or <library>/<name>) as checked by you
copperflow modules remove <name> take a module off the shelf
copperflow library list the libraries of modules: built in, git and folders
copperflow library add <name> <address or folder> [--ref <branch or tag>]
add a library from git (https://, ssh:// or user@host:path)
or a folder; its modules read NOT verified until you verify them
copperflow library update [name] bring git libraries to the newest commit of their ref
copperflow library remove <name> forget a library (a clone is deleted, a folder never)
copperflow packages [words...] the standard packages with their footprint strings, pads and size
(words narrow the list: soic, sot 5, sc70, crystal)
copperflow place <file> <part> <name> [key=value ...]
add a library or built-in part to a circuit
copperflow bom <file> [--csv] print the bill of materials
copperflow package <file> [--out dir]
write BOM, datasheets, part status and pin maps to a folder
copperflow pins <file> [--part <name>] [--format md|csv|c]
which net is on each pin of the library chips and connectors
copperflow export <file> [--out dir] write the fabrication files for JLCPCB: Gerbers, drills,
pick-and-place and BOM in <name>-fab/ and <name>-fab.zip
beside the circuit (or in the project folder --out), with <name>.step
copperflow step <file> [--out file.step] write the board and its parts (as boxes) as a STEP file for CAD,
<name>.step beside the circuit
copperflow glb <file> [--out file.glb] [--mask black] [--finish hasl] [--silk black]
write the board as made and its parts (as simple shapes) as a GLB
file a 3D viewer turns, <name>.glb beside the circuit
copperflow html <file> [--out file.html] [--mask black] [--finish hasl] [--silk black]
write the design as one web page with its files inside,
<name>.html beside the circuit
copperflow render <file> [--view pcb|schematic|board|3d] [--page <name>] [--parts U1,C3] [--width n] [--out file.png]
board: the bare board as made [--side bottom] [--mask black] [--finish hasl] [--silk black] [--background #rrggbb]
3d: the board as made with its parts as simple shapes [--angle top|bottom|front|iso] and the same look options
[--change <id> | --since <id>]
draw the board or a schematic page to a PNG, as the Studio shows it
(<name>-pcb.png or <name>-schematic-<page>.png beside the circuit)
copperflow simulate <file> --set V12=12 --set CTRL=3.3 [--sheet <name>] [--closed SW1,J2] [--coil K1] [--all]
the DC operating point from ideal sources and simple models: no time,
no frequency, no temperature, no tolerance; chips are not modelled.
With --sheet and no --set it runs the sheet's cases
copperflow spice <file> [--sheet <name>] [--set net=volts ...] [--out file.cir]
write the same circuit as a SPICE3 netlist for another simulator
copperflow board <file> --dxf <path> [--layer <name>] [--units mm|inch] [--origin keep] [--replace]
set the board's outline, holes and keepouts from a DXF drawing
copperflow import kicad <board.kicad_pcb> [--name <circuit name>] [--replace] [--origin keep]
make a new circuit from a KiCad board: its outline, parts (as
library parts, not verified), nets, tracks, vias and pours
copperflow impedance [--single 50] [--pair 90] [--gap 0.2] [--width 0.3]
line widths and gaps for an impedance on the board's stack (rules.yaml);
an estimate: the router does not route pairs together or tune lengths
copperflow history [--limit n] list recent changes
copperflow history <id> | --since <id> what one change did, or everything after it
copperflow undo [id] undo the newest change, or the given oneEvery command accepts --root <dir> (default: the current directory).
Libraries
A library is a folder of modules laid out as the shelf is: modules/<Name>/ (or <Name>/ at the top
when there is no modules folder), each holding <Name>.sheet.tsx, parts/<id>/part.yaml (and
footprint.yaml) and an optional module.json. copperflow comes with one, named copperflow; you
add your own:
copperflow library add <name> <git address or folder> [--ref <branch or tag>]
copperflow library update [name]
copperflow library remove <name>copperflow library lists them. The agent sees their modules as <library>/<Name> in
list_modules, module_info and use_module. A circuit file is code that runs when the board
builds, so a sheet from a library enters a project only when copperflow has proved it plain (part
imports, one function returning tags with literal values, nothing else), and its parts come as data,
their component files written by copperflow. A library module reads NOT verified until you run
copperflow modules verify <library>/<Name> --by <name>.
Roadmap
0.2 (done) Visual editor in the browser: drag, rotate, lock, delete and reconnect wires, marks.
0.3 (done) Parts library (one folder per part) and datasheet-to-part import; BOM and datasheet package.
0.4 (done) Placement, routing, pours and the fabrication export; sheets, modules and libraries; part verification on screen, the change view, the order report, pin maps, STEP and the 3D view, fast-line rules, DC simulation, KiCad board import and the board drawn as made.
Next Routing pairs together and tuning lengths, time and frequency in the simulator, real part models in 3D.
Contributing
See CONTRIBUTING.md.
License
Apache License 2.0. See LICENSE and NOTICE. "copperflow" refers to this project; the license does not grant rights to the name.
The visual editor bundles open-source packages (React, MIT). Their licences ship in
dist/app/THIRD_PARTY_LICENSES.txt.
Available Tools
57 toolsadd_holeC
Add a non-plated mounting hole as ONE change.
Inputs: x (required), y (required), file (required), diameter (required).
add_pourB
Add a copper pour of a net on one layer as ONE change; it fills round other nets' copper on every build, and what it joins counts as routed. The answer gives its id and the pads it joins: check them.
Inputs: net (required), file (required), layer (required), props, +1 more.
add_textA
Write text as ONE change. Without layer: a note on a schematic page (default Main) at (x, y) sheet units. With layer: board silkscreen at (x, y) mm, height default 1.5. The answer names it (G3 or silkscreentext:1) for edit_circuit set_drawing/remove_drawing. Other shapes: add_drawing.
Inputs: x (required), y (required), file (required), text (required), +5 more.
add_traceA
Schematic trace (a connection, no copper): connect two ports or nets, e.g. from ".R1 > .pin1" to "net.GND".
Inputs: to (required), file (required), from (required), props.
add_viaB
Place a via by hand as ONE change; its net is that of the copper under it unless given.
Inputs: at (required), file (required), net, layers.
attach_datasheetA
Record the datasheet a part's pins came from (link, title, pages) in part.yaml and verification.md. The link is not fetched.
Inputs: url (required), part (required), pages, title.
autoplaceA
Place parts by their connections as ONE change: every part without a position, or only some parts or one instance. Placed and locked parts stay. Run it before autoroute. With fit: true a part with no room grows the board. The answer gives wire length, board size, overlaps, parts with no room and copper a move left behind.
Inputs: file (required), fit, parts, instance, +2 more.
autorouteA
Route the unrouted connections as ONE change: the whole board, or only some nets, parts or one instance (one of these). Run it after placing; parts with no position get no copper; existing copper is kept. It names each connection it could not route, with the reason: route those with route_track, or move parts and run it again.
Inputs: file (required), nets, parts, instance, +1 more.
board_summaryARead-only
The board in about 60 lines: size, layers, courtyard use, one line per part (position, side, [LOCKED] or "not placed"), the ten longest connections, overlaps, parts off the board, pours, silkscreen texts, drawings, unrouted count.
Inputs: file (required), detail.
bomBRead-only
Bill of materials for a circuit, grouped by part, and whether the board is ready to order.
Inputs: file (required).
check_circuitARead-only
Check the circuit: electrical, placement, copper and pour rules. Answers with the error and warning counts, then up to 20 findings. Run it after autoplace, after autoroute and after removing copper; fix the errors before reporting success.
Inputs: file (required), filter.
circuit_summaryARead-only
Summarize a circuit: one line per part and per net, then locked parts, marks from the human and lock violations. filter "PS1" shows one sub-sheet instance; detail "full" lists every prop and trace.
Inputs: file (required), detail, filter.
connect_netsA
Connect pins to named nets as ONE change, e.g. { "GND": ["R1.pin2", "C1.pin2"] }; pins already on the net are skipped.
Inputs: file (required), nets (required).
copper_summaryARead-only
Summarize the copper in at most 60 lines: totals, per net (tracks, vias, unrouted), pours and holes by id, violations by rule. Call it before and after drawing copper.
Inputs: file (required).
create_partA
Create a library part from a datasheet you have read: pins by number with names and types, a footprint string (sot23_5, 0402), MPN, suppliers. When no string fits, package { "file": "footprint.yaml" } with footprint_file pads copied from the datasheet land pattern (never estimated). datasheet (url, file, title) e.g. { "url": "https://example.com/ds.pdf", "title": "TJA1051 datasheet" }; pin table pages go to attach_datasheet. An existing id is refused unless replace. The part starts NOT verified: tell the human to check verification.md.
Inputs: id (required), pins (required), title (required), package (required), +8 more.
describe_sheetB
Write a sheet's card: does (one line), sources, each port's type and what it carries, cases for simulate. "" or [] removes. One history entry. Limits and a good card: guide { topic: "modules" }.
Inputs: file (required), does, cases, ports, +1 more.
edit_circuitA
Apply several edits in order as ONE change, each with one key shaped like the tool of that name (connect also takes corners). add_drawing, set_drawing, remove_drawing, add_page, rename_page, remove_page, wire_corners, rename_parts, rename_port, sheet_size, set_pour, set_hole: guide { topic: "writing-circuits" }. One refused edit writes nothing; the answer names it.
Inputs: file (required), edits (required).
export_fabricationA
Write the JLCPCB fabrication files to -fab/ and a zip: Gerbers, drills, pick-and-place and BOM CSVs, pictures of the board as made and a STEP model. Call it after a clean check_circuit: a design with errors is refused.
Inputs: file (required), out.
export_htmlA
Write the design as one HTML file beside the circuit (schematic, board, 3D, BOM, fabrication and model files inside; opens offline). Use it to hand the design to a person as one file.
Inputs: file (required), out, look.
export_modelA
Write the board and its parts as one 3D model file beside the circuit: a STEP file for mechanical CAD (parts as boxes) or a GLB file a 3D viewer turns (the board as made). An unfinished design is written too.
Inputs: file (required), format (required), out, look.
export_packageC
Write a folder with the BOM, local datasheets and the library parts' verification status.
Inputs: file (required).
fillet_tracksA
Round the square corners of tracks as ONE change. A corner stays square where the arc would break clearance; the answer counts those with reasons. Locked tracks are left alone; straighten_tracks undoes it.
Inputs: file (required), ids, radius.
fit_boardB
Set the board as ONE change: by default a rectangle round the parts plus margin; or width and height (centred on x, y), or an outline; layers: 2 or 4 copper layers. The answer names parts left outside.
Inputs: file (required), x, y, width, +4 more.
guideCRead-only
The copperflow skill: SKILL.md, or a reference with a topic. A text already read answers a short line unless again. Call it when the skill is not installed.
Inputs: again, topic.
import_boardA
Set the board from a DXF or SVG drawing as ONE change: the largest closed shape is the outline, circles in it mounting holes, other shapes keepouts. Parts are not moved; the answer lists those now outside. A .kicad_pcb instead makes file a new circuit (outline, parts, nets, copper); the answer lists what did not come over.
Inputs: dxf (required), file (required), layer, units, +2 more.
import_graphicA
Place a drawing (logo, mark) from source, a project .svg/.dxf, on the board as ONE change; kept in graphics/. Centre x,y and width in mm (else board centre); width keeps aspect; fill fills closed outlines; net (copper) makes it that net's copper. Answers id, size, omissions.
Inputs: file (required), layer (required), source (required), x, +7 more.
import_partA
Import one part by its LCSC number when the human asks: symbol, footprint and attributes from the JLCEDA/EasyEDA library into parts//. It is NOT verified: tell the human to check verification.md, and that the import is for personal, non-commercial use only (EasyEDA's terms). Never import in bulk. Needs the internet. Letter-numbered pins (BGA, many USB-C) and bottom pads are refused: use create_part.
Inputs: lcsc (required), id, replace.
list_circuitsARead-only
List the circuit files (*.circuit.tsx) in the project.
Inputs: no named parameters.
list_modulesBRead-only
The shelf, then each library (modules named library/Name), one line a module. Look here before designing a block.
Inputs: filter.
list_partsARead-only
List the parts library (parts/) with verification status. Built-in kinds (resistor, capacitor, led, pinheader, …) are not here: guide { topic: "writing-circuits" } lists them.
Inputs: no named parameters.
make_sheetA
Move parts into a new sub-sheet .sheet.tsx and put an instance of it in their place, as ONE change. Each net crossing the boundary becomes a port of that name, so the netlist stays the same.
Inputs: file (required), name (required), parts (required), rename, +1 more.
module_infoCRead-only
A module's card, ports, parts, sources and origin.
Inputs: name (required).
new_circuitA
Write a whole new circuit file from a netlist in one call: parts (no positions) and nets (pin lists). Unless place is false the board is then placed (fitted when no board is given) as a second entry. A block used more than once goes in sheets, used by instances. Nothing is written if anything is wrong; the answer says what. An existing file is refused unless replace. Details: guide { topic: "writing-circuits" }.
Inputs: file (required), nets (required), parts (required), board, +7 more.
note_decisionB
Note a design decision in PROJECT.md as one dated line, as ONE change: each choice a later context should not undo (a part and why, a board size, what the person approved).
Inputs: text (required), file.
open_studioA
Open the Studio, the visual editor, for the person: reuses this project's running Studio or starts one, and opens it in their browser. Call it when the person asks to open copperflow, the editor or the board, or wants to watch. Give them the address it returns, to them only.
Inputs: open.
part_infoBRead-only
Show a library part's part.yaml, its footprint's pads and the verification checklist.
Inputs: id (required).
place_partB
Add a part to a circuit: a library part id from list_parts or a built-in kind (guide { topic: "writing-circuits" }).
Inputs: file (required), name (required), part (required), page, +1 more.
project_statusARead-only
Call this first in every task: PROJECT.md (intent, blocks, last decisions, open items), then per circuit file its counts, unplaced, unrouted, errors, warnings and last changes.
Inputs: no named parameters.
recent_changesBRead-only
List recent changes by you and the human, newest first, with undos and redos. id: what one change did; since: all after it.
Inputs: id, limit, since.
redo_changeA
Redo one of your own undos: the newest, or the given id (the undo's or the undone change's). A human's undo is theirs; you cannot redo it.
Inputs: id.
remove_copperADestructive
Remove tracks and vias by id (from copper_summary or check_circuit) as ONE change; { id, segment } removes one segment. Locked copper is refused.
Inputs: ids (required), file (required).
remove_holeADestructive
Remove a non-plated hole by id as ONE change. Locked holes are refused; a hole inside an instance ("PS1/hole:1") lives in its sheet file.
Inputs: id (required), file (required).
remove_partBDestructive
Remove a part and every trace connected to it.
Inputs: file (required), part (required).
remove_pourADestructive
Remove a copper pour by id as ONE change. Locked pours are refused; a pour inside an instance ("PS1/copperpour:1") lives in its sheet file.
Inputs: id (required), file (required).
remove_traceADestructive
Schematic trace (a connection, not copper): remove the one between two selectors (in either direction).
Inputs: to (required), file (required), from (required).
renderB
A PNG of the board or one schematic page, as the person sees it; view board: the bare board as made; 3d: with parts as simple shapes, at an angle. Look after autoplace and autoroute, before asking the person.
Inputs: file (required), out, look, page, +7 more.
route_trackA
Copper track (not a schematic trace): draw one of a net by hand as ONE change: corners on one layer, or from and to pads (via: corners between; none: the router finds the path or says what is in the way). It starts on the net's copper, not a locked part's pad, and touches no other net. The answer lists copper violations. For what autoroute could not route.
Inputs: file (required), to, net, via, +4 more.
save_moduleC
Copy a described sheet and its library parts to the person's shelf of modules, after they approved the board. Refused without does or with a port that has no type and no carries (describe_sheet).
Inputs: file (required), name, replace.
set_part_fieldsA
Set a library part's suppliers, mpn, manufacturer or description; pins and footprint stay. null removes one. A verified part is refused.
Inputs: id (required), mpn, suppliers, description, +1 more.
set_projectA
Rewrite sections of PROJECT.md as ONE change: intent (at most 2000 characters), blocks (an array of at most 50 { name, does, status }) and open (an array of at most 50 non-empty strings). Sections not given and Decisions stay.
Inputs: open, blocks, intent.
set_propsA
Set literal props of a part (pcbX, pcbY, pcbRotation, schX, resistance, footprint, …); missing props are added. schNameAt, schValueAt and pcbNameAt are label offsets { x, y }; noConnect: "pin3,pin10" flags pins meant to stay open; supplierPartNumbers: "jlcpcb:C25804". null removes these.
Inputs: file (required), part (required), props (required).
set_rulesA
Change rules.yaml as ONE change, merged into it: netClasses (trackWidth, clearance, via), fabrication (profile "jlcpcb-4layer", minimums, placementRotations). A bad value is refused with the reason. The answer says what it means for the board.
Inputs: rules (required), file.
simulateARead-only
DC operating point of a circuit, or of a sheet beside it: set nets to volts ("open" floats), close switches, energise relay coils; answers nets, sources, parts beyond a limit, then each part. With sheet and no set it runs the sheet's cases; no time, frequency or tolerance, and chips are not modelled.
Inputs: file (required), all, set, coil, +2 more.
straighten_tracksA
Put back the square corners fillet_tracks rounded, as ONE change, where clearance allows. Locked tracks are left alone.
Inputs: file (required), ids.
undo_changeA
Undo one of your own changes: the newest, or the given id. A human's "Redo:" of it is theirs; you cannot undo it.
Inputs: id.
unrouteADestructive
Remove the router's copper, for some nets or all, as ONE change. Hand-drawn and locked copper stay.
Inputs: file (required), all, nets.
use_moduleC
Copy a module's sheet (and parts the project lacks) beside the circuit file; then add_instance. A library's sheet must be plain; its parts come as data.
Inputs: file (required), module (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 57 tools
There are clear but overlapping tool families: connect_nets, add_trace, route_track and edit_circuit wire_corners all relate to connections; copper_summary, board_summary, circuit_summary and project_status all summarize state; and export_fabrication, export_model, export_html and export_package all export. The descriptions do distinguish schematic trace from copper track and give hints, but with 57 tools an agent can easily pick a near-miss sibling.
Almost all tools use snake_case verb_noun or noun pairs (set_project, add_trace, remove_copper, export_fabrication), with only minor deviations such as noun-only bom, render and guide, plus new_circuit versus the usual create/import pattern. The naming is predictable enough that an agent can guess tool names reliably.
57 tools is far above a comfortable range, even for a complex PCB design domain. Several clusters could be consolidated (four export_* tools, three summary tools, multiple connection and module tools), so the count feels heavy and increases selection cost.
The surface covers a broad lifecycle: project intent, circuits, parts, placement, routing, copper, pours, holes, rules, simulation, checking, fabrication exports, modules and undo/redo. Minor gaps remain, such as no explicit circuit file deletion or rename, no library part removal, and no tool for locking a part despite lock-aware tools elsewhere.
Maintenance
Related MCP Connectors
Project management shared by people and AI agents, with persistent project state through MCP.
MCP-native collaborative markdown editor with real-time AI document editing
Real-time collaborative whiteboard — AI agents and humans edit the same board live over MCP.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables multiple AI agents to coordinate work on the same codebase by providing real-time file locking, commit approval, and agent awareness through a lightweight WebSocket-based MCP server.917 npm11MIT
- FlicenseNot gradedqualityDmaintenanceMCP server enabling AI agents to collaborate in shared rooms with a document edited via compare-and-swap optimistic concurrency, plus a chat channel and change deltas.-
- AlicenseNot gradedqualityAmaintenanceEnables AI agents and humans to collaboratively manage kanban boards and Markdown documentation via MCP tools, with stable item keys, revision-safe editing, and full audit trails.AGPL 3.0

forge-orchestratorofficial
FlicenseNot gradedqualityAmaintenanceEnables orchestrating multiple AI coding tools (Claude Code, Codex CLI, Gemini CLI) on shared repositories with file locking, knowledge capture, task planning, and drift detection via an MCP server.166-