嘉立创 EDA Agent

Dieses lokale KI-Automatisierungsframework richtet sich an die Professional Version von 嘉立创 EDA. Die MCP-Schicht hält keinen Projektzustand; nur der Python-Broker speichert WebSocket-Verbindungen und ausstehende Anfragen prozessintern. Nach dem Stoppen des Dienstes verschwinden Verbindungen, Anfragen und temporäre Bilder.

Architektur

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 werden nicht als Base64 über WebSocket übertragen. Die Extension lädt den Blob über POST /upload/image hoch und stellt dem MCP-Aufrufer die temporäre URL /files/{id} zur Verfügung. Bilder verfallen standardmäßig nach 5 und werden beim Beenden des Dienstes sofort gelöscht.

Verzeichnis

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

Backend starten

Das Projekt ist bereits mit Abhängigkeiten aus mcp_server/.venv installiert:

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

Standardadressen:

• 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

• Bild-Upload: http://127.0.0.1:8000/upload/image

MCP-Client automatisch konfigurieren

Nach dem Starten des Backends kann das Installationsskript ausgeführt werden, um automatisch die lokal installierten MCP-Clients zu erfassen und den Dienst jlceda-ai-agent in die entsprechenden globalen Konfigurationsdateien einzutragen:

cd mcp_server
python install.py --install

Das Skript unterstützt gängige Clients wie Claude Desktop/Code, Cursor, Windsurf, Codex, Cline, Roo Code, Kilo Code, VS Code, Gemini CLI, OpenCode, Kimi Code, Zed. Handhabung nur erkannte Clients automatisch verarbeitet; es überschreibt keine anderen MCP-Dienste in der Konfiguration. Wenn Dateien mit JSON- oder TOML-Inhalt nicht analysiert werden können, werden sie übersprungen.

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 中移除

Nach dem Schreiben der Konfiguration muss der entsprechende MCP-Client vollständig neu gestartet werden. Das Installationsskript verwaltet ausschließlich die Client-Konfiguration; das Backend muss wie im nächsten Abschnitt beschrieben separat gestartet werden.

Verfügbare Umgebungsvariablen:

Extension erstellen und installieren

cd lc_extension
npm install
npm run typecheck
npm run build

Generierte Dateien:

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

Installieren Sie in 嘉立创 EDA Professional V3 über „Erweitert → Erweiterungsmanager → Importieren“. Nach der Installation muss für die Extension „Externe Interaktion erlauben“ aktiviert werden, sonst lehnen die offiziellen APIs SYS_WebSocket und SYS_ClientUrl WebSocket und Bild-Uploads ab.

Extension verwendet die UUID des aktuellen Projekts als project_id und stellt den Projektnamen in list_projects bereit. Nach einem Projektwechsel registriert sich die Extension beim nächsten Heartbeat automatisch neu. Die KI sollte daher zuerst list_projects aufrufen und die zurückgegebene project_id in jedem nachfolgenden EDA-Werkzeugaufruf verwenden.

Wenn sich die Backend-Adresse ändert, passen Sie bitte die entsprechenden Stellen an:

lc_extension/src/config.ts

MCP-Werkzeuge

Projekt- und Bibliotheksfunktionen:

• list_projects, project.get_info

• component.search

Schaltplan lesen und prüfen:

• schematic.get_info, schematic.get_netlist, schematic.run_drc

Schaltplan-Bauteile und Bereinigen:

• 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

Schaltplan-Netze und Verdrahtung:

• 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

Empfohlener Ablauf für die KI-Komponentenauswahl: Zuerst component.search aufrufen und für jeden Kandidaten Name, Beschreibung, Symbol, Footprint, 3D-Modell, erweiterte Attribute sowie library_uuid/device_uuid auslesen. Nach der Auswahl durch die KI werden diese beiden UUIDs an schematic.place_component übergeben, um die Auswahl exakt zu platzieren. Die Suchergebnisse werden seitenweise zurückgegeben (Standard 20, maximal 100 Einträge pro Seite). Wenn has_more den Wert true hat, kann die KI die nächste Seite anfordern, um nicht eine große Menge an Kandidaten in den Modellkontext zu laden. schematic.add_component bleibt als kompatibles Schnellwerkzeug für die Suche nach „Suche und platziere erstes Ergebnis“ erhalten.

Für übergreifende schematische Verbindungen über mehrere Bereiche sollte schematic.connect_net bevorzugt werden. Es platziert gleichnamige Netzmarkierungen, Ports oder Labels direkt auf den jeweiligen Ziel-Pins und erzeugt dadurch keine versehentlichen Brücken durch Leitungsüberkreuzungen. Zum Zeichnen tatsächlicher Leitungen können die waypoints von schematic.connect bzw. die points von schematic.create_wire verwendet werden, um orthogonale Wege explizit festzulegen. Standardmäßig wird die Kreuzung mit Leitungen eines anderen Netzwerks geprüft und gefährliche Vorgänge werden mit WIRE_CROSSING abgelehnt. Der Schutz wird nur übersprungen, wenn der Aufrufer explizit allow_crossings=true übergibt.

schematic.clear entfernt auf der aktuellen Schaltplanseite platzierte Bauteile, Netzwerkmarken und Leitungen, behält aber Rahmen-/Titelblock-Elemente ohne Pins, ohne Referenzbezeichnungen und ohne Netz. Für gezielte Klärung können schematic.delete_components oder schematic.delete_wires verwendet werden.

pcb.route_net ruft das Einzelnetz-Autorouting von 嘉立创 auf. pcb.auto_route unterstützt Netzwerk-Whitelist, Ausschlusslisten sowie Geschwindigkeits-/Verdrahtungsquoten-Strategie. Die DRC für Schaltplan und PCB verwenden den detaillierten Resultatsmodus. Einige 嘉立创-APIs sind weiterhin als Beta markiert. Nach einem EDA-Upgrade sollten ein TypeScript-Typcheck und ein realer Regressionstest erneut ausgeführt werden.

Verification

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

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

Die aktuellen automatischen Prüfungen aumfassen Protokollvalidierung, Broker-RPC-Roundtrip, Fähigkeitsprüfung, HTTP-Bild-Upload/Lesen sowie die offizielle Typprüfung der Extension und das Verpacken als .eext.

Design-Grenzen

• Es werden weder Redis, SQLite noch sonstige Datenbanken verwendet.

• MCP-Werkzeuge halten keine WebSocket-, Projekt- oder EDA-Zustände.

• Der Broker speichert nur Online-Verbindungen, Heartbeat-Zeit und ausstehende Anfragen.

• Die Extension kennt kein MCP; sie verarbeitet ausschließlich Broker-JSON-RPC.

• Es werden keine KI-Dialoge oder PCB-/Schaltpläne gespeichert.

• Bilder werden nur im temporären Systemverzeichnis gespeichert und nach Ablauf der TTL bereinigt.

Offizielle Referenz von 嘉立创: Einstieg in die Erweiterungs-API, Erweiterungs-API aufrufen, SYS_WebSocket.