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.
Configuration
View docs{
"mcpServers": {
"mixelpixx-kicad-mcp-server": {
"command": "node",
"args": [
"/path/to/KiCAD-MCP-Server/dist/index.js"
],
"env": {
"LOG_LEVEL": "info",
"PYTHONPATH": "/path/to/kicad/python"
}
}
}
}You can run a KiCAD MCP Server to securely connect your KiCAD workspace with AI assistants, enabling natural language control of PCB design tasks. This server exposes a rich set of tools, real-time project state access, and flexible deployment options to automate schematic and board workflows while keeping AI context efficient.
You interact with the KiCAD MCP Server through a client that supports the MCP interface. Start by launching the local server, then configure your client to connect using the provided stdio channel. Once connected, you can ask the AI to create projects, place components, route nets, load schematics, generate outputs, or inspect current project state. The system uses a router to discover and execute the most appropriate tools for your task, minimizing context while preserving full functionality.
Prerequisites you need on your machine include KiCAD 9.0 or higher, Node.js 18 or higher, and Python 3.10 or higher. You will also interact with Python dependencies and a local MCP client.
# Linux (Ubuntu/Debian) example
sudo add-apt-repository --yes ppa:kicad/kicad-9.0-releases
sudo apt-get update
sudo apt-get install -y kicad kicad-libraries
# Node.js
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
# Install the MCP server locally
git clone https://github.com/mixelpixx/KiCAD-MCP-Server.git
cd KiCAD-MCP-Server
npm install
pip3 install -r requirements.txt
npm run build
# Verify KiCAD Python bindings are accessible
python3 -c "import pcbnew; print(pcbnew.GetBuildVersion())"After building, you run the MCP server as a local stdio endpoint. You configure your MCP client to connect to the local node process, which communicates with KiCAD via the Python backend.
{
"mcpServers": {
"kicad": {
"type": "stdio",
"name": "kicad",
"command": "node",
"args": ["/path/to/KiCAD-MCP-Server/dist/index.js"],
"env": {
"PYTHONPATH": "/path/to/kicad/python",
"LOG_LEVEL": "info"
}
}
}
}Initialize a new KiCAD project and set up the initial PCB and schematic files.
Load an existing KiCAD project into the MCP session.
Save the current KiCAD project state to disk.
Retrieve metadata about the current project.
Configure the PCB dimensions for the board outline.
Create the board outline in the PCB layout.
Add a new board layer to the stack.
Switch the active working layer.
List all layers in the board stack.
Retrieve properties of the board, such as dimensions and layers.
Generate a 2D preview image of the board.
Place mounting holes at specified coordinates.
Add text annotations on the board.
Place a single component with its footprint.
Move an existing component to a new position.
Rotate a component by a given angle.
Remove a component from the board.
Modify component properties such as value or footprint.
Query details for a placed component.
List all components currently placed on the board.
Create a grid or pattern of components.
Align multiple components relative to each other.
Copy an existing component.
Create a new electrical net.
Route copper traces between pads.
Place vias for layer transitions.
Remove copper traces.
List all nets in the design.
Define a net class with specific rules.
Create copper pours or polygons.
Route a differential pair with specified spacing.
List available footprint libraries.
Search footprints by keywords or attributes.
List footprints within a library.
Get details about a footprint.
Download the local JLCPCB parts database (one-time setup).
Search the JLCPCB catalog with filters.
Get pricing and footprint details for a part.
View statistics about the local JLCPCB database.
Find cheaper or more available part alternatives.
Initialize a new schematic from a template.
Open an existing schematic file.
Place symbols with on-demand dynamic loading from KiCad libraries.
List symbol libraries available for schematics.
Export the schematic as a PDF.
Create wires between schematic points with customizable stroke.
Auto-connect schematic pins with intelligent routing.
Add net labels in the schematic with orientation control.
Connect component pins to named nets in the schematic.
Check whether KiCAD UI is running.
Launch the KiCAD user interface.
Configure Design Rule Check parameters.
Retrieve the current DRC settings.
Execute a Design Rule Check.
Retrieve DRC violations from the latest run.
Generate Gerber fabrication files.
Export documentation as PDF.
Export board as SVG vector graphics.
Generate 3D models (STEP/VRML) of the board.
Produce a bill of materials for the design.