Altium MCP Server

TLDR: Use Claude to control or ask questions about your Altium project. This is a Model Context Protocol (MCP) server that provides an interface to interact with Altium Designer through Python. The server allows for querying and manipulation of PCB designs programmatically.

Note: Having Claude place components on the PCB currently fails hard.

Example commands

• Run all output jobs

• Create a symbol for the part in the attached datasheet and use the currently open symbol as a reference example.

• Create a schematic symbol from the attached MPM3650 switching regulator datasheet and make sure to strictly follow the symbol placement rules. (Note: Need to open a schematic library. Uses AppData\Roaming\Claude\Claude Extensions\local.dxt.altium-mcp\server\symbol_placement_rules.txt description as pin placement rules. Please modify for your own preferences.)

• Find me the LM358 symbol in my opamp library and open it

• Create a multi-part symbol for a quad op-amp from the attached LM324 datasheet (creates parts A, B, C, D with shared V+/V- power pins)

• Create a PCB footprint for the SMD part in the attached datasheet and add it to my open PcbLib

• Duplicate my selected layout. (Will prompt user to now select destination components. Supports Component, Track, Arc, Via, Polygon, & Region)

• Show all my inner layers. Show the top and bottom layer. Turn off solder paste.

• Get me all parts on my design made by Molex

• Give me the description and part number of U4

• Place the selected parts on my pcb with best practices for a switching regulator. Note: It tries, but does terrible placement. Hopefully I can find a way to improve this.

• Give me a list of all IC designators in my design

• Get me all length matching rules

Installing the MCP Server

The easiest way to install is to use Claude Code, point it to this repo and ask it to install it for you. Or alternatively, see below.

Watch on YouTube

1. Make sure Claude has Python 3.10+ installed: drop down > File > Settings > Extensions > Advanced > Python. If not, install Python and add it to PATH.

2. Download the altium-mcp.dxt desktop extension file from releases

3. In Claude Desktop on Windows: drop down > File > Settings > Extensions > Advanced > Install Extension... Select the .dxt file

You shouldn't need to restart Claude and you should now see altium-mcp in the tool menu near the search bar.

Creating a new .dxt (For Developers)

Bootstrap Venv (Recommended)

This approach ships a small bootstrap script (start_server.py) that creates a virtual environment and pip-installs dependencies on the user's machine at first launch. The .dxt is tiny (~60 KB) and works across any Python 3.10+ version.

The older approach of bundling pre-compiled packages in server/lib/ is no longer recommended — it breaks when the user's Python version doesn't match the version used to build the bundled .pyd files (e.g. pydantic_core compiled for 3.11 fails on 3.13).

How it works:

1. start_server.py (at the repo root) checks for server/.venv/Scripts/python.exe

2. If the venv doesn't exist, it creates one and pip-installs the pinned dependencies

3. It then launches server/main.py using the venv's Python

4. First launch takes ~20-30 seconds; subsequent launches are instant

Build steps:

1. Make sure start_server.py exists at the repo root (see below for contents)

2. Make sure server/main.py does NOT have the old site.addsitedir hack at the top

3. Update manifest.json: set entry_point to start_server.py, remove any env/PYTHONPATH fields, and use manifest_version: "0.3"

4. Package the DXT — either use dxt pack or manually zip and rename:

Compress-Archive -Path manifest.json, start_server.py, pyproject.toml, server -DestinationPath altium-mcp.zip
Rename-Item altium-mcp.zip altium-mcp.dxt

Do NOT include server/lib/ or server/.venv/ in the .dxt. The whole point is that these are created on the user's machine.

start_server.py:

import subprocess
import sys
from pathlib import Path

SCRIPT_DIR = Path(__file__).parent
VENV_DIR = SCRIPT_DIR / "server" / ".venv"
REQUIREMENTS = [
    "mcp[cli]==1.5.0",
    "pillow>=11.1.0",
    "pywin32>=310",
]

def ensure_venv():
    python_exe = VENV_DIR / "Scripts" / "python.exe"
    if python_exe.exists():
        return str(python_exe)

    subprocess.check_call([sys.executable, "-m", "venv", str(VENV_DIR)])
    pip_exe = str(VENV_DIR / "Scripts" / "pip.exe")
    subprocess.check_call([pip_exe, "install", "--quiet"] + REQUIREMENTS)
    return str(python_exe)

