# KiCAD-MCP-Server: Driving KiCad 9 from Claude and Other MCP Clients

> KiCAD-MCP-Server exposes KiCad's schematic, routing and export work to an MCP client over a Python and TypeScript bridge. It is a practical fit for hobby and small-team boards, and the README itself warns that AI-generated designs still need engineering review.

**mixelpixx/KiCAD-MCP-Server** — KiCAD MCP is a Model Context Protocol (MCP) implementation that enables Large Language Models (LLMs) like Claude to directly interact with KiCAD for printed circuit board design.

- Repository: https://github.com/mixelpixx/KiCAD-MCP-Server
- Stars: 2,523 · Forks: 347
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/mixelpixx-kicad-mcp-server

## The gap KiCAD-MCP-Server fills between a chat window and a board file

KiCad is a GUI application. Its scripting surface exists, but reaching it from an AI assistant means writing glue code that speaks both the assistant's protocol and KiCad's Python API. This project is that glue, packaged as a Model Context Protocol server. The README describes it as a server that "enables AI assistants like Claude to interact with KiCAD for PCB design automation," built against the MCP 2025-06-18 specification.

The intended user is someone who already knows what a schematic and a footprint are. The README lists project setup, schematic editing, component placement, routing, DRC and ERC runs, and export among the things the server can do today. It also covers custom symbol and footprint generation for modules that are not in the standard KiCad library, and personal library management so a part created once can be reused across projects. That is a maintenance chore more than a design decision, and it is the strongest reason to look at the project.

Two integrations round out the list: a JLCPCB parts catalog with pricing and stock data, and Freerouting for automatic routing through Java or Docker. Neither is a substitute for knowing your stackup and your current return paths.

## How the MCP server, the Python bridge and KiCad actually talk

The repository is a two-language system, and the split is visible in the top-level layout: a src/ directory for TypeScript, a python/ directory, and a package.json whose main entry is dist/index.js. The TypeScript side is the MCP server itself. It depends on @modelcontextprotocol/sdk, express, zod and dotenv, and `npm run build` compiles it with tsc into dist/.

The Python side holds the KiCad-facing work. requirements.txt lists kicad-python for the IPC and real-time UI sync path, sexpdata for S-expression parsing "used by the MCP runtime," and kicad-skip for schematic manipulation. Pillow, pymupdf and cairosvg handle rendering: the comment in requirements.txt explains that pymupdf ships binary wheels on Windows, macOS and Linux, so a stock pip install always has a working SVG-to-PNG converter, with cairosvg as the second choice because its native cairo runtime cannot be assumed on Windows. That is a deliberate packaging decision, not an accident.

Credentials are handled separately from tool calls. The .env.example file states that the Digi-Key tools read DIGIKEY_CLIENT_ID and DIGIKEY_CLIENT_SECRET and nothing else, and that "credentials are never accepted as tool arguments, so they cannot end up in a chat transcript, a saved workflow, or a log line." JLCPCB works the same way, with the added note that without credentials, get_jlcpcb_part falls back to a local snapshot database populated by download_jlcpcb_database, and that search is always local. The repository also carries download_jlcpcb.py at the top level, consistent with that snapshot workflow.

## Installing KiCAD-MCP-Server and getting one real tool call through

The README's quick start has three prerequisites: KiCad 9.0 or newer, Node.js 18+, and Python 3.11+. Note that pyproject.toml declares requires-python >=3.9 while the README asks for 3.11+, a small inconsistency worth resolving in favor of the README if you hit import errors.

Clone the repository, install the Node dependencies and build the TypeScript server:

```bash
git clone https://github.com/mixelpixx/KiCAD-MCP-Server.git
cd KiCAD-MCP-Server
npm install
npm run build
```

The build runs tsc and writes dist/index.js, which is the file the MCP client launches. Then install the Python dependencies, since the KiCad-facing handlers live there:

```bash
pip install -r requirements.txt
```

For VS Code with GitHub Copilot, the README says to copy config/vscode-mcp.example.json to .vscode/mcp.json, which VS Code auto-detects. For Claude Desktop the config file lives at %APPDATA%\Claude\claude_desktop_config.json on Windows and ~/.config/claude/claude_desktop_config.json on macOS and Linux, with example files in config/windows-config.example.json and config/macos-config.example.json. The README points to docs/PLATFORM_GUIDE.md for the full setup and does not reproduce the JSON inline, so read that file rather than guessing at the shape.

If you want live JLCPCB lookups, copy the environment template and fill it in. The file itself says .env is gitignored and must never hold committed credentials:

```bash
cp .env.example .env
```

Once the client is configured, the docs to read before your first session are docs/TOOL_INVENTORY.md for the full tool list and docs/ROUTER_QUICK_START.md for routing. There is also a docs:tools script that regenerates the tool inventory from source, and a docs:tools:check variant that verifies it is current, which is a reasonable way to confirm the inventory matches the build you just made.

## Where KiCAD-MCP-Server stops being the right tool

The README carries a disclaimer that is unusually direct for a project page, and it should shape how you use the server. It states that the project is provided without warranty, and that the authors accept no liability for errors in generated schematics, PCB layouts or manufacturing files, for damage to hardware or components caused by incorrect designs, for financial losses from manufacturing errors or incorrect orders, or for data loss and corruption of KiCad project files.

The same disclaimer says AI-generated design suggestions do not replace qualified engineering review, and that safety-critical applications in medical, aerospace and automotive work require mandatory independent expert verification. Treat that as the project's own statement of where it is the wrong tool, not as boilerplate. A board that will be fabricated in quantity, or that carries mains voltage, or that will fly, is not a place to accept generated output on trust.

