Server data from the Official MCP Registry
Drive a live Altium Designer session: schematic, PCB and library tools. KiCad and EasyEDA too.
About
Drive a live Altium Designer session: schematic, PCB and library tools. KiCad and EasyEDA too.
Security Report
eda-agent is an MCP server that bridges an AI assistant to a live Altium Designer session via a DelphiScript polling loop and local file IPC, and its requested permissions (filesystem for workspace/logs, local HTTP dashboard on 127.0.0.1, subprocess/UI automation via Win32, env vars for config) broadly match its stated EDA purpose. The visible code shows no exfiltration, hardcoded credentials, or obfuscation; the main concerns are the broad GUI/UI-automation capabilities (app_menu, app_drive_dialogs with a modal-bypass path) and the unauthenticated local dashboard with server-side yield/takeover endpoints, which deserve user awareness rather than indicating malicious intent. The truncated source means some modules (dashboard, UI driver, bridge) could not be fully reviewed. Supply chain analysis found 18 known vulnerabilities in dependencies (1 critical, 14 high severity). Package verification found 1 issue.
3 files analyzed · 25 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
What You'll Need
Set these up before or after installing:
Environment variable: EDA_AGENT_BACKEND
Environment variable: EDA_AGENT_TOOLSET
How to Install
Add this to your MCP configuration file:
{
"mcpServers": {
"eda-agent": {
"command": "uvx",
"args": [
"eda-agent==0.8.1"
],
"env": {
"EDA_AGENT_BACKEND": "your-eda-agent-backend-here",
"EDA_AGENT_TOOLSET": "your-eda-agent-toolset-here"
}
}
}
}Some servers take additional arguments. See the repository for details.
Documentation
View on GitHubFrom the project's GitHub README.
eda-agent
MCP server that lets an AI (or any MCP-compatible client) interact with a live Altium Designer session, with KiCad and EasyEDA Pro available as additional backends. It exposes around 600 tools on Altium, covering schematic, PCB, library, project, and design-agent operations, over a persistent DelphiScript bridge. The AI reads the design you currently have open, asks questions about it, and can modify it in place while you watch. The backend is selected at startup, so each user sees only their own tool set.
⚠️ Experimental. Not all tools are extensively tested. Some can crash the Altium DelphiScript engine. See Known limitations before using on any design you haven't backed up.
Demo
Claude Code with eda-agent designs a round 54 mm, 4-layer RGB LED display board in Altium Designer from a written spec to manufacturing files. It builds a project library from scratch, with a symbol, footprint, 3D model and part numbers for every part. It then draws the schematic, places 61 LEDs in rings, routes the USB pair at 90 ohms, pours stitched ground, gets DRC clean and writes the Gerbers, drill, BOM, pick-and-place and STEP files. A correction round follows: a review prompt lists issues from the first pass, and Claude reroutes the whole USB pair as a coupled differential pair, gives every part a realistic 3D model from its datasheet drawing and finishes the schematics with title blocks. The result would still get a manual tweaking pass before prototyping, but it is already at a very good stage.
Claude Code with eda-agent draws a 12 V to 3.3 V, 2 A step-down supply around the TI TPS62130 in Altium Designer from one sentence. It fetches the datasheet, sizes the inductor, capacitors and feedback divider from it, builds the symbols, draws the schematic and verifies the netlist.
Support the project
Developing eda-agent and testing it against Altium's scripting engine takes a significant amount of work. If you find eda-agent useful in your work, sponsorship keeps it free and maintained. Questions and bug reports get an answer whether you sponsor or not.
Sponsors
Professional and Company sponsors appear here with their logo, and Backer and Big thanks sponsors by name. Be the first: github.com/sponsors/salitronic.
Dashboard
Two dashboards ship with eda-agent:
- In-Altium status window - a floating Altium-side window showing live status, request count, cumulative Altium-side time, auto-shutdown countdown, and a per-command log with durations.
Hide pingsfilters the 30 s keep-alive traffic;Slow onlyisolates slow calls. The Config tab (right) sets what the AI may do: edit designs, delete, close documents, and drive menus and dialogs, plus view options. Changes apply live. The Detach button exits the polling loop cleanly; it saves nothing, so unsaved edits stay in the editor. - Web dashboard - a local browser dashboard at
http://127.0.0.1:8766, focused on design review. A Review tab surfaces datasheet / MPN / manufacturer / footprint coverage gauges and an actionable issue queue (missing datasheet, missing MPN, orphan nets, ...); Project, Components, Nets, Libraries and Plan tabs give live structured views. Click any component or net to drill into a detail drawer; one click cross-probes it into Altium. Light / dark theme, server-sent-events live feed. It is auto-started by the MCP server - the Open Dashboard button on the in-Altium status window launches the browser.
How it works
- Altium Designer stays open and in full control of your design
- A DelphiScript polling loop runs inside Altium's scripting engine
eda-agent(Python, launched by your MCP client) sends commands via file-based IPC- Altium executes, writes a response, and returns to polling
- You see the changes happen live in Altium
This is not a batch tool that opens a project, runs a script, and exits. It's a live connection for as long as you want it (conversational design review, guided refactoring, ad-hoc BOM queries, "what nets does this resistor connect to?"), all on the project you currently have open.
Features
- ~600 tools on the default Altium backend (600+ with both registered) across application, project, library, schematic/general, PCB, and design-agent categories
- Generic primitives (
obj_query,obj_modify,obj_create,obj_delete,obj_run_process) that work on almost any schematic or PCB object type via late-binding, avoiding per-type handler proliferation (obj_createmakes schematic objects only). On a board, a filter on an exactNet=,Component=,Layer=orBoundsLeft/BoundsBottomgoes straight to its objects; any other condition is checked on every object of the type - Every tool takes a list: give nearly any tool
items, a list of its own arguments, and up to 200 items are one call, one request to Altium and one undo step (pcb_place_arc(items=[...])places twenty arcs that one Undo takes back; in a PcbLib each pad is its own undo step). The reply gives each item's result in order. Some tools take their list directly:pcb_place_tracks,pcb_place_vias,pcb_place_arcs,pcb_place_pads,pcb_move_components,sch_place_wires,sch_place_components,sch_set_components_parameters,lib_add_pins,proj_get_connectivity_many,sim_attach_primitives.obj_modifywithitemssends one request, but each item is its own search and edit. Typical wall-time savings: 10 to 100x on multi-item edits - Design review snapshot:
design_review_snapshotbundles 8 to 12 review reads (project info, components, nets, rules, diff, messages, stats, unrouted, BOM) into a single call. One LLM turn instead of a dozen - Design-lint sweep:
design_lint_reportruns 31 audit checks in one IPC pass and returns a structured violation list - schematic-side (component-parameter visibility per class, power-port orientation, floating ports, multi-output / no-driver nets, duplicate designators, off-grid components) and PCB-side (DNP variant components, tented-via ratio, near-miss track endpoints, signal vias without nearby return via, via antennas, removed pad shapes, components outside outline, pads too close to board edge, invalid polygon regions, optional DRC). Each check is also reachable on its own asaudit(kind=...); the dashboard's Status → Health subtab has a one-click Lint panel that calls/api/lintand groups results by Schematic / PCB - Canonical circuit blocks:
design_add_circuit_blockfolds a whole block into aDesignPlanin one call, allocating refdes, wiring every pin to the right net and tagging power / ground and roles. Twelve of them:decoupling,pullup,pulldown,series_resistor,voltage_divider,rc_lowpass,rc_highpass,led_indicator,crystal,pi_filter,mosfet_low_side,mosfet_high_side. Naming-agnostic: you supply the part identities, it owns only the wiring pattern.design_list_circuit_blocksreturns each one's parameter contract, so the planner never guesses a parameter name - Datasheet-first discipline: every component-surfacing response (
pcb_get_components,proj_get_bom,proj_get_component_info_many,proj_find_component,lib_search,design_review_snapshot,sim_get_readiness) carries a_datasheet_guidanceblock with per-part vendor search queries.app_attach/app_pingcarry a_system_reminderon their first call and every 10th after it (EDA_AGENT_REMINDER_EVERYsets the interval), so every MCP client that connects sees the rule at session start and again later. LLM-fabricated datasheet values are forbidden; WebFetch/WebSearch are called out by name - Sch <-> PCB netlist crossref:
obj_crossref_net(net_name)compares the schematic pin list against the PCB pad list for the same net. Catches ECO drift, stale post-fabrication routing, phantom nets from port/sheet-entry rename conflicts.in_syncflag +sch_only/pcb_onlydiff - SPICE simulation workflow:
sim_get_readinessaudits every component and partitions into ready / needs-primitive / needs-file.sim_attach_primitivessets SpicePrefix + Value on passives.sim_attach_modellinks a vendor.mdl/.ckt.sim_rundispatches the simulator. Built-in guardrail: never fabricate a SPICE model file, fetch the vendor one - Focus-independent PCB access: every PCB handler falls back to
GetPCBBoardByPathwhenGetCurrentPCBBoardreturns nil (user has a sch tab focused). No more misleading "No PCB document is active" when the PCB is right there - Persistent and compile-cached: one polling loop stays loaded, so a call does not start a script each time.
SmartCompilecachesDM_Compilewith a 2 s TTL so a multi-read review pays for one compile instead of a dozen. Explicitproj_force_recompile+proj_get_compile_freshnessprobes for cases that need a guaranteed-fresh netlist (e.g. after user edits) - Editor and project settings, read back: board grids and the sheet's electrical grid, board and schematic editor preferences, auto-save, and project options (net identifier scope, output path, pin swapping). Every value written is read back, and one that did not take is reported in
not_applied - Rigid-flex and route clean-up: split a board into layer stack regions, give each region its own stack (a flex stack with fewer copper layers), add and edit bend lines with radius, angle and fold order, and run Altium's Gloss or Retrace on chosen nets with the track count and length reported before and after
- Layer stack manager: the whole physical stack with Z heights and finished thickness, dielectric and solder mask settings (Dk, Df, thickness, stiffener), layers inserted above or below a chosen layer, impedance profiles created and set per layer, and each via's protection structure and back drilling
- Board output and editor settings: the Gerber and print setup saved in a board, Testpoint Style rules, the coarse visible grid factor and each grid's unit, what pasting keeps and the paste array, confirmations, auto-pan and netlist-load behaviour, display fonts and colours, more schematic preferences, a pad's drill type, and sheet reference zones for every part, label and port
- Net colour highlighting: give board nets a colour and draw them in it, or copy each net's project (schematic) colour onto the board so both highlight alike
- Annotation runs silently:
proj_annotatedesignates components without popping the annotate dialog - Drives the GUI where there is no API: a great deal of Altium exists only as menus and dialogs.
app_menuclicks through the real menu bar by name (and lists what a menu holds, so paths are discovered rather than guessed);app_list_open_dialogsreports what is on screen, what it says and whether Altium is stuck;app_uisets checkboxes, fields, dropdowns and grid rows;app_press_dialog_buttonpresses one button;app_drive_dialogsanswers a whole sequence reactively. None of it uses the bridge, only Win32 and the accessible layer, so it keeps working while a modal has the scripting engine blocked, which is exactly when you need it.app_menuwithhow="drive"fires a menu command and answers its dialogs in the same call, because a command that opens a modal blocks the bridge and a second call would never arrive. The driver decides from what is on screen rather than from a script, stops on any dialog it cannot classify, and gates the press that changes the design behindallow_commit. Dialog text that Altium paints into handle-less controls is recovered by OCR and labelled as read from pixels, not text - Deferred save for speed: mutations mark documents as modified in memory; disk writes happen on explicit
app_save_all, andapp_detachsaves the documents that were edited. A clean document is never rewritten, and edits are not slowed by a save each - Two dashboards: an in-Altium floating status window (status, request count, per-command performance, command log, Detach button) and a browser-based web dashboard (
127.0.0.1:8766) for design review - datasheet / MPN / footprint coverage gauges, an actionable issue queue, component / net drill-in, one-click cross-probe into Altium, light / dark theme. The whole project view loads in one bundled IPC round-trip (project.dashboard_snapshot); the web dashboard auto-starts with the MCP server - DelphiScript trap linter:
scripts/altium/lint.py(wired intobuild.py) scans the Pascal sources for known parser hazards -Cardinal()casts, malformed hex literals, empty.Add('')arguments, braces inside comments, fixed-size arrays as function locals, reserved-word identifiers - and fails the build before a bad deploy - Activity logs: every command is appended to
workspace/activity.log(one CSV line per command: timestamp, duration, command name, status, response size and the full response). The bridge also writesbridge_trace.logfor IPC-level diagnostics - Bulk-tool nudge: when a singular tool is hit 2 to 3 times in 10 s, the response carries a
_hint_bulkfield pointing at the batch variant. Clients that missed the bulk tool in the docstring learn about it at runtime - Design agent surface: MCP tools (
design_get_discipline,design_snapshot_inventory,design_validate_plan,design_audit_schematic,design_validate) that let an MCP-client LLM produce a structuredDesignPlanJSON, audit the drawn sheet for layout problems, and validate ERC + connectivity. Datasheet-first, NDA-isolated by construction - Schematics drawn from a hand template: the LLM plans the sheet the way an engineer draws it, every coordinate on the grid (rails as straight wires, capacitors hanging to ground, a divider whose midpoint runs straight to its pin), writing wires through pin anchors such as
U1.EN.sch_preview_templatechecks the template and draws it to a PNG without touching the sheet;sch_draw_templateplaces the parts, reads their pins back, checks the wiring against those pins and the plan's nets, refuses a short or a misplaced part before the first wire, then draws the wires, power ports and labels and stamps the part data. On EasyEDA,easyeda_emit_templateandeasyeda_emit_template_connectionsdo the same in two passes - Atomic-parts contract: every existing-status Part must carry
mpn,footprint,datasheet_url; the inventory snapshot exposes those fields per component;design_validateemitsatomic_partswarnings when the contract is missed. Aligns with the KiCad Atomic / Digi-Key Library / atopile / JITX convention - Schematic audit:
design_audit_schematicreturns structured{overlaps, wire_crossings, stacked_ports}for the active schematic - pairs of components whose bboxes intersect, wire segments crossing a non-endpoint component body (real Pascal-sideVertex.*+BoundingRectangle.*accessors), and clusters of 3+ rail glyphs of the same net. Each violation carries enough geometry for the planner to compute a corrective move. Programmatic feedback loop without needing a visual snapshot - Health and doctor preflight:
eda-agent health(offline checks: workspace dir, pointer file, bundled scripts) andeda-agent doctor(full preflight talking to Altium: process running, script polling responsive, version match, a read-only command canary, optional--librarylib-path checks).--jsonfor machine-readable output - pip-installable: no admin, no installer, no touching Altium's config
Requirements
- Python 3.11+
- An EDA tool, one of:
- Altium Designer (recent versions, AD20+ preferred) - Windows only
- KiCad 10 with its API enabled (Preferences → Plugins → Enable KiCad API) and the board open in the PCB editor; nothing extra to install
- EasyEDA Pro with the bundled extension installed (see
extensions/easyeda/README.md)
The server picks a backend at startup (EDA_AGENT_BACKEND, default altium), so one install drives any of them. See EDA backends.
Installation
From PyPI, into an environment of its own so its dependencies never clash with your other Python tools:
pipx install eda-agent
or uv tool install eda-agent with uv. Either puts the eda-agent command on your PATH (run pipx ensurepath once if pipx says it is not). Without pipx or uv, plain pip works too:
python -m pip install eda-agent
That installs tagged releases. To run the latest commits on main instead, install from GitHub (no clone needed):
pipx install "git+https://github.com/salitronic/eda-agent"
or python -m pip install "git+https://github.com/salitronic/eda-agent".
Each copy looks for updates where it came from and, when there are some, says the command that upgrades it: pipx upgrade eda-agent, uv tool upgrade eda-agent, or python -m pip install --upgrade with the same source. A clone you install yourself is for working on eda-agent; see Development.
Two optional parts are compiled, and come as ready-built wheels (no Rust needed): eda-agent[route] makes the board router's path search several times faster, and eda-agent[render3d] adds the path tracer for pcb_render_3d. Without them the same tools run on numpy and scipy.
With pip, use python -m pip rather than a bare pip. It works even when pip's Scripts folder is not on your PATH, which is common when Python was installed for you by IT, and it guarantees the package goes into the same Python you will run it with.
Register the server with your MCP client. The binary is eda-agent and runs on stdio; consult your client's docs for how to add a local stdio-based server. For a pip install, everywhere this README says eda-agent, python -m eda_agent does exactly the same thing and does not depend on PATH. A pipx or uv install has its own Python, so use eda-agent there.
Claude Code
claude mcp add altium eda-agent
Adds eda-agent as an MCP server named altium to your Claude Code project config. Use -s user to register it at the user level (available across every project):
claude mcp add -s user altium eda-agent
If eda-agent isn't on your PATH ("'eda-agent' is not recognized") after a pip install, register it through Python instead. This needs no path at all:
claude mcp add -s user altium -- python -m eda_agent
The -- matters: it tells claude mcp add that everything after it is the command to run, rather than options for claude itself.
To verify the connection: /mcp in a Claude Code session should list altium as connected.
Other MCP clients
The server speaks standard MCP over stdio; any client that accepts a local stdio command will work. Invoke eda-agent (or eda-agent serve) as the subprocess, or python -m eda_agent if it is not on your PATH.
Altium-side scripts
Drop the Altium script project somewhere you can find it:
eda-agent install-scripts
or, if eda-agent is not recognised:
python -m eda_agent install-scripts
Default destination: wherever Altium already loads the script project from (its Global Projects list, for every Altium version installed), or %USERPROFILE%\EDA Agent\scripts\ the first time. Use --dest PATH to put it elsewhere; Altium still talks to the same workspace either way. eda-agent health reports a registration that points at a missing file.
Register the script as a Global Project in Altium (once):
- Preferences (the gear icon at the top right; DXP → Preferences before AD18) → Scripting System → Global Projects → Install from file
- Select the
Altium_API.PrjScryou just installed
From then on, every Altium startup compiles the script project and the polling loop is one click away:
- File → Run Script...
- Expand
Altium_API→Dispatcher.pas, select StartMCPServer, click Run
The polling loop starts and your MCP client can drive Altium.
Updating
For as long as it runs, the server looks once an hour, in the background, whether this repository has new commits; the look is a cheap check that the branch has moved, and a full check follows only when it has. When there are new commits, the next tool reply says so and lists them, app_ping and app_context repeat it, and the assistant asks you before installing anything. A check that fails is reported once too. A copy installed with pip from this repository compares the commit it was installed from with the latest one; any other pip install compares its version with the one here. Either says how to upgrade. If you agree, for a clone, server_update(apply=True) fast-forwards it, reinstalls when the dependencies changed, copies the Altium scripts again when they changed and restarts the polling loop. Then reconnect the server (/mcp in Claude Code) to run the new Python. From a terminal, the same thing is:
eda-agent update # shows what is new, then asks
eda-agent update --check # only shows what is new
A clone with uncommitted changes, commits of its own or another branch checked out is never touched; the update says why and stops. Set EDA_AGENT_UPDATE_CHECK=0 to stop the background check from reaching the network.
EDA backends
One tool surface, chosen at startup by EDA_AGENT_BACKEND (or --backend).
| Backend | Reached through | Status |
|---|---|---|
altium | a persistent DelphiScript bridge | default, most complete |
kicad | KiCad's IPC API and kicad-cli | optional |
easyeda | a browser extension you import into EasyEDA Pro | optional |
Altium Designer is the tool this project is built around, and it needs
your own licensed install; the other two backends serve people who work in
those editors. None is offered in place of another. A design can be
exchanged with KiCad in both directions (proj_import_from_kicad,
proj_convert_to_kicad), for handing it to someone who works in the other
tool or for review.
The EasyEDA connection runs the other way round: the editor dials out to this server, so nothing here can start it or make it connect.
Full detail, including what differs between them and what each one
cannot do, is in docs/BACKENDS.md.
Finding the right tool
Tools are grouped by the document they act on, and mixing them up is the
most common mistake: lib_ acts on a .PcbLib or .SchLib, pcb_ on an open
.PcbDoc, sch_ on an open .SchDoc, and obj_ on either, by the object
type it is given (eTrackObject acts on the active board). A board tool aimed at a
library does not reliably fail. With no board focused it can resolve some other
open board and report success for work you never asked for.
Two tools answer different questions about the surface:
tool_catalog- search by name, category, maturity or interaction. Use it when you know roughly what the operation is called.tool_guide- ask in plain words what you are trying to do. It answers the tool and what it needs first, the tool you were probably reaching for and why it acts on a different document, and the short list of things that are genuinely impossible with the reason.
That last answer is the one worth knowing about. Without it there is no way to
tell "you missed it" from "it does not exist", so the same dead ends get
investigated repeatedly. An empty result from tool_guide means the guide has
nothing on the subject, not that the server cannot do it.
The same split is stated in the server instructions your MCP client receives at startup, so a client that reads them starts out knowing it.
Tool count (clients that cap it)
Some MCP clients limit how many tools a server may expose, or serialize every
schema into the model context at startup and slow noticeably. This server
registers several hundred. Set EDA_AGENT_TOOLSET=minimal (or pass
--toolset minimal) to advertise just two:
tool_catalog- find an operation by category, maturity, interaction or name, and get its parameters withwith_schema=True.tool_invoke- run any tool by name with an arguments dict.
Every other tool stays registered and reachable through that pair; only the advertised list shrinks, from several hundred to two.
claude mcp add -s user altium -e EDA_AGENT_TOOLSET=minimal eda-agent
Only families of tools that differ by a mode are advertised as one tool each:
the calculators (pcb_calc), the audits (audit), the dimension and 3D body
kinds, the menu runners, the dialog drivers and the checkpoints. Each takes a
kind and that kind's arguments. Every member keeps its own name,
description and schema; tool_catalog returns its summary line and schema,
and tool_invoke runs it.
Everything else keeps a tool of its own; collapsing whole areas into
pcb(action=...) style entry points would lose the per-tool descriptions a
model finds the right operation by.
The trade-off: in minimal the model no longer sees
tool schemas up front, so it must discover before it can act, and an argument
mistake surfaces as the target tool's own error rather than a schema
validation message. Call tool_catalog(query=..., with_schema=True) to get a
tool's parameters and required list before invoking it, rather than guessing
argument names - some are not what they look like (current_amps, not
current_a), and the same tool can differ between backends. Prefer full
(the default) unless your client forces otherwise.
Part sourcing
part_search queries every enabled provider and merges the results, each
hit attributed to the source that found it; part_fetch then pulls one
part's detail from a provider you name. No provider is enabled by
default, and there is no fallback order, so a result always names its
source.
The providers, their credentials and their access policies are in
docs/PART_SOURCING.md.
Altium 365, company policies, simulators
Altium 365. The altium365_ tools read workspaces, projects and the
managed library, and can publish, release and change parameters (only with
confirm=True). Two routes: the workspace's own API, with
EDA_AGENT_ALTIUM365_DOMAIN and a token made under Admin > Developer in
EDA_AGENT_ALTIUM365_TOKEN; or Nexar, with your Nexar app's client id in
EDA_AGENT_NEXAR_APP_ID, its secret in EDA_AGENT_NEXAR_CLIENT_SECRET (a
Nexar portal app refuses a sign-in without it) and eda-agent altium365-login
once (eda-agent altium365-logout forgets it).
EDA_AGENT_ALTIUM365_WORKSPACES limits the tools to the workspaces it
lists. Nothing Altium 365 returns is written to disk.
altium365_check_setup says which route is set up.
The Nexar route runs under your own Nexar app, so
Nexar's API terms are yours to keep: among
them, what the API returns is not to be kept for more than 24 hours, which
includes copies your AI client saves in a conversation, and the app's key
is never to be published.
Company policies are your files in EDA_AGENT_POLICY_DIR: a
naming.json (a template and pattern per footprint, symbol and
component) for lib_check_naming and lib_make_name, and rules files in
rules/*.json for design_check_company_rules. With none set, nothing is
imposed.
Simulators. design_simulate_deck runs a deck in ngspice when it is
installed, or in LTspice when you ask for it or it is the only one
installed. design_simulators lists what is installed.
Example use cases
Full-project design review
"Do a design review of the PoE front-end. Pull the snapshot, fetch the TPS2372 and TL072 datasheets, and flag anything that doesn't match."
One design_review_snapshot call gives the AI project info, design stats, components, nets, rules, diff, messages, board stats, and BOM, plus a datasheet-fetch checklist. The AI then grounds every recommendation in the vendor datasheets it actually pulled. 8 to 12 separate queries collapse into one tool call.
Schematic review
The AI reads your schematic live. Ask it anything a reviewer would:
"List every component connected to the 3V3 rail and flag anything whose datasheet limit is below that."
"Find all net labels that appear only once across the whole project. Those are probably typos."
"What's driving the /RESET net? Walk the connectivity and tell me where it resets and how."
"Do any two components share a designator prefix with gaps in numbering (e.g. R1, R2, R4)? Re-annotate or tell me what's missing."
"Compare the focused schematic to the version from 3 weeks ago. What parameter values changed?"
Behind that, the AI calls tools like obj_query(object_type="eSchComponent", scope="project"), proj_get_connectivity_many(designators=[...]), proj_get_nets(...), obj_modify(...), and so on. You watch Altium repaint as it works.
Sch ↔ PCB drift detection
"Run
obj_crossref_neton POE_PG. The PCB seems to have R7 on this net but I'm not sure the schematic still does."
The response shows sch pins, PCB pads, matched count, and the diff in each direction. A non-empty pcb_only list means the board was fabricated from an earlier schematic revision and a later edit broke the post-ECO merge; catch this before the next ECO push rips routed connections. in_sync: false plus the exact diff tells you which port or sheet-entry rename to undo.
SPICE simulation setup
"Set this schematic up for an AC sweep. Attach SPICE primitives to every passive, fetch vendor SPICE models for the op-amps, and tell me if any part can't be simulated."
sim_get_readiness partitions the design into ready / needs_primitive / needs_file. The AI batches primitives onto every passive in one sim_attach_primitives call, searches vendor sites for the IC models, attaches them with sim_attach_model, and reports any holdouts. It will not fabricate a SPICE model file; the rule is baked into the tool response.
Library hygiene
"Open
Resistors.SchLiband report every component missing a Value, ManufacturerPart1, or Description parameter. Fill in the missing Description from the datasheet URL if present.""Diff our
Caps.SchLibagainstCaps_vendor.SchLiband tell me what's new or changed.""Create a new 48-pin symbol for STM32F411 with this pinout table."
The last one uses lib_add_pins: one call places the whole pinout in a single transaction instead of 48 LLM turns.
PCB spot-checks
"Any unrouted nets on the board?"
"What's the total trace length for the USB differential pair, split by layer?"
"Show me all vias on the 12V net and their drill sizes."
"Run DRC and summarize the violations by severity."
"What does the
Clearance_HVrule actually enforce: clearance value, scope expressions, priority?"
That last one uses pcb_get_rule_properties, which returns the actual numeric gap / widths / impedance targets, not just rule metadata.
Bulk changes
"Every 0402 resistor with value 10k, set its Tolerance parameter to 1% and Voltage to 50V."
"Rename the net OLD_CS to SPI_CS across every sheet in the project."
"Move C1-C20 into this 200-mil grid layout pattern."
A list given to pcb_move_components or sch_place_components (or as items to most other tools) finishes the whole operation in one call and one undo step. obj_modify with items is one call, but each item is its own search and its own edit.
Known limitations
This tool is experimental. Please read this section before using on a design you haven't backed up.
Bridge changes are checked by Free Pascal and a linter before they ship, which cannot prove Altium's own DelphiScript engine accepts them: the two differ on which identifiers exist, and an undeclared one faults at runtime rather than at compile time.
docs/RELEASE_VERIFICATION.mdis the procedure for closing that gap on a release, starting with a self-test that runs inside Altium and needs no document.
UI automation synthesises real keyboard and mouse input
Most of this project talks to Altium through the scripting bridge, which addresses a window handle directly and cannot affect anything else. The app_* UI automation tools are different, and are used where Altium offers no other route: application.execute_menu reports success while invoking nothing, GetMenu returns 0 on Altium's DevExpress bars, and whole dialogs (Update From Libraries, Preferences, the wizards) have no scripting API at all.
Synthesised input is not addressed to a window. keybd_event and mouse_event are delivered to whatever is active at the instant they fire, and a click lands on whatever is under the pointer. So these tools:
- take focus. Menus and clicks need Altium in front, so running them while you are typing will interrupt you
- cannot be confirmed the way a property write can. A keystroke has no read-back; anything that matters is verified afterwards with a bridge read
- could, without containment, deliver an event to another application if focus or the pointer moved
What contains that: a foreground check runs immediately before every event, including between a key press and its release, and refocuses Altium rather than failing; coordinates are refused unless the point is over a window belonging to Altium's own process; and no tool accepts a window handle from the caller, so an arbitrary window cannot be addressed. tests/test_foreground_guard.py enforces all three, checking the event guard per line of source rather than per function, because a function that checks once and then emits five events in a loop would pass a naive test while firing four unchecked events.
To switch it off entirely:
EDA_AGENT_UI_AUTOMATION=0
Every synthesised event is then refused. Reading stays available on purpose, because dialog detection is how the rest of the system notices Altium is blocked on a modal.
One case is not solvable: Altium's menu bar carries entries that are commands rather than menus (Place a Comment, Share, Open Home page, Preferences), and nothing distinguishes them. Measured across all 17 bar items: identical MSAA state including HASPOPUP, identical accDefaultAction, identical UIA control type. Listing such an entry clicks it, and clicking it runs it.
Full detail in docs/ui-automation.md.
Altium DelphiScript engine can crash
Some tool paths trigger DelphiScript compile or runtime errors ("Undeclared identifier…", "Could not convert variant of type (Dispatch) into type (OleStr)", etc.). When that happens, the script project halts mid-execution and the polling loop stops responding. You will see one of:
- An Altium error dialog stating the problem
- Your MCP client timing out waiting for a response
Recovery is automatic when the crash happens during a call. The server takes a screenshot of the error box, presses OK, takes a screenshot of the halted line, stops the script and restarts the loop. Other sessions' calls wait while it does. The call that crashed fails with a message saying the script crashed and where the screenshots and a crash record are (logs/crashes in the workspace). The handler may have applied part of its change, so read the design back before repeating it. For a script found halted some other way, call app_recover_script, or run eda-agent relaunch --restart.
By hand: in Altium Designer, open the script project tab and press the red Stop button in the Script IDE toolbar (equivalently Run > Stop from the menu, or Ctrl+F3; use Ctrl+Pause/Break if the script is stuck in an infinite loop). This stops the halted debugger. Then re-launch the polling loop via File > Run Script... > StartMCPServer > Run.
This is an ongoing reliability effort. Every identified crash is either fixed or guarded. If you hit a new one, the Altium error dialog tells you the exact identifier or line. Opening an issue with that text helps us harden the relevant path.
UNC network paths need current scripts
A UNC path (\\server\team\board.PrjPcb) opens like any other with the current scripts. Scripts deployed before the fix drop one leading backslash, so the file is not found and the error names a path that looks almost right. Run eda-agent install-scripts --force to update them, or use a mapped drive letter (Z:\team\board.PrjPcb) in the meantime.
A few Altium fields hold only Latin-1 text
Requests reach Altium as UTF-8, so the ohm sign and CJK text arrive intact (10Ω stays 10Ω). A few of Altium's own stores keep one byte per character whatever is sent: an embedded data record's description (pcb_embedded_data) refuses characters above U+00FF rather than storing ?.
Altium tool buttons relying on internal scripting pause while the server is running
Altium itself uses DelphiScript internally for many built-in commands (some ribbon buttons, panel actions, menu items). While the eda-agent polling loop is active, those built-in commands may become temporarily unresponsive because Altium's scripting engine is single-threaded and currently owned by our polling loop.
The polling loop owns the scripting engine for as long as it's running. While it runs, Altium's own script-backed buttons sit waiting. The loop exits when either:
- The MCP client calls
app_detach(or the dashboard Detach button is clicked);app_detachsaves the edited documents (the button saves nothing), the loop exits within ~500 ms, and Altium becomes fully responsive, OR - 10 minutes of total silence from the MCP client (no commands AND no keep-alive pings) triggers the built-in auto-shutdown
In practice, while an MCP client is attached and sending keep-alive pings every 30 s, the loop will never time out on its own; you need to either have the AI call app_detach or close the MCP client session entirely. After the client disconnects, expect up to ~10 minutes for the loop to auto-exit unless you use Detach to release it immediately.
ECO (sch → PCB update) opens a modal, and there is no silent API
Documentation truncated — see the full README on GitHub.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Git
Freeby Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.


