Skip to content
Back to search

eplan-tools

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Canary-ECAD/eplan-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Canary-ECAD/eplan-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/canary-ecad--eplan-mcp/badge.svg)](/listings/canary-ecad--eplan-mcp)

HTML

<a href="/listings/canary-ecad--eplan-mcp"><img src="/api/listings/canary-ecad--eplan-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Local EPLAN automation (P8)

pip install pythonnet "mcp<2"
claude mcp add eplan -- python YOURPATH/eplan-p8-mcp-server/mcp_server/server.py
claude mcp list   # should list "eplan"

Then start EPLAN, open Claude Code, and say `connect to eplan`. The full guide is in [`eplan-p8-mcp-server/mcp_server/README.md`](eplan-p8-mcp-server/mcp_server/README.md).

Prerequisite

Remoting must be enabled in EPLAN before the server can connect: turn on **Allow remote access via Remote Client** under **File → Settings… → Workstation → Interfaces → Remote access**.

What the server exposes

In its default `full` mode the server publishes **199 tools**:

| Group | Count | What it covers | |---|---|---| | Connection / utility | 8 | Connect, version selection, status, extension listing | | Typed EPLAN actions (`eplan_*`) | 183 | One tool per documented or verified action, each executed silently inside a C# script under QuietMode, so no EPLAN dialog can block an unattended run | | Action catalog (`eplan_action_catalog` / `_describe` / `_run` / `_ribbon_catalog`) | 4 | Reaches a further ~1,050 actions that exist only as GUI buttons, mined from the install's `MFTools.xml` rather than the official docs | | Asset Administration Shell (`aas_*`) | 4 | AAS/AASX digital-twin export and import |

The ~1,050 catalog actions are deliberately *not* given one wrapper tool each: that would have tripled the tool count and degraded tool selection for everything else.

Among the 183 typed tools are four live-DataModel tools — `eplan_live_query_functions`, `eplan_live_query_pages`, `eplan_live_set_function_text` and `eplan_live_set_connection_designations` — which read and edit the open project's object model through runtime reflection, working around the script engine's limitation on static `using` directives.

Beyond individual actions, the toolset covers the building blocks of a fully unattended develop → deploy → test loop:

- **Application lifecycle** — `eplan_app_launch` / `eplan_app_shutdown` / `eplan_app_restart`: exit EPLAN, swap add-in DLLs, relaunch, reconnect, reopen the project. - **Disposable fixtures** — `eplan_scratch_project_*`: scratch projects cloned from a template. - **Diagnostics** — `eplan_get_system_messages`: read EPLAN's message tree and see the same errors and warnings the user sees in the GUI. - **Private extension modules** — see [below](#private-extension-modules-eplan_mcp_extensions).

A tool-by-tool reference, generated from this repository's docstrings, lives at [covaga.dev/docs/tools](https://covaga.dev/docs/tools/project-and-workspace-management/).

Discovery mode

`EPLAN_MCP_MODE=discovery` publishes 13 tools instead of 199, trading a token-heavy tool list for one extra search round-trip per task. It is worth it for MCP clients that send every tool's full schema on every request.

