Server data from the Official MCP Registry
Design KiCad schematics and routed PCBs by talking to Claude. Checked by KiCad. Needs KiCad 10.
About
Design KiCad schematics and routed PCBs by talking to Claude. Checked by KiCad. Needs KiCad 10.
Security Report
Valid MCP server (3 strong, 0 medium validity signals). No known CVEs in dependencies. Imported from the Official MCP Registry.
12 files analyzed · No issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
How to Install
Install command not verified. See the repository for install instructions.
View repositoryDocumentation
View on GitHubFrom the project's GitHub README.
MCP-KiCad
Design electronic schematics and boards by talking to Claude. This is an MCP server that lets a language model draw real KiCad schematics — placing parts, wiring nets, adding power symbols and running KiCad's own electrical rules check — turn them into placed and routed two-layer boards, and hand you the files to open, edit and send to a board house.
What it actually does
You ask for a circuit in plain language. Claude writes a short declarative description of it and calls one tool, compile_schematic, which turns that description into a finished schematic file.
You: Build me a 555 astable running at about 1 Hz, 5 V supply.
Claude: [looks up the real pin names of the NE555, writes the design, compiles it] Done — 7 components, ERC clean. Here's the preview.
The result opens in KiCad like any other schematic. It is not a picture: it is a real file with a real netlist — and one more call turns it into a board.
What makes the output usable
Generating something is easy; generating a schematic a human would accept is not. Every compiled schematic is checked before you see it, and the compiler refuses to emit anything that fails:
| Guarantee | How it is enforced |
|---|---|
| No wire crosses a wire from a different net | A geometric gate re-checks every segment. Offenders become net labels instead |
| No wire runs through a component body | Same gate, checked against each symbol's real outline |
| Every declared connection exists | The finished file is re-read and its netlist compared against what you asked for |
| No accidental extra connections | The same check, in reverse — a wire that touches a pin it shouldn't is an error |
| Power symbols really touch their pins | Verified by physical contact, not by net name |
| A junction wherever wires meet | The rule was measured across the 115 schematics KiCad ships: a dot where three or more wire ends meet, and where two meet on a pin |
| KiCad agrees | kicad-cli runs ERC on the result and the report comes back with it |
If a connection cannot be drawn cleanly, it degrades to a net label rather than producing a wire that lies. The schematic is never silently wrong.
A net crossing itself is not one of those cases: it is one net either way, so the wire is cut at the crossing and given a junction rather than being thrown away. Only a genuine conflict with another net costs you a wire.
From schematic to board
Every part comes out of compile_schematic with a footprint that has been checked to exist and to have a pad for each pin — the one you named, the one KiCad's library symbol carries, or a stated default. compile_pcb then builds the board:
| Connectivity | Read from the netlist KiCad itself exports, so the board agrees with KiCad's Update PCB from Schematic, which keeps working on it |
| Placement | Seeded from the schematic layout; no overlapping courtyards; decoupling capacitors against their IC's power pin, connectors on the board edge, rotations that shorten the wiring |
| Routing | Two layers, 45° tracks, wider tracks for supplies and for any net you name (net_widths, e.g. 2 mm for a heater), a ground plane on the back. Or single-sided for boards made at home (single_sided): through-hole parts, every track on the bottom, wide tracks and pads for a CNC or toner transfer, and a straight wire jumper over the top only where a connection cannot be made. Track width and clearance are yours to set (track_width, power_width, clearance) |
| Checking | KiCad's DRC with schematic parity. A board that does not implement its schematic, or breaks a rule, is never handed over: the routing is thrown away and the board comes back unrouted, with the reason |
export_fabrication writes the Gerbers, drill files, a pick-and-place file, a BOM and a zip ready for a board house — and refuses to while the board fails those checks.
What it does not do
- It cannot check the parts in your hand. Pinouts and footprints come from KiCad's libraries and the datasheets; a transistor whose maker ordered its legs differently, or a module whose header is not the one in the library, is yours to check before ordering boards.
- No component invention. It uses KiCad's installed symbol libraries, and
find_part/import_partbring in what is missing from external KiCad libraries — verified before installation. If a part exists nowhere, it says so instead of drawing one. - Not a simulator. It draws what you describe; it does not tell you whether your circuit is a good idea.
Requirements
| KiCad 10 | Provides kicad-cli, used for ERC and for rendering. Earlier versions are untested. |
| Claude Desktop or Claude Code | Or any other MCP client. |
| Go 1.24+ | Only if you build from source. |
Installation
Option A — one click (recommended)
Download mcp-kicad.mcpb from Releases and double-click it. Claude Desktop installs it as an extension: no JSON to edit, no paths to type. The bundle carries the Windows, macOS and Linux builds, so the same file works everywhere.
Then skip straight to Checking that it works.
On Apple Silicon the bundled macOS build runs through Rosetta. If you want the native one, take
mcp-kicad-darwin-arm64from Option B instead.
Option B — download a binary
-
Go to Releases and download the file for your system:
System File Windows (Intel/AMD) mcp-kicad-windows-amd64.exeLinux (Intel/AMD) mcp-kicad-linux-amd64Linux (ARM, e.g. Raspberry Pi) mcp-kicad-linux-arm64macOS (Apple Silicon) mcp-kicad-darwin-arm64macOS (Intel) mcp-kicad-darwin-amd64 -
Put it wherever you like — say
C:\Tools\mcp-kicad.exeor~/bin/mcp-kicad. -
On Linux and macOS, make it executable:
chmod +x ~/bin/mcp-kicadOn macOS the first run is blocked because the binary is unsigned. Allow it with:
xattr -d com.apple.quarantine ~/bin/mcp-kicad
There is nothing else to install. The binary is self-contained and needs no configuration file: it finds KiCad on its own.
Option C — build from source
git clone https://github.com/unmateria/MCP-Kicad.git
cd MCP-Kicad
go build -o mcp-kicad ./cmd/server # add .exe on Windows
Connecting it to Claude
Not needed if you installed the .mcpb bundle — it registers itself.
Claude Desktop
Edit the configuration file — create it if it isn't there:
| System | Location |
|---|---|
| Windows | %APPDATA%\Claude\claude_desktop_config.json |
| macOS | ~/Library/Application Support/Claude/claude_desktop_config.json |
| Linux | ~/.config/Claude/claude_desktop_config.json |
Add the server:
{
"mcpServers": {
"kicad": {
"command": "C:\\Tools\\mcp-kicad.exe",
"args": []
}
}
}
On Linux or macOS the command is a normal path, "/home/you/bin/mcp-kicad".
Windows note: backslashes must be doubled in JSON (
C:\\Tools\\...). A single backslash is the single most common reason the server fails to start.
Then quit Claude Desktop completely and reopen it. Reloading the window is not enough — the server runs as a child process and only starts on a full restart.
Claude Code
claude mcp add kicad -- /path/to/mcp-kicad
Checking that it works
Ask Claude:
Use get_project_info to check the KiCad setup.
You should get back the detected kicad-cli path, the library directories, and the output directory. If it reports that kicad-cli was not found, see Configuration below.
Using it
Just describe the circuit. Be specific about what matters to you — supply voltage, part numbers you want, values you've already chosen — and leave the rest to Claude.
Prompts that work well:
Design a 5 V regulated supply from a 12 V input using an LM7805, with input and output decoupling and a power LED.
Make me an ATmega328P minimal board: 16 MHz crystal with load caps, reset pull-up, ICSP header, and decoupling on both supply pins.
Build a two-transistor astable multivibrator that blinks two LEDs at roughly 2 Hz.
Useful things to ask for afterwards:
- "Show me the schematic" — renders a preview image.
- "Export it as PDF" — through
kicad-cli. - "Run ERC" — KiCad's electrical rules check, with the violations explained.
- "Move the decoupling caps closer to U1 and recompile" — the design source is text, so revisions are cheap.
The generated files land in the output directory (get_output_dir tells you where; set_output_dir changes it).
The design source
Behind the scenes, Claude writes a small JSON document and compiles it. You will rarely need to touch this, but it is worth seeing, because it explains why the results are stable — positions are never given in millimetres, they are anchored pin-to-pin:
{
"version": 1,
"project": "led_18650",
"sheet": "auto",
"blocks": [
{
"name": "led",
"symbols": [
{ "ref": "BT1", "lib": "Device:Battery_Cell", "value": "18650" },
{ "ref": "R1", "lib": "Device:R", "value": "100", "rot": 90,
"place": { "pin": "1", "at": "BT1.+", "dir": "up", "cells": 1 } },
{ "ref": "D1", "lib": "Device:LED", "value": "LED_RED", "rot": 90,
"place": { "pin": "A", "at": "R1.2", "dir": "right", "cells": 3 } }
]
}
],
"nets": {
"VBAT": ["BT1.+", "R1.1"],
"_ANODE": ["R1.2", "D1.A"],
"GND": ["D1.K", "BT1.-"]
},
"power_nets": { "GND": "power:GND" }
}
The first symbol in a block anchors it; every other symbol hangs off a pin of one already placed, a whole number of 2.54 mm grid cells away. That is how a schematic stays on-grid and readable no matter how the model reorders things.
The complete format is specified in internal/tools/design_format.md (the same text the design_guide tool serves to the model), and there are thirteen worked examples in docs/compiler/ — from a two-part LED circuit to a greenhouse controller with 27 components.
Configuration
None is required. The server looks for KiCad in the usual places:
- Windows —
C:\Program Files\KiCad\<version>\bin\kicad-cli.exe, thenPATH - Linux —
/usr/bin/kicad-cli,/usr/local/bin/kicad-cli, thenPATH - macOS —
/Applications/KiCad/KiCad.app/Contents/MacOS/kicad-cli, thenPATH
If your install is somewhere unusual, or you want to change where files are written, copy config.ini.example to config.ini next to the executable and fill in what you need:
[paths]
kicad_cli = /opt/kicad/bin/kicad-cli
output_dir = /home/you/schematics
libs_root = /home/you/mcp-kicad-libs
[api_keys]
mouser =
digikey_client_id =
digikey_client_secret =
The API keys are optional and buy metadata only — no distributor serves CAD files. Every source that actually carries symbols and footprints needs no key.
Generated files default to <your home>/mcp-kicad/output.
Tools
Thirty-five tools are exposed. In practice Claude drives almost everything through compile_schematic, compile_pcb and export_fabrication; the rest exist for inspection and for repairing an existing file.
Designing
compile_schematic · design_guide · get_design_context · kicad_workflow_help · apply_template · list_templates
Finding parts
find_part · import_part · check_component_existence · symbol_pins · list_symbol_libraries · register_library
Reading a schematic
read_schematic · get_connectivity_summary · cluster_components · layout_metrics
Editing by hand
create_schematic · add_symbol · connect_pins · disconnect_pin · add_wire · add_label · add_power_rail · junction · no_connect · connect_netlist · batch_schematic
Boards
compile_pcb · export_fabrication · modify_pcb_layout
Checking and exporting
validate_design (ERC/DRC) · export_schematic_image (SVG/PDF)
Setup
get_project_info · get_output_dir · set_output_dir
Parts KiCad doesn't have
KiCad ships around 22 700 symbols. The one you need is often not among them.
find_part searches every source at once and import_part installs a
candidate:
find_part query="ESP32-C3-MINI-1"
import_part ref="espressif:symbols/Espressif.kicad_sym#ESP32-C3-MINI-1"
→ MCP_Imported:ESP32-C3-MINI-1 53 pins, footprint matched, ready for compile_schematic
| Source | What it carries | Licence |
|---|---|---|
| installed | this machine's KiCad libraries and everything already imported | — |
| jlcpcb | JLCPCB's assembly catalogue: symbol + footprint + 3D model, all matched | MIT |
| cern | CERN Open Hardware: symbols for thousands of real part numbers | CERN-OHL-P-2.0 |
| digikey-lib | Digi-Key's library, 150 category libraries | per repository |
| espressif | Espressif's own ESP32 library | per repository |
| sparkfun | SparkFun breakouts, sensors and connectors | CC-SA-4.0 |
| lcsc | LCSC / EasyEDA, converted to KiCad — the long tail, by C-number | third-party data |
| mouser, digikey | identification only: the real MPN, manufacturer, package and datasheet behind an order code. No CAD files — no distributor serves them. Needs an API key | — |
Each source is indexed once into libs/cache/ and searched offline from then
on. Nothing is installed until it has been verified:
- it parses,
kicad-clireads it back and rewrites it,- it places in a scratch schematic with its pins resolved,
- its pins are compared against the footprint's pads,
- KiCad draws it, and you get the picture.
A part that fails is not installed at all. A half-imported symbol is worse than no symbol, because it looks like it works. And if a part exists in no source, the answer is that it does not exist — never a substitute chosen quietly, never geometry drawn from imagination.
Everything lands in one library, MCP_Imported, registered with KiCad so the
GUI's symbol chooser sees it too. Each imported symbol carries an MCP_Source
property recording where it came from, under what licence and when — which is
why libs/ is not versioned: it is reproducible from the sources.
How it works
.design.json → compile → .kicad_sch
- Place. Every symbol's position is derived from a pin anchor, resolved to absolute coordinates on the 2.54 mm grid.
- Wire. Short, obviously-correct connections are drawn with closed-form geometry; longer ones go to an A* router that avoids component bodies.
- Power. One power symbol per pin, offset in the direction the pin points, then aligned into rails.
- Gate. Every wire is re-examined. Anything that crosses another net, cuts through a symbol or overlaps collinearly is deleted and replaced by net labels — connectivity is preserved, the lie is not.
- Tidy. Reference and value text is moved off bodies and wires; the sheet is centred and the paper size upgraded if the circuit doesn't fit.
- Verify. The file is re-read from scratch, its netlist traced and compared against the source, and
kicad-cliruns ERC.
.kicad_sch → compile_pcb → .kicad_pcb
- Netlist. Exported by
kicad-cli, the same data Update PCB from Schematic uses. - Place. Schematic positions seed the board at several scales; parts are legalised without overlap, rotated to shorten the wiring, decoupling capacitors put at their IC's power pin and connectors on the edge.
- Route. A two-layer grid router written for this project from published algorithms (A* with bend costs, PathFinder negotiated congestion, then a rip-up-and-improve pass), with no code from other routers. Its copper is measured exactly against every other net before it is handed back.
- Verify. KiCad rewrites the file, fills the ground plane and runs DRC with schematic parity. A variant that fails is replaced by the next best: plane with thermal reliefs, plane with solid joints, no plane, unrouted.
KiCad files are read and written through a real S-expression parser (internal/sexp) — never by pattern-matching on text.
Known limitations
- Text can still overlap on dense sheets. Reference designators and net labels are moved to the lowest-overlap position available, but on a crowded schematic the best available spot sometimes still touches something. The compiler reports exactly what is left over and how much extra spacing would clear each one.
- Some connections become labels instead of wires. This is the gate doing its job. Electrically identical, less pretty.
- PNG previews need a Chromium-family browser (Edge, Chrome, Chromium or Brave). Without one, a lower-quality pure-Go renderer is used instead. Only the Windows path is verified in practice.
- Boards are two-layer or single-sided, from a grid router. On a single-sided board the number of wire jumpers depends on where the parts sit; moving a few by hand in KiCad and routing again usually removes some. It routes every board in the reference corpus, at 45°; it is not a replacement for hand layout on high-speed, RF or high-voltage work. Where the ground plane cannot give a pad two thermal spokes, it joins it solidly and says which pad.
- Placement starts from the schematic. A tidy schematic gives a tidy board; parts the schematic puts far apart start far apart.
- Tested with Claude Desktop and Claude Code. Other MCP clients should work but haven't been tried.
Development
go build -o mcp-kicad ./cmd/server # build
go test ./... # all tests
go run ./cmd/verify_e2e # end-to-end smoke test
go run ./cmd/compile -o out.kicad_sch docs/compiler/led_18650.design.json
go run ./cmd/measure_layout out.kicad_sch # layout quality metrics
go run ./cmd/pininfo <library.kicad_sym> # pin positions in a symbol library
go run ./cmd/compile_pcb -widths "+12V=1" out.kicad_sch # place and route a board
go run ./cmd/export_fab out.kicad_pcb # Gerbers, drill, BOM, pick-and-place
# The component sources are claims about the outside world. `go test ./...`
# never touches the network; these re-measure them on demand.
MCP_KICAD_LIVE=1 go test ./internal/parts/providers/ -run TestLive -v
MCP_KICAD_LIVE=1 go test ./internal/tools/ -run TestLiveImportAndCompile -v
The thirteen sources in docs/compiler/ are the reference corpus — every change to the pipeline is checked against all of them, as schematics and as boards.
License
PolyForm Noncommercial License 1.0.0 — free to use, modify and share for any noncommercial purpose, including personal projects, hobby electronics, education, research and nonprofit organisations. Commercial use is not granted by this license.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
mcp-creator-python
Freeby mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.