if __name__ == "__main__":
    venv_python = ensure_venv()
    server_path = str(SCRIPT_DIR / "server" / "main.py")
    sys.exit(subprocess.call([venv_python, server_path]))

manifest.json server section:

"server": {
    "type": "python",
    "entry_point": "start_server.py",
    "mcp_config": {
      "command": "python",
      "args": ["${__dirname}/start_server.py"]
    }
  }

Pitfalls

These are hard-won lessons from debugging DXT builds. Violating any of these will produce errors that are difficult to diagnose.

1. Do NOT use os.execv() in start_server.py. The DXT installs to a path containing spaces (Claude Extensions). On Windows, os.execv splits the path at the space and fails. Use sys.exit(subprocess.call([...])) instead.

2. Pin mcp to ==1.5.0. Using >=1.5.0 pulls in the latest version, which has breaking API changes (FastMCP.__init__() dropped the description kwarg). The server code was written against 1.5.0.

3. Do NOT use manifest_version: "0.4" with "type": "uv". Claude Desktop does not support it yet. You will get Invalid manifest: server: Required. Use "type": "python" with manifest_version: "0.3".

4. After removing the site.addsitedir hack from main.py, fix the pathlib.Path reference. The hack included import pathlib at the top of the file. The logging setup later uses pathlib.Path(...) which will throw NameError once that import is gone. Change it to Path(...) — the from pathlib import Path import already exists in the file, just make sure it comes before the logging setup.

5. Do NOT bundle server/lib/ in the DXT. That was the old approach and defeats the purpose of the venv bootstrap.

Legacy: Bundled server/lib (Not Recommended)

This approach bundles all dependencies in server/lib/ and sets PYTHONPATH to point to it. It produces a much larger .dxt (~17 MB) and only works if the user's Python version matches the version used to compile the bundled packages.

1. Populate packages: python -m pip install --no-cache-dir --target server/lib -r requirements.txt

2. Set the manifest entry_point to server/main.py and add "env": {"PYTHONPATH": "${__dirname}/server/lib"} to mcp_config

3. Package: npm install -g @anthropic-ai/dxt && dxt pack

DXT Resources

• Desktop Extensions

• Desktop Extensions Github

• Getting Started with DXT

• Python DXT Example Code

• DXT Manifest

Configuration

When launching claude for the first time, the server will automatically try to locate your Altium Designer installation. It will search for all directories that start with C:\Program Files\Altium\AD* and use the one with the largest revision number. If it cannot find any, you will be prompted to select the Altium executable (X2.EXE) manually when you first run the server. Altium's DelphiScript scripting is used to create an API between the mcp server and Altium.

Available Tools

The server provides several tools to interact with Altium Designer:

Output Jobs

• get_output_job_containers: Using currently open .OutJob file, reads all available output containers

• run_output_jobs: Pass a list of output job container names from the currently open .OutJob to run any number of them. .OutJob must be the currently focused document.

Component Information

• get_all_designators: Get a list of all component designators in the current board

• get_all_component_property_names: Get a list of all available component property names

• get_component_property_values: Get the values of a specific property for all components

• get_component_data: Get detailed data for specific components by designator

• get_component_pins: Get pin information for specified components

Schematic/Symbol

• get_schematic_data: Get schematic data for specified components

• create_schematic_symbol (YouTube): Passes pin list with pin type & coordinates to Altium script. Supports multi-part symbols (e.g. quad op-amps) via a part_count parameter and an owner_part_id field on each pin (use 0 for shared power/GND pins). Also supports active-low pin name overbars by placing a backslash after each overbarred character (e.g. R\E\S\E\T\ renders as RESET with overbar).

• get_symbol_placement_rules: Create symbol's helper tool that reads ~\AppData\Roaming\Claude\Claude Extensions\local.dxt.altium-mcp\server\symbol_placement_rules.txt to get pin placement rules for symbol creation.

• get_library_symbol_reference: Create symbol's helper tool to use an open library symbol as an example to create the symbol

• search_library_symbol: Search for a symbol by name in a schematic library (.SchLib) and navigate to it. Supports partial name matching. Will open the library file in Altium if a path is provided, or show a file picker if not.

Layout Operations

• get_all_nets: Returns a list of unique nets from the pcb

• create_net_class (YouTube): Create a net class from a list of nets

