MCP-KiCad

Design electronic schematics 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 — and hand you a .kicad_sch file you can open, edit and manufacture from.

Léeme en español

An LM2596 step-down converter. Nobody drew this by hand: it was compiled from a text description, and it passes ERC.

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, ready for PCB layout.

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:

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.

What it does not do

• No PCB work. No board layout, no copper routing, no Gerbers. Schematics only, on purpose — a PCB from a bad schematic is worthless.
• No component invention. It uses KiCad's installed symbol libraries, and find_part / import_part bring 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

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-arm64 from Option B instead.

Option B — download a binary

1. Go to Releases and download the file for your system:

   System	File
   Windows (Intel/AMD)	mcp-kicad-windows-amd64.exe
   Linux (Intel/AMD)	mcp-kicad-linux-amd64
   Linux (ARM, e.g. Raspberry Pi)	mcp-kicad-linux-arm64
   macOS (Apple Silicon)	mcp-kicad-darwin-arm64
   macOS (Intel)	mcp-kicad-darwin-amd64

2. Put it wherever you like — say C:\Tools\mcp-kicad.exe or ~/bin/mcp-kicad.

3. On Linux and macOS, make it executable:

   bash

   Copy

   chmod +x ~/bin/mcp-kicad
   

   On macOS the first run is blocked because the binary is unsigned. Allow it with:

   bash

   Copy

   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:

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, then PATH
• Linux — /usr/bin/kicad-cli, /usr/local/bin/kicad-cli, then PATH
• macOS — /Applications/KiCad/KiCad.app/Contents/MacOS/kicad-cli, then PATH

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 =