Altium MCP Unified

A unified Model Context Protocol (MCP) server for Altium Designer that intelligently routes between live API interaction and file-based operations.

Overview

This project provides a seamless bridge between Claude Desktop and Altium Designer, supporting two operational modes:

• Live Mode: When Altium Designer is running, interact directly with the application through Python-based tools
• File Mode: When Altium Designer is closed, read and analyze design files using a Rust-based parser

Architecture

The unified architecture uses a smart dispatcher that automatically detects the availability of Altium Designer and routes requests accordingly:

altium-mcp-unified/
├── manifest.json          # MCP manifest for Claude Desktop
├── server/
│   ├── main.py            # MCP entry point + tool registry
│   ├── router.py          # Live vs file mode detection
│   ├── live/              # Python tools for live Altium interaction
│   │   ├── board.py
│   │   ├── layout.py
│   │   ├── schematic.py
│   │   └── output_jobs.py
│   ├── file/
│   │   └── bridge.py      # Calls Rust binary, parses JSON responses
│   └── workspace/         # Request/response JSON (Altium bridge)
├── rust-core/             # Rust binary for file parsing
└── scripts/               # Altium DelphiScript bridge

Features

• Intelligent Mode Switching: Automatically detects whether Altium Designer is running
• Live API Access: Direct interaction with open Altium projects via Python
• File-Based Analysis: Parse and analyze Altium files without opening the application
• Unified Interface: Single MCP server for both operational modes

Implementation Status

This project is under active development. Planned implementation phases:

1. Foundation: Core routing and dispatcher implementation
2. Bridge Layer: Rust binary integration for file operations
3. Live Layer: Python tool integration for live Altium interaction
4. Integration: End-to-end testing and validation

Requirements

• Python 3.8+
• Altium Designer (for live mode operations)
• Rust toolchain (for building the file parser)
• Claude Desktop with MCP support

Installation

# Clone the repository
git clone https://github.com/10x-engineering/altium-mcp-unified.git
cd altium-mcp-unified

# Install Python dependencies
pip install -r requirements.txt

# Build the Rust parser
cd rust-core
cargo build --release
cd ..

Configuration

Add the MCP server to your Claude Desktop configuration:

{
  "mcpServers": {
    "altium-unified": {
      "command": "python",
      "args": ["path/to/altium-mcp-unified/server/main.py"]
    }
  }
}

Usage

Once configured, the MCP server will automatically route your requests based on Altium Designer's availability:

• Ask Claude to analyze schematics, layouts, or board designs
• Request component information, net connectivity, or design rule checks
• Export design data or generate reports

The server handles the complexity of determining whether to use live API calls or file-based parsing.

Contributing

Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.

License

[License information to be added]

Related Projects

• coffeenmusic's Altium Python tools
• embedded-society's Altium file parser

Credits

This unified architecture combines the best of both worlds:

• Live API interaction inspired by coffeenmusic's Python tools
• File parsing capabilities from embedded-society's Rust implementation