There is a second boundary. The README announces Konnect, described as this project rebuilt from scratch in Rust as a native KiCad 10 plugin, a single binary with no runtime dependencies, built on KiCad's official IPC API instead of SWIG, with 171 tools, bundled Claude skills and agents, design-review audits and a manufacturing pipeline. The README says Konnect is where new development happens and that it is licensed AGPL-3.0, free for individuals and open source with commercial licences available for businesses. The Python and TypeScript server described here "remains fully open (MIT) and maintained," but if you are starting fresh on KiCad 10 and want the actively developed line, the README is pointing you elsewhere. The last push to this repository was on 2026-09-10, so it is not abandoned, but the maintainer's own framing matters when you weigh where to invest.

The README also does not document rollback, undo semantics, or how to revert a project after a bad tool call. For a tool that writes into KiCad project files, that silence is the practical risk: keep the project under version control before you let a client drive it.

## KiCAD-MCP-Server against writing your own pcbnew script

The obvious alternative is skipping MCP entirely and writing Python against KiCad's own scripting interface. The difference is in who does the reasoning. A pcbnew script executes the steps you already decided on: you name the footprint, the position, the net. KiCAD-MCP-Server inverts that, putting a language model between your description and the API call, which is why the README can advertise "Design PCBs with natural language" and why it ships tool schemas and real-time project state access for the model to read.

That inversion is the whole value and the whole cost. You gain the ability to say what you want and let the client work out the calls, and you gain integrations that would otherwise be a separate scripting project, such as the JLCPCB catalog with pricing and stock, and Freerouting driven through Java or Docker. You lose determinism. A script produces the same board every run; a model-driven tool call does not, and the README's own disclaimer about generated schematics and layouts is the acknowledgement of that.

There is a middle position worth naming. Because the Python handlers live in a normal package with pytest configured and a tests/ directory, and because the tool inventory can be regenerated and checked from source, you can read the handler for a given tool and decide whether you trust it before you let a client call it. That is more work than either extreme, and for a small board it is probably the right amount.

## Licence, maintenance and the cost of keeping up

The project is MIT licensed, and package.json confirms "license": "MIT" for the npm package kicad-mcp. MIT is permissive: you can use, modify and redistribute the code, including in commercial work, provided the licence and copyright notice are preserved. The README's disclaimer notes that the MIT licence likewise excludes all liability. None of this is legal advice; if you are shipping a product that embeds the server, have your own counsel read the LICENSE file rather than this paragraph.

One version detail is worth flagging before you file a bug. package.json declares version 2.7.0, matching the most recent release, while pyproject.toml declares version 2.4.0 for the Python package kicad-mcp-server, and requires-python >=3.9 against the README's Python 3.11+. The two halves of the repository are versioned separately, so quote the component and the version when you report anything.

Upgrade cost is dominated by the KiCad dependency. The README requires KiCad 9.0 or newer, and the announcement of Konnect targets KiCad 10. If your KiCad install moves ahead of what the Python bindings support, the KiCad-facing handlers are where you will feel it. The repository does carry a CHANGELOG.md and releases at a steady cadence through 2026, so tracking what changed between versions is feasible; the work is in re-verifying your own boards after an upgrade, not in the upgrade itself.

## Conclusion

Adopt KiCAD-MCP-Server if you already run KiCad 9 and want an MCP client to handle repetitive placement, symbol and footprint creation, or export steps on non-critical boards, and you are willing to read the tool inventory before trusting any generated output. Do not adopt it for safety-critical work: the README states that medical, aerospace and automotive designs require mandatory independent expert verification, and the disclaimer excludes liability for errors in generated schematics, layouts or manufacturing files. Before wiring it into a project you care about, confirm that your KiCad version is 9.0 or newer, that Python 3.11+ and Node.js 18+ are present, and that the JLCPCB or Digi-Key credentials you intend to use are set in .env rather than passed as tool arguments.

## FAQ

### How do I install KiCAD-MCP-Server?

Install KiCad 9.0 or newer, Node.js 18+ and Python 3.11+, then clone the repository and run npm install followed by npm run build. Install the Python side with pip install -r requirements.txt, then point your MCP client at the built dist/index.js using the example configs in the config/ directory.

### How do I open an MCP server?

You do not open it directly. The MCP client launches the server process, so you register it in the client's config file, such as .vscode/mcp.json for VS Code or claude_desktop_config.json for Claude Desktop, using the examples in the config/ directory. The README points to docs/PLATFORM_GUIDE.md for the full setup.

### Does KiCad have AI?

KiCad itself does not, but KiCAD-MCP-Server is a Model Context Protocol server that lets AI assistants interact with KiCad for PCB design automation, built on the MCP 2025-06-18 specification. It works with Claude Desktop, Claude Code, VS Code and any MCP client.

### Can Claude do KiCad?

Through this server, yes, within limits. The README lists project setup, schematic editing, component placement, routing, DRC and ERC, and export among the supported operations, but it also states that AI-generated design suggestions do not replace qualified engineering review and that safety-critical applications require independent expert verification.

## Sources

- [Issues](https://github.com/mixelpixx/KiCAD-MCP-Server/issues)
- [License: MIT](https://github.com/mixelpixx/KiCAD-MCP-Server/blob/main/LICENSE)
- [mixelpixx/KiCAD-MCP-Server on GitHub](https://github.com/mixelpixx/KiCAD-MCP-Server)
- [README](https://github.com/mixelpixx/KiCAD-MCP-Server/blob/main/README.md)
- [Releases](https://github.com/mixelpixx/KiCAD-MCP-Server/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mixelpixx-kicad-mcp-server