嘉立创 EDA AI Agent

This is a local AI automation framework for 嘉立创 EDA Professional. The MCP layer holds no project state; only the Python Broker keeps WebSocket connections and pending requests in-process. When the service stops, the connections, requests, and temporary images all disappear.

Architecture

MCP Client / AI Agent
        |
        | Streamable HTTP: POST /mcp
        v
Stateless MCP tools
        |
        | in-process call
        v
In-memory asyncio Broker
        |
        | JSON over WebSocket: /ws
        v
JLCEDA TypeScript Extension
        |
        v
JLCEDA Extension API (eda.*)

Screenshots are not passed over WebSocket as Base64. The Extension uploads a Blob via POST /upload/image and returns a temporary /files/{id} URL to the MCP caller. Images expire after 5 minutes by default, and are deleted immediately when the service exits.

Directory

mcp_server/
  main.py                 # 独立服务入口
  application.py          # HTTP、WebSocket、MCP ASGI 组合
  mcp_api/                # 无状态 MCP 工具定义
  broker/                 # 唯一有状态组件（仅内存）
  protocol/               # WebSocket JSON 协议
  files/                  # 临时图片存储
  tests/

lc_extension/
  src/main.ts
  src/websocket/          # 注册、心跳、RPC 响应、重连
  src/commands/           # schematic、PCB、DRC、capture
  src/utils/
  extension.json
  build/dist/             # npm run build 生成 .eext

Starting the Backend

The project already has its dependencies installed using mcp_server/.venv:

cd mcp_server
source .venv/bin/activate
python main.py

Default addresses:

• MCP: http://127.0.0.1:8000/mcp

• Extension WebSocket: ws://127.0.0.1:8000/ws

• Health check: http://127.0.0.1:8000/health

• Image upload: http://127.0.0.1:8000/upload/image

Auto-Configure MCP Client

After the backend is started, you can run the installation script to automatically scan the MCP Clients installed on this machine and write the jlceda-ai-agent service into the corresponding global configuration file:

cd mcp_server
python install.py --install

The script supports Claude Desktop/Code, Cursor, Windsurf, Codex, Cline, Roo Code, Kilo Code, VS Code, Gemini CLI, OpenCode, Kimi Code, Zed, and other common Clients. It only processes the Clients it detects, and does not overwrite other MCP services already in the configuration; files whose JSON or TOML cannot be parsed are skipped.

python install.py --list                         # 查看支持项及扫描结果
python install.py --install codex,cursor         # 指定 Client
python install.py --url http://127.0.0.1:9000/mcp
python install.py --dry-run                      # 只预览
python install.py --uninstall                    # 从检测到的 Client 中移除

After writing the configuration, the corresponding MCP Client must be fully restarted. The installation script only handles the Client configuration; the backend service still needs to be started separately as described in the next section.

Available environment variables:

Build and Install the Extension

cd lc_extension
npm install
npm run typecheck
npm run build

Generated files:

lc_extension/build/dist/jlceda-ai-agent_v0.1.0.eext

In 嘉立创 EDA Professional V3, install it via “Advanced → Extension Manager → Import”. After installing, you must enable "Allow external interaction" for the extension; otherwise the official SYS_WebSocket and SYS_ClientUrl APIs will reject the WebSocket connection and image uploads.

The Extension uses the current project's UUID as project_id, and also provides the project name through list_projects. After switching projects, the next heartbeat will automatically re-register. Therefore the AI should first call list_projects and then place the returned project_id into each subsequent EDA tool call.

If the backend address changes, update it accordingly:

lc_extension/src/config.ts

MCP Tools

Projects and libraries:

• list_projects、project.get_info

• component.search

Schematic reading and inspection:

• schematic.get_info、schematic.get_netlist、schematic.run_drc

Schematic components and cleanup:

• schematic.place_component、schematic.add_component

• schematic.modify_component、schematic.delete_components

• schematic.delete_wires、schematic.modify_wire、schematic.clear

• schematic.set_pin_no_connect

Schematic nets and wiring:

• schematic.create_net_flag、schematic.create_net_port

• schematic.create_net_label、schematic.connect_net

• schematic.create_wire、schematic.connect

• schematic.auto_layout、schematic.auto_route

PCB:

• pcb.get_info、pcb.place_component、pcb.modify_component、pcb.delete_components

• pcb.create_track、pcb.modify_track、pcb.create_board_outline

• pcb.create_via、pcb.modify_via、pcb.delete_routing_primitives

• pcb.clear_routing、pcb.route_net、pcb.auto_route、pcb.auto_layout

• pcb.run_drc

Screenshots:

• capture.schematic、capture.pcb、capture.region

The recommended AI part-selection flow is: first call component.search and read each candidate's name, description, symbol, footprint, 3D model, extended attributes, and library_uuid/device_uuid; after the AI makes its selection, pass these two UUIDs to schematic.place_component for exact placement. Search results are returned page by page (20 by default, up to 100 per page); when has_more is true, the AI can request the next page, avoiding a large number of candidates flooding the model context. schematic.add_component remains the compatible shortcut for "search and place the first result".

For cross-sheet schematic connections, prefer schematic.connect_net. It places net flags, ports, or labels of the same net directly onto the target pins, so there are no accidental short circuits from crossing wires. When real wires are needed, use waypoints on schematic.connect or points on schematic.create_wire to explicitly specify an orthogonal path; by default, crossings with wires on other nets are checked and rejected with WIRE_CROSSING. This protection is skipped only when the caller explicitly passes allow_crossings=true.

schematic.clear removes the placed components, net flags, and wires on the current sheet, but keeps frame/title-block primitives that have no pins, no reference designators, and no nets. For targeted cleanup, use schematic.delete_components or schematic.delete_wires instead.

pcb.route_net invokes 嘉立创's single-net autorouter; pcb.auto_route supports net allowlists, exclusion lists, and speed/completion-rate strategies. Both the schematic and PCB DRC use the detailed result mode. Some 嘉立创 APIs are still marked as Beta; after upgrading the EDA, re-run the TypeScript type checks and do a regression on a real device.

Verification

cd mcp_server
.venv/bin/python -m pytest -q

cd ../lc_extension
npm audit --audit-level=moderate
npm run typecheck
npm run build

Current automated verification includes protocol validation, Broker RPC round trips, capability checks, HTTP image upload/read, and the official type check and .eext packaging for the Extension.

Design Boundaries

• No Redis, SQLite, or any other database is used.

• MCP tools hold no WebSocket, project, or EDA state.

• The Broker only stores online connections, heartbeat times, and pending requests.

• The Extension does not know about MCP; it only handles Broker JSON RPC.

• No AI conversations or PCB/schematic data is stored.

• Images exist only in the system temporary directory and are cleaned up by TTL.

嘉立创 official reference: Getting started with the Extension API、Invoking the Extension API、SYS_WebSocket。