**Skip it in Claude Code.** Claude Code already defers tool schemas itself — a name list up front, a schema fetched on demand — so the `full` 199-tool list already costs it about as little as `discovery`'s 13 would, and layering discovery's search → describe → call indirection on top only adds a round-trip. The tradeoff and the measurements are in [`eplan-p8-mcp-server/mcp_server/README.md`](eplan-p8-mcp-server/mcp_server/README.md#discovery-mode-eplan_mcp_mode).

Remote documentation RAGs (P8, EEC Pro, 2027)

Already deployed and ready to use — no local data required:

# EPLAN Electric P8 documentation (2026, semantic search)
claude mcp add eplan-rag -- cmd /c npx mcp-remote https://rag2026.covaga.xyz/mcp

# EPLAN EEC Pro 2026 documentation
claude mcp add eecpro-rag -- cmd /c npx mcp-remote https://rageecpro.covaga.xyz/mcp

# EPLAN Electric P8 documentation (2027, keyword/full-text search)
claude mcp add eplan-wiki-2027 -- cmd /c npx mcp-remote https://rag2027.covaga.xyz/mcp

`eplan-wiki-2027` is deliberately a separate server rather than a 2026 → 2027 upgrade of

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 73 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "eplan-tools",
  3. "owner": {
  4. "name": "Canary E-cad",
  5. "url": "https://github.com/Canary-ECAD"
  6. },
  7. "metadata": {
  8. "description": "The Canary E-cad plugin marketplace for EPLAN Electric P8 and EEC Pro: agent skills for scripting, the EPLAN API and Remote Client, plus the documentation RAG MCP servers.",
  9. "version": "2.1.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "eplan",
  14. "source": {
  15. "source": "github",
  16. "repo": "Canary-ECAD/eplan-scripting-skill"
  17. },
  18. "description": "EPLAN Electric P8: the eplan-router skill plus the P8 skill (scripting, API and Remote Client) and the two P8 documentation RAG MCP servers. EEC Pro is a separate plugin: install eec-pro as well.",
  19. "version": "2.2.0",
  20. "author": {
  21. "name": "Canary E-cad",
  22. "url": "https://github.com/Canary-ECAD"
  23. },
  24. "homepage": "https://covaga.dev",
  25. "license": "MIT",
  26. "keywords": ["eplan", "eplan-p8", "eplan-electric-p8", "electrical-engineering", "csharp", "automation"],
  27. "category": "development",
  28. "strict": false,
  29. "skills": [
  30. "./eplan-router",
  31. "./skills/eplan-p8/eplan-scripting"
  32. ]
  33. },
  34. {
  35. "name": "eplan-scripting",
  36. "source": {
  37. "source": "github",
  38. "repo": "Canary-ECAD/eplan-scripting-skill"
  39. },
  40. "description": "EPLAN Electric P8 only: C# scripting, the EPLAN API (parts database, 3D), Remote Client automation, verified action parameters and production pitfalls. Covers EPLAN 2022-2027.",
  41. "version": "2.1.0",
  42. "author": {
  43. "name": "Canary E-cad",
  44. "url": "https://github.com/Canary-ECAD"
  45. },
  46. "homepage": "https://covaga.dev",
  47. "license": "MIT",
  48. "keywords": ["eplan", "eplan-p8", "eplan-api", "eplan-scripting", "csharp", "automation"],
  49. "category": "development",
  50. "strict": false,
  51. "skills": ["./skills/eplan-p8/eplan-scripting"]
  52. },
  53. {
  54. "name": "eec-pro",
  55. "source": {
  56. "source": "github",
  57. "repo": "Canary-ECAD/eec-pro-skill"
  58. },
  59. "description": "EPLAN EEC Pro 2026: typicals and the mechatronic model, the formula language, configuration interfaces, Groovy actions and P8 post-generation scripts, the EOX model file, the Job Server (recipes, triggers, workers, REST, timing), and generation into P8 / Pro Panel / PLC / text targets. Includes the EEC Pro documentation RAG MCP server.",
  60. "version": "2.1.0",
  61. "author": {
  62. "name": "Canary E-cad",
  63. "url": "https://github.com/Canary-ECAD"
  64. },
  65. "homepage": "https://covaga.dev",
  66. "license": "MIT",
  67. "keywords": ["eplan", "eec-pro", "typicals", "job-server", "eox", "electrical-engineering", "automation"],
  68. "category": "development",
  69. "strict": false,
  70. "skills": ["./skills/eec-pro-development"]
  71. }
  72. ]
  73. }