• get_pcb_layers: Get detailed layer information including electrical, mechanical, layer pairs, etc.

• get_pcb_layer_stackup: Gets stackup info like dielectric, layer thickness, etc.

• set_pcb_layer_visibility (YouTube): Turn on or off any group of layers. For example turn on inner layers. Turn off silk.

• get_pcb_rules: Gets the rule descriptions for all pcb rules in layout.

• get_selected_components_coordinates: Get position and rotation information for currently selected components

• move_components: Move specified components by X and Y offsets

• layout_duplicator (YouTube): Starts layout duplication assuming you have already selected the source components on the PCB.

• layout_duplicator_apply: Action #2 of layout_duplicator. Agent will use part info automatically to predict the match between source and destination components, then will send those matches to the place script.

The cool thing about layout duplication this way as opposed to with Altium's built in layout replication, is that the exact components don't have to match because the LLM can look through the descriptions and understand which components match and which don't have a match. That's something that can't really be hard coded.

PCB Footprint Library

• create_pcb_footprint: Create a new PCB footprint in the currently active .PcbLib document. Supports SMD pads (Rect, Round, Oval shapes) defined in mm relative to the component origin. Auto-generates a courtyard on Mech 15 and silkscreen with a pin 1 indicator (gap in the top-left corner), or accepts explicit courtyard dimensions. Contributed by coffeedust (PR #7).

Both

• get_screenshot: Take a screenshot of the Altium PCB window or Schematic Window that is the current view. It should auto focus either of these if it is open but a different document type is focused. Note: Claude is not very good at analyzing images like circuits or layout screenshots. ChatGPT is very good at it, but they haven't released MCP yet, so this functionality will be more useful in the future.

Server Status

• get_server_status: Check the status of the MCP server, including paths to Altium and script files

How It Works

The server communicates with Altium Designer using a scripting bridge:

1. It writes command requests to workspace\request.json

2. It launches Altium with instructions to run the Altium_API.PrjScr script

3. The script processes the request and writes results to workspace\response.json

4. The server reads and returns the response

References

• Get scripts' project path from Jeff Collins and William Kitchen's stripped down version

• BlenderMCP: I got inspired by hearing about MCP being used in Blender and used it as a reference. https://github.com/ahujasid/blender-mcp

• Used CopyDesignatorsToMechLayerPair script by Petar Perisin and Randy Clemmons for reference on how to .Replicate objects (used in layout duplicator)

• Petar Perisin's Select Bad Connections Script: For understanding how to walk pcb primitives (track, arc, via, etc) connected to a pad

• Matija Markovic and Petar Perisin Distribute Script: For understanding how to properly let the GUI know when I've updated tracks' nets

• Petar Perisin's Room from Poly: Used as reference to detect poly to pad overlap since I couldn't get more tradition methods to work.

• Petar Perisin's Layer Panel Script: Used as reference for getting layers and changing layer visibility

• Jeff Collins has an XIA_Release_Manager.pas script that taught me the art of the Output Job. See his post on the Altium Forums: https://forum.live.altium.com/#/posts/189423

Contributors

• coffeedust — create_pcb_footprint tool for PcbLib automation (PR #7)

• fwolter — Fix JSON parsing error when the decimal separator is a comma (PR #3)

Disclaimer

This is a third-party integration and not made by Altium. Made by coffeenmusic

TODO:

• Change selection filter:

  • scripts-libraries\Scripts - PCB\FilterObjects\

  • scripts-libraries\Scripts - SCH\SelectionFilter\

• Show/Hide Panels: DXP/ReportPCBViews.pas

• Create rules: PCB/CreateRules.pas

• Run DRC: IPCB_Board.RunBatchDesignRuleCheck(

• Move cursor to position: IPCB_Board.XCursor, IPCB_Board.YCursor

• Add get schematic & pcb library path for footprint.

• Add get symbol from library

• log response time of each tool

• Add go to schematic sheet

• Go to sheet with component designator

• Board.ChooseLocation(x, y, 'Test');

• Zoom to selected objects:

• Change Schematic Selection Filter: SelectionFilter.pas

• Place schematic objects (place component from library): PlaceSchObjects.pas

• How can I read through components from libraries in Components panel?

TODO Tests: Need to add the following test units

• get_pcb_layers

• set_pcb_layer_visibility

• layout_duplicator

• get_pcb_screenshot