README.md · README · 425 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # EPLAN AI Automation Toolkit
  2. **English** · [Español](README.es.md) · [Deutsch](README.de.md) · [中文](README.zh-CN.md) · [한국어](README.ko.md) · [Türkçe](README.tr.md) · [Polski](README.pl.md) · [Русский](README.ru.md)
  3. [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/Canary-ECAD/eplan-mcp)
  4. [![MCP Badge](https://lobehub.com/badge/mcp/covagashi-eplan_2026_ia_mcp_scripts)](https://lobehub.com/mcp/covagashi-eplan_2026_ia_mcp_scripts)
  5. AI-assisted automation for **EPLAN Electric P8** and **EPLAN EEC Pro 2026**, built on the
  6. Model Context Protocol (MCP).
  7. 📖 **Documentation, install guide and full tool reference: [covaga.dev](https://covaga.dev)**
  8. This repository contains the local MCP server that drives a running EPLAN instance.
  9. The three remote documentation RAGs live in the separate
  10. [eplan-cloudflare-rags](https://github.com/Canary-ECAD/eplan-cloudflare-rags) repository.
  11. > Working with an LLM here? Read [`llm.md`](llm.md) — it describes, in LLM-facing terms,
  12. > everything the toolkit can do and configure.
  13. ## Repository layout
  14. ```
  15. .
  16. └── python/ # LOCAL: MCP server that controls EPLAN P8
  17. ```
  18. | Component | Type | Purpose | EPLAN product |
  19. |---|---|---|---|
  20. | `python/` | Local Python MCP | Drive a running EPLAN instance from Claude: open/close projects, exports, reports, scripts | EPLAN Electric P8 |
  21. | [**eplan-cloudflare-rags**](https://github.com/Canary-ECAD/eplan-cloudflare-rags) | Remote Cloudflare Workers, separate repository | Serve the P8 2026, P8 2027 and EEC Pro documentation over MCP and REST | EPLAN Electric P8 and EEC Pro |
  22. | [**eplan-scripting-skill**](https://github.com/Canary-ECAD/eplan-scripting-skill) | Claude Code skill, separate repository | Teach Claude to write correct EPLAN scripts, API code and Remote Client apps | EPLAN Electric P8 |
  23. Each repository carries its own README with installation and usage details.
  24. ## What is MCP?
  25. **MCP (Model Context Protocol)** is an open standard that lets AI assistants interact with
  26. external tools and services. Rather than only generating code, Claude can *execute* actions
  27. inside EPLAN in real time and consult the documentation through search.
  28. ## Quick start
  29. ### Local EPLAN automation (P8)
  30. ```bash
  31. python YOURPATH/python/install.py # own .venv + registers "eplan"
  32. claude mcp list # should list "eplan"
  33. ```
  34. Then start EPLAN, open Claude Code, and say `connect to eplan`. The full guide is in
  35. [`python/mcp_server/README.md`](python/mcp_server/README.md).
  36. > **Moved:** the server folder was called `eplan-p8-mcp-server/` before version 0.2.0. An MCP
  37. > registration that points at the old path stops working: run `python/install.py` again.
  38. ![Claude CLI configured](assets/claude-cli-configured.png)
  39. #### Prerequisite
  40. Remoting must be enabled in EPLAN before the server can connect: turn on **Allow remote
  41. access via Remote Client** under **File → Settings… → Workstation → Interfaces → Remote
  42. access**.
  43. ![Allow remote access via Remote Client](assets/remoting-allow-local-access.png)
  44. #### What the server exposes
  45. In its default `full` mode the server publishes **199 tools**:
  46. | Group | Count | What it covers |
  47. |---|---|---|
  48. | Connection / utility | 8 | Connect, version selection, status, extension listing |
  49. | Typed EPLAN actions (`eplan_*`) | 183 | One tool per documented or verified action, each executed silently inside a C# script under QuietMode, so no EPLAN dialog can block an unattended run |
  50. | Action catalog (`eplan_action_catalog` / `_describe` / `_run` / `_ribbon_catalog`) | 4 | Reaches a further ~1,050 actions that exist only as GUI buttons, mined from the install's `MFTools.xml` rather than the official docs |
  51. | Asset Administration Shell (`aas_*`) | 4 | AAS/AASX digital-twin export and import |
  52. The ~1,050 catalog actions are deliberately *not* given one wrapper tool each: that would
  53. have tripled the tool count and degraded tool selection for everything else.
  54. Among the 183 typed tools are four live-DataModel tools —
  55. `eplan_live_query_functions`, `eplan_live_query_pages`, `eplan_live_set_function_text`
  56. and `eplan_live_set_connection_designations` — which read and edit the open project's
  57. object model through runtime reflection, working around the script engine's limitation on
  58. static `using` directives.
  59. Beyond individual actions, the toolset covers the building blocks of a fully unattended
  60. develop → deploy → test loop:
  61. - **Application lifecycle** — `eplan_app_launch` / `eplan_app_shutdown` /
  62. `eplan_app_restart`: exit EPLAN, swap add-in DLLs, relaunch, reconnect, reopen the project.
  63. - **Disposable fixtures** — `eplan_scratch_project_*`: scratch projects cloned from a template.
  64. - **Diagnostics** — `eplan_get_system_messages`: read EPLAN's message tree and see the same
  65. errors and warnings the user sees in the GUI.
  66. - **Private extension modules** — see [below](#private-extension-modules-eplan_mcp_extensions).
  67. A tool-by-tool reference, generated from this repository's docstrings, lives at
  68. [covaga.dev/docs/tools](https://covaga.dev/docs/tools/project-and-workspace-management/).
  69. #### Tool annotations
  70. Every tool says what it does, so a client can decide when to ask the user first. Each one
  71. carries the four standard MCP annotations (`readOnlyHint`, `destructiveHint`,
  72. `idempotentHint`, `openWorldHint`), always set, plus EPLAN facts in its `_meta` under the
  73. key `canary-ecad/eplan`:
  74. | Fact | Meaning |
  75. |---|---|
  76. | `changesProject` | Writes the open project (a client may back it up first) |
  77. | `runsCode` | Runs scripts, actions or add-ins it is given |
  78. | `changesEplan` | Changes EPLAN itself: settings, parts database, master data, ribbon, add-ins |
  79. | `projectArgument` | The argument that names the project, when the tool has one |
  80. They are facts, not policy: the table lives in
  81. [`mcp_server/tool_annotations.py`](python/mcp_server/tool_annotations.py), and
  82. [`tools.json`](python/tools.json) is the published copy. Each release (a tag
  83. `vX.Y.Z`) attaches `tools.json` and lists the tools added, removed or re-annotated since the
  84. previous one.
  85. #### Script host
  86. The script host runs ordinary, typed C# against the EPLAN API (`using Eplan.EplApi.DataModel;`
  87. works) inside EPLAN, with no build and no restart. It compiles the script with Roslyn, checks it
  88. for unsafe calls and runs it. The same script runs
  89. in three runtimes: a registered add-in, a bootstrap through `ExecuteScript` (nothing to register),
  90. or an offline host that needs no EPLAN window and works on closed projects. Writes go only to
  91. scratch clones unless a person enables real-project writes and approves each saved script. The
  92. library in `dotnet/scripts/` ships ready-made tools for texts, line styles, functions, macro boxes
  93. and parts. All runtimes need the EPLAN API developer license.
  94. **EPLAN 2026 and 2027+.** The host comes in two flavors, one per framework EPLAN runs on, and the
  95. server picks the one the target EPLAN loads:
  96. | Flavor | EPLAN | Roslyn | After a run |
  97. |---|---|---|---|
  98. | `net8` | 2027 or newer (.NET 8) | EPLAN's own | the script is unloaded (collectible context) |
  99. | `netfx` | 2026 (.NET Framework 4.8.1) | shipped with the host | the script stays loaded until EPLAN closes; running the same script again reuses it |
  100. `dotnet/` builds the flavor of the EPLAN it finds (`Directory.Build.props` reads the API naming
  101. scheme from `Bin`: `Eplan.EplApi.*Netu.dll` on 2027, `*u.dll` on 2026; `-p:EplanTargetFramework=`
  102. forces it). EPLAN 2025 and older are refused up front and pointed at `eplan_execute_custom_script`
  103. and the `eplan_live_*` tools.
  104. ![Script host: MCP client, Python server, three runtimes, EPLAN API](docs/images/script-host-architecture.svg)
  105. Quick start (the server folder is now `python/`: see the "Moved" note in
  106. [Quick start](#local-eplan-automation-p8)):
  107. 1. `eplan_script_host_install`: downloads the host release (GitHub tag `host-v<version>`, separate
  108. from the server's `vX.Y.Z` tags) for the target EPLAN's flavor, checks its SHA-256 sums and
  109. installs it under `~/.eplan-mcp/host/<version>/<flavor>`. The script tools also do this on first
  110. use. Maintainers build each flavor on a machine with that EPLAN (2027 for `net8`, 2026 for
  111. `netfx`) with `dotnet/pack/pack-release.ps1`, which prints the `gh release` commands; both
  112. flavors go to the same release.
  113. 2. `eplan_script_hello`: reports the host version, the runtime that answers, EPLAN and the license.
  114. 3. Run a library script on a scratch clone. Pass `dry_run=True` to see what a writing script would
  115. change:
  116. ```text
  117. eplan_script_run(script="text_placements", project="<scratch>.elk", args={"page": "<page>"})
  118. eplan_script_run(script="text_set_height", project="<scratch>.elk", dry_run=True,
  119. args={"page": "<page>", "handle": "<handle from text_placements>", "factor": 1.5})
  120. ```
  121. `eplan_script_run` defaults to `dry_run=False`. Set `EPLAN_MCP_SCRIPT_TOOLS=publish` to get each
  122. library script as its own `eplan_<name>` tool; writers published that way default to
  123. `dry_run=True`. How to write scripts, the write gate and the full tool list:
  124. [`dotnet/SCRIPTING.md`](dotnet/SCRIPTING.md).
  125. #### Discovery mode
  126. `EPLAN_MCP_MODE=discovery` publishes 13 tools instead of 199, trading a token-heavy tool
  127. list for one extra search round-trip per task. It is worth it for MCP clients that send
  128. every tool's full schema on every request.
  129. **Skip it in Claude Code.** Claude Code already defers tool schemas itself — a name list up
  130. front, a schema fetched on demand — so the `full` 199-tool list already costs it about as
  131. little as `discovery`'s 13 would, and layering discovery's search → describe → call
  132. indirection on top only adds a round-trip. The tradeoff and the measurements are in
  133. [`python/mcp_server/README.md`](python/mcp_server/README.md#discovery-mode-eplan_mcp_mode).
  134. ### Remote documentation RAGs (P8, EEC Pro, 2027)
  135. Already deployed and ready to use — no local data required:
  136. ```bash
  137. # EPLAN Electric P8 documentation (2026, semantic search)
  138. claude mcp add eplan-rag -- cmd /c npx mcp-remote https://rag2026.covaga.xyz/mcp
  139. # EPLAN EEC Pro 2026 documentation
  140. claude mcp add eecpro-rag -- cmd /c npx mcp-remote https://rageecpro.covaga.xyz/mcp
  141. # EPLAN Electric P8 documentation (2027, keyword/full-text search)
  142. claude mcp add eplan-wiki-2027 -- cmd /c npx mcp-remote https://rag2027.covaga.xyz/mcp
  143. ```
  144. `eplan-wiki-2027` is deliberately a separate server rather than a 2026 → 2027 upgrade of
  145. `eplan-rag`: it indexes a different doc version *and* uses a different search mode (SQLite
  146. FTS5/bm25 keyword matching over [`cloudflare-rag-eplan-2027/`](https://github.com/Canary-ECAD/eplan-cloudflare-rags/tree/main/cloudflare-rag-eplan-2027)'s
  147. bundled wiki, versus Vectorize + bge semantic search). Measured head-to-head on real
  148. queries they fail differently: FTS5 wins exact-name lookups ("what is the signature of X"),
  149. semantic search wins when the query shares no vocabulary with the docs at all. Install both.
  150. Both also expose a plain REST API, which is convenient for verifying EPLAN action names and
  151. parameters while developing:
  152. ```bash
  153. curl -X POST https://rag2026.covaga.xyz/search -H "Content-Type: application/json" \
  154. -d '{"query": "export project pdf", "topK": 3}'
  155. curl -X POST https://rag2027.covaga.xyz/search -H "Content-Type: application/json" \
  156. -d '{"query": "FindAction", "topK": 3}'
  157. ```
  158. See [`cloudflare-rag-eplan-p8/README.md`](https://github.com/Canary-ECAD/eplan-cloudflare-rags/blob/main/cloudflare-rag-eplan-p8/README.md) and
  159. [`cloudflare-rag-eecpro/README.md`](https://github.com/Canary-ECAD/eplan-cloudflare-rags/blob/main/cloudflare-rag-eecpro/README.md) for the tools, REST
  160. endpoints and architecture.
  161. ### Visual symbol RAG (new)
  162. Identify EPLAN electrical symbols from images — a cropped glyph from a PDF,
  163. schematic or screenshot in, the real `short_name` out:
  164. - Index: 33,502 EPLAN symbol images (IEC/NFPA) embedded with CLIP ViT-B/32
  165. (512-dim, cosine) into Cloudflare Vectorize, from
  166. [`covaga/electrical-symbols-dataset`](https://huggingface.co/datasets/covaga/electrical-symbols-dataset).
  167. - Public endpoint `https://symbols.covaga.xyz` (same open pattern as the
  168. other RAGs — no credentials):
  169. ```bash
  170. # vector = CLIP ViT-B/32 L2-normalized embedding of the symbol image
  171. curl -X POST https://symbols.covaga.xyz/query -H "Content-Type: application/json" \
  172. -d '{"vector": [0.01, -0.02, "...512 floats..."], "topK": 5}'
  173. ```
  174. Each match carries `short_name`, catalog `number`, `description` and
  175. `variant_id`, plus a cosine score — the `short_name` is the identifier EPLAN
  176. API calls expect. Re-indexing and redeploy run through GitHub Actions in
  177. [`cloudflare-rag-symbols/`](https://github.com/Canary-ECAD/eplan-cloudflare-rags/tree/main/cloudflare-rag-symbols).
  178. #### Using it from this MCP server
  179. A ready-made extension ships in
  180. [`python/extensions/symbol_search.py`](./python/extensions/symbol_search.py).
  181. Enable it and the agent gets an `eplan_symbol_search` tool:
  182. ```powershell
  183. pip install sentence-transformers pillow requests
  184. set EPLAN_MCP_EXTENSIONS=<repo>\python\extensions
  185. ```
  186. Then, pointed at a cropped symbol image, Claude calls
  187. `eplan_symbol_search(image_path="C:\\...\\crop.png")` → the image is embedded
  188. locally with CLIP → `symbols.covaga.xyz` returns candidates like
  189. `F1 (no. 50, variant B) — Fuse, single-pole` → use the top `short_name` in
  190. EPLAN API calls. No Cloudflare token needed: the Worker holds the index
  191. binding.
  192. ### Claude Code skill for EPLAN development
  193. The MCP servers let Claude *act* on EPLAN. The
  194. [**eplan-scripting**](https://github.com/Canary-ECAD/eplan-scripting-skill) skill teaches
  195. it to *write correct EPLAN code*: scripting entry points, verified action parameters,
  196. parts-database access, Remote Client automation (dynamic ports, headless EPLAN, Cogineer),
  197. and the production pitfalls — pseudo-asynchronous command blocking, the message-loop
  198. monitor thread, dispose discipline, the EPLAN 2025 remoting changes.
  199. The skill lives in its own repository and is deliberately **host-agnostic**: it assumes no
  200. MCP server, no particular script runner and no particular documentation index, so it is
  201. useful on its own whether or not you run anything else from here.
  202. ```
  203. /plugin marketplace add Canary-ECAD/eplan-mcp
  204. /plugin install eplan@eplan-tools # eplan-router + P8 skill + P8 doc RAGs
  205. /plugin install eplan-scripting@eplan-tools # Electric P8 only
  206. /plugin install eec-pro@eplan-tools # EEC Pro only
  207. ```
  208. Manual installation and details:
  209. [the skill's own README](https://github.com/Canary-ECAD/eplan-scripting-skill#readme).
  210. ## Adding new EPLAN actions
  211. The local MCP server registers tools **dynamically** from each actions package's `__all__`
  212. list, so adding an action takes two steps and no per-tool boilerplate.
  213. ### 1. Implement the action
  214. In `python/mcp_server/api/actions/<your_module>.py`:
  215. ```python
  216. def open_project(project_path: str, open_mode: str = None) -> dict:
  217. """Open a project in EPLAN.
  218. Args:
  219. project_path: Full path to the .elk project file.
  220. open_mode: "Standard", "ReadOnly", or "Exclusive" (optional).
  221. """
  222. manager, error = _get_connected_manager()
  223. if error:
  224. return error
  225. action = _build_action("ProjectOpen", Project=project_path, OpenMode=open_mode)
  226. return manager.execute_action(action)
  227. ```
  228. ### 2. Export it
  229. Add the function to the imports **and** to `__all__` in
  230. `python/mcp_server/api/actions/__init__.py`. It is then auto-registered as
  231. `eplan_open_project`.
  232. Then say what it does: add a line to `TOOL_FLAGS` in
  233. `python/mcp_server/tool_annotations.py` (see [Tool annotations](#tool-annotations))
  234. and run `python python/tools/dump_tools.py` to update `tools.json`. The test
  235. suite fails until both are done.
  236. ### 3. Restart the MCP server
  237. The new tool becomes available once Claude / the server restarts.
  238. ### 4. Validate against the official docs (optional)
  239. `python/tools/validate_actions.py` cross-checks every action name and
  240. parameter declared in the wrappers against the official EPLAN docs RAG and writes a
  241. markdown report:
  242. ```bash
  243. python python/tools/validate_actions.py
  244. ```
  245. ![EPLAN test](assets/eplan-test.png)
  246. ### Tips
  247. 1. **Verify against the docs.** Use the remote P8 RAG (`https://rag2026.covaga.xyz`) to
  248. confirm the exact EPLAN action name and its parameters.
  249. 2. **Write meaningful docstrings and type hints.** They become the tool description and
  250. input schema the LLM sees and relies on.
  251. 3. **Handle paths carefully.** Windows paths need escaping (`\\`) or forward slashes (`/`).
  252. ## Private extension modules (`EPLAN_MCP_EXTENSIONS`)
  253. The server can load **extra tool modules from outside this repository** — company-specific
  254. or private tooling (custom add-in test harnesses, internal workflows) that must not live in
  255. a public repo.
  256. Point the `EPLAN_MCP_EXTENSIONS` environment variable at one or more directories (separated
  257. by `;` on Windows). Every top-level `*.py` file there that does not start with `_` is
  258. imported at startup, and its `__all__` functions are registered as MCP tools exactly like
  259. the built-in actions:
  260. ```python
  261. # my_company_tools.py (in a private repo, NOT in eplan-mcp)
  262. TOOL_PREFIX = "acme_" # optional, default "eplan_"
  263. __all__ = ["run_smoke_test"]
  264. import actions # the server's api/ folder is on sys.path
  265. from actions._base import _get_connected_manager
  266. def run_smoke_test(project_path: str) -> dict:
  267. """Docstring becomes the tool description the LLM sees."""
  268. clone = actions.scratch_project_create(project_path)
  269. ...
  270. return {"success": True}
  271. ```
  272. Rules and behaviour:
  273. - `TOOL_PREFIX` namespaces the tools (`acme_run_smoke_test` above).
  274. - The stable contract is `eplan_mcp.ext` (`EXT_API_VERSION = 1`): `run_script`, `run_action`,
  275. `register_script_dir` (adds a folder of `.cs` library scripts with their own helpers),
  276. `scratch_root`. Declare `EXT_API = (1, 1)`; the server refuses an extension whose range does
  277. not include its version. Anything outside `ext` may change in any release.
  278. - `TOOL_FLAGS = {"run_smoke_test": "project"}` (optional) gives the tools their
  279. [annotations](#tool-annotations), as does `run_smoke_test.__tool_flags__ = "project"` on the
  280. function; without either they have none.
  281. - Extensions may import everything the built-in actions use: `actions`, `actions._base`,
  282. `actions.scripted._execute_script` (run C# inside EPLAN), `eplan_connection`.
  283. - A broken extension is reported on stderr and skipped; it never prevents the server from
  284. starting.
  285. - `eplan_list_extensions` shows what was loaded.
  286. Combined with the lifecycle and scratch-fixture tools, this enables a fully unattended loop
  287. for developing private EPLAN add-ins: build the DLL → deploy → `eplan_app_restart` → verify
  288. the add-in's actions registered (for example via a `FindAction` script) → run them against a
  289. disposable scratch project → `eplan_get_system_messages` to catch anything EPLAN complained
  290. about.
  291. ## EPLAN version selection (automatic)
  292. There is **nothing to configure**. On startup the server scans
  293. `C:\Program Files\EPLAN\Platform` for installed versions and:
  294. - **Auto mode (default):** `eplan_connect` targets the **newest installed version** and
  295. picks the matching .NET runtime automatically — coreclr for EPLAN 2027+, .NET Framework
  296. for 2026 and older.
  297. - **Explicit mode:** the LLM can call `eplan_versions` to list what is installed and then
  298. connect to a specific one with `eplan_connect(version="2026")` — e.g. "connect to
  299. eplan 2026".
  300. Notes:
  301. - EPLAN installed somewhere non-standard? Set `EPLAN_PLATFORM_ROOT` to its `Platform` folder.
  302. - Once one version's DLLs are loaded into the process, switching versions requires
  303. restarting the MCP server — a .NET runtime cannot be swapped at runtime.
  304. - `eplan_connect` also accepts a `host` (and `"host:port"`) to reach an EPLAN instance on
  305. another machine; port auto-detection only works on localhost.
  306. ## Related repositories
  307. | Repository | What it is |
  308. |---|---|
  309. | [**eplan-scripting-skill**](https://github.com/Canary-ECAD/eplan-scripting-skill) | The Claude Code skill above, standalone and host-agnostic. Install with `/plugin marketplace add Canary-ECAD/eplan-mcp`. |
  310. | [**eplan-ctxmenu-kit**](https://github.com/covagashi/eplan-ctxmenu-kit) | Add your own entries to EPLAN's right-click menus, and read the row the user clicked. A discovery tool plus a worked example. |
  311. ## Resources
  312. - [EPLAN API documentation](https://www.eplan.help/)
  313. - [MCP protocol specification](https://modelcontextprotocol.io/)
  314. - [Claude Code documentation](https://docs.anthropic.com/claude-code)
  315. ## License
  316. MIT — see [`LICENSE`](LICENSE).
  317. > **Disclaimer:** this is an independent community project by [Canary E-cad](https://github.com/Canary-ECAD). It is not affiliated with, endorsed by, or supported by EPLAN GmbH & Co. KG. EPLAN, EPLAN Electric P8 and EPLAN EEC Pro are trademarks of their respective owner.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.