Skip to content
Back to search

PowerMCP

PowerMCP is an open-source collection of MCP servers for power system software like PowerWorld, PSSE and OpenDSS. These tools enable LLMs to directly interact with power system applications, facilitating intelligent coordination, simulation, and control in the energy domain.

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/Power-Agent/PowerMCP 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/Power-Agent/PowerMCP'

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/power-agent--powermcp/badge.svg)](/listings/power-agent--powermcp)

HTML

<a href="/listings/power-agent--powermcp"><img src="/api/listings/power-agent--powermcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

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

πŸ“– Quick start

> **πŸš€ New to PowerMCP? Start here!**

The recommended way to get started is the `powermcp` package and its installer (see the **Installation** section below):

pip install powermcp
powermcp install        # pick tools, capture local paths, write your MCP client config

> πŸ“‹ The **[PowerMCP Tutorial PDF](https://github.com/Power-Agent/PowerMCP/blob/main/PowerMCP_Tutorial.pdf)** documents the original **low-code / manual** setup β€” cloning the repo and hand-editing the Claude Desktop config. It predates the `powermcp` installer and is **not the recommended path**; use it only if you specifically want the manual approach.

Video Demos

Check out these demos showcasing PowerMCP in action:

- [**Contingency Evaluation Demo**](https://www.youtube.com/watch?v=MbF-SlBI4Ws): An LLM automatically operates power system software, such as PowerWorld and pandapower, to perform contingency analysis and generate professional reports.

- [**Loadgrowth Evaluation Demo**](https://www.youtube.com/watch?v=euFUvhhV5dM): An LLM automatically operates power system software, such as PowerWorld, to evaluate different load growth scenarios and generate professional reports with recommendations.

Useful MCP Tutorials

MCP follows a client-server architecture where:

* **Hosts** are LLM applications (like Claude Desktop or IDEs) that initiate connections * **Clients** maintain 1:1 connections with servers, inside the host application * **Servers** provide context, tools, and prompts to clients

Check out these helpful tutorials to get started with MCP:

- [**Getting Started with MCP**](https://modelcontextprotocol.io/introduction): Official introduction to the Model Context Protocol fundamentals. - [**Core Architecture**](https://modelcontextprotocol.io/docs/concepts/architecture): Detailed explanation of MCP's client-server architecture. - [**Building Your First MCP Server**](https://modelcontextprotocol.io/docs/develop/build-server): Step-by-step guide to creating a basic MCP server. - [**Anthropic MCP Tutorial**](https://docs.claude.com/en/docs/mcp): Learn how to use MCP with Claude models. - [**Cursor MCP Tutorial**](https://cursor.com/docs/context/mcp): Learn how to use MCP with Cursor. - [**Other Protocol**](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf): Open AI Function Calling Tool

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.

README.md Β· README Β· 345 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. # PowerMCP ⚑
  2. [![PyPI](https://img.shields.io/pypi/v/powermcp.svg)](https://pypi.org/project/powermcp/)
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  4. [![Python Version](https://img.shields.io/badge/python-3.10%20to%203.14-blue.svg)](https://www.python.org/downloads/)
  5. PowerMCP is an open-source collection of MCP servers for power system software such as PSS/E, PowerWorld, PowerFactory, PSLF, PSCAD, OpenDSS, pandapower, and PyPSA. These tools enable LLMs to directly interact with power system applications, facilitating intelligent coordination, simulation, and control in the energy domain.
  6. PowerMCP is part of [PowerAgent](https://poweragent.seas.harvard.edu/), an open-source community for agentic AI in power systems, maintained by the Power and AI Initiative (PAI) at Harvard SEAS.
  7. > **Install with your AI agent:** paste [this prompt](#-install-with-an-ai-agent-recommended) into Claude Code, Codex, or another coding agent and it will install and configure PowerMCP for you.
  8. ## 🌟 What is MCP?
  9. The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) is a revolutionary standard that enables AI applications to seamlessly connect with various external tools. Think of MCP as a universal adapter for AI applications, similar to what USB-C is for physical devices. It provides:
  10. - Standardized connections to power system software and data sources
  11. - Secure and efficient data exchange between AI agents and power systems
  12. - Reusable components for building intelligent power system applications
  13. - Interoperability between different AI models and power system tools
  14. ## 🀝 Our Community Vision
  15. We're building an open-source community focused on accelerating AI adoption in the power domain through MCP. Our goals are:
  16. - **Collaboration**: Bring together power system experts, AI researchers, and software developers
  17. - **Innovation**: Create and share MCP servers for various power system software and tools
  18. - **Education**: Provide resources and examples for implementing AI in power systems
  19. - **Standardization**: Develop best practices for AI integration in the energy sector
  20. ## πŸš€ Getting Started with MCP
  21. ### πŸ“– Quick start
  22. > **πŸš€ New to PowerMCP? Start here!**
  23. The recommended way to get started is the `powermcp` package and its installer. Either let an AI coding agent do it ([copy the prompt](#-install-with-an-ai-agent-recommended)), or run it yourself (see the **Installation** section below):
  24. ```bash
  25. pip install powermcp
  26. powermcp install # pick tools, capture local paths, write your MCP client config
  27. ```
  28. > πŸ“‹ The **[PowerMCP Tutorial PDF](https://github.com/Power-Agent/PowerMCP/blob/main/PowerMCP_Tutorial.pdf)** documents the original **low-code / manual** setup β€” cloning the repo and hand-editing the Claude Desktop config. It predates the `powermcp` installer and is **not the recommended path**; use it only if you specifically want the manual approach.
  29. ### Video Demos
  30. Check out these demos showcasing PowerMCP in action:
  31. - [**PowerMCP New Feature Release**](https://www.youtube.com/watch?v=xwTcNZLmIW8): pip install, automatic setup with `powermcp install`, and PowerIO integration.
  32. - [**Grid Impact Evaluation Demo**](https://www.youtube.com/watch?v=LxF8RqsNf04): Agentic AI streamlines the grid impact evaluation of large loads such as data centers, automating the analysis and report generation.
  33. - [**PowerSkills + PowerMCP Demo**](https://www.youtube.com/watch?v=bxZu47f6fUE): [PowerSkills](https://github.com/Power-Agent/PowerSkills) and PowerMCP together give AI agents the domain knowledge and structured instructions for simulation, analysis, and optimization across industry software tools, with reports in an industry-standard format.
  34. - [**Contingency Evaluation Demo**](https://www.youtube.com/watch?v=MbF-SlBI4Ws): An LLM automatically operates power system software, such as PowerWorld and pandapower, to perform contingency analysis and generate professional reports.
  35. - [**Loadgrowth Evaluation Demo**](https://www.youtube.com/watch?v=euFUvhhV5dM): An LLM automatically operates power system software, such as PowerWorld, to evaluate different load growth scenarios and generate professional reports with recommendations.
  36. ### Useful MCP Tutorials
  37. MCP follows a client-server architecture where:
  38. * **Hosts** are LLM applications (like Claude Desktop or IDEs) that initiate connections
  39. * **Clients** maintain 1:1 connections with servers, inside the host application
  40. * **Servers** provide context, tools, and prompts to clients
  41. Check out these helpful tutorials to get started with MCP:
  42. - [**Getting Started with MCP**](https://modelcontextprotocol.io/introduction): Official introduction to the Model Context Protocol fundamentals.
  43. - [**Core Architecture**](https://modelcontextprotocol.io/docs/concepts/architecture): Detailed explanation of MCP's client-server architecture.
  44. - [**Building Your First MCP Server**](https://modelcontextprotocol.io/docs/develop/build-server): Step-by-step guide to creating a basic MCP server.
  45. - [**Anthropic MCP Tutorial**](https://docs.claude.com/en/docs/mcp): Learn how to use MCP with Claude models.
  46. - [**Cursor MCP Tutorial**](https://cursor.com/docs/context/mcp): Learn how to use MCP with Cursor.
  47. - [**Other Protocol**](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf): Open AI Function Calling Tool
  48. ## πŸ“¦ Installation
  49. ### πŸ€– Install with an AI agent (recommended)
  50. More and more people install PowerMCP by asking an AI coding agent such as **Claude Code**, **Codex**, Cursor, or Cline to do it. Open the agent in a terminal on the machine where your power-system software lives, then paste this prompt and fill in the two lists:
  51. ```text
  52. Install and configure PowerMCP (https://github.com/Power-Agent/PowerMCP) on this computer.
  53. Follow the agent guide step by step:
  54. https://raw.githubusercontent.com/Power-Agent/PowerMCP/main/llms-install.md
  55. Tools I want, in addition to the core pandapower, PyPSA and PowerIO: <for example OpenDSS, ANDES, PSS/E, or "core only">
  56. MCP clients to configure: <for example Claude Code, Claude Desktop, Codex CLI>
  57. Use a dedicated virtual environment. Ask me before guessing the install path of any
  58. commercial software. Finish by running `powermcp doctor` and telling me what is left for me to do.
  59. ```
  60. The agent follows [`llms-install.md`](llms-install.md): it checks your OS and Python, creates a virtual environment, installs the right extras, stores vendor software paths, writes the MCP client configuration without touching your other servers, and verifies the result. If your agent can't open web links, clone this repository and tell it to read `llms-install.md` from the clone.
  61. After it finishes, restart your MCP client (start a new Claude Code or Codex session, or fully quit and reopen Claude Desktop) so it loads the new servers.
  62. ### Install it yourself
  63. PowerMCP installs as a single Python package with an interactive CLI. Python 3.10 through 3.14 is supported.
  64. ```bash
  65. pip install powermcp
  66. ```
  67. The base install includes the open-source engines that need no extra setup: **pandapower**, **PyPSA**, and **PowerIO** (the cross-server case-conversion substrate). Every other tool is opt-in via an extra. Quote the brackets, since zsh (the macOS default shell) otherwise rejects them:
  68. ```bash
  69. pip install "powermcp[psse]" # add PSS/E support
  70. pip install "powermcp[andes,opendss]" # add several tools at once
  71. pip install "powermcp[opensource]" # all open-source tools (ANDES, Egret, OpenDSS, surge, HOPE, LTSpice, GenX)
  72. pip install "powermcp[windows]" # all Windows vendor tools (PowerWorld, PSS/E, PSLF, PowerFactory, PSCAD)
  73. pip install "powermcp[all]" # everything (closed-source tools still need the local software)
  74. ```
  75. ### Supported tools
  76. | Tool | `powermcp` id | pip extra | Platform | Notes |
  77. |---|---|---|---|---|
  78. | pandapower | `pandapower` | *(core)* | any | |
  79. | PyPSA | `pypsa` | *(core)* | any | HiGHS included; CBC, GLPK, Gurobi optional |
  80. | PowerIO | `powerio` | *(core)* | any | case parsing, conversion, and matrices for every other server |
  81. | ANDES | `andes` | `andes` | any | |
  82. | Egret | `egret` | `egret` | any | needs ipopt or Gurobi |
  83. | OpenDSS | `opendss` | `opendss` | any | |
  84. | surge | `surge` | `surge` | any | Python 3.12 to 3.14 |
  85. | HOPE | `hope` | `hope` | any | needs a HOPE.jl checkout and Julia |
  86. | GenX | `genx` | `genx` | any | needs a GenX.jl checkout; SLURM to submit cases |
  87. | LTSpice | `ltspice` | `ltspice` | any | LTspice must be installed (auto-detected) |
  88. | PLEXOS database | `plexosdb` | `plexosdb` | any | Python 3.11 to 3.13; extra manual steps in [PLEXOSDB/README.md](PLEXOSDB/README.md) |
  89. | PowerWorld | `powerworld` | `powerworld` | Windows | needs a running, licensed Simulator |
  90. | PSS/E | `psse` | `psse` | Windows | needs PSS/E installed |
  91. | GE PSLF | `pslf` | `pslf` | Windows | needs PSLF installed |
  92. | PowerFactory | `powerfactory` | `powerfactory` | Windows | needs PowerFactory installed |
  93. | PSCAD | `pscad` | `pscad-windows` | Windows | needs PSCAD installed |
  94. ### Set up with the interactive installer
  95. ```bash
  96. powermcp install
  97. ```
  98. The wizard lets you pick tools (pandapower + PyPSA + PowerIO pre-selected), captures the local install path for any tools that need one (PSS/E, PSLF, PowerFactory, LTSpice, HOPE, GenX), installs the right extras, and writes the MCP client configuration for **Claude Desktop**, **Claude Code**, and the **Codex CLI**. Each entry launches the server with the absolute path of the Python interpreter that ran the installer, so keep that environment in place. Use `--dry-run` to preview the changes, `--clients` to pick which clients to configure, or `--yes` for a non-interactive core install.
  99. In the interactive picker, move with ↑/↓ and **press SPACE to toggle each tool** before ENTER (ENTER alone keeps only the preselected tools). Prefer not to use the checkbox? Choose tools directly:
  100. ```bash
  101. powermcp install --tools psse,andes # core + the listed tools
  102. powermcp install --all # every tool available on this platform
  103. ```
  104. Re-running `powermcp install` interactively pre-checks the tools you've already installed or configured, so it **preserves and updates** your setup instead of resetting to the core tools. With `--tools`, list every tool you want to keep: `powermcp_*` entries for tools left out of the list are removed. Paths for tools like LTSpice are **auto-detected and pre-filled**, so you can usually just press Enter.
  105. ### CLI commands
  106. | Command | Description |
  107. |---|---|
  108. | `powermcp install` | Setup wizard: interactive, or `--tools <ids>` / `--all` (also `--dry-run`, `--yes`, `--clients claude-desktop,claude-code,codex,none`) |
  109. | `powermcp run <tool>` | Launch a server over stdio (used by the generated client config) |
  110. | `powermcp list` | List the available tools, extras, and Windows-only flags |
  111. | `powermcp doctor [tool]` | Check dependencies and configured paths for every tool, or for one |
  112. | `powermcp config show` / `config set <tool>.<key> <path>` | Inspect / set local software paths |
  113. | `powermcp --version` | Print the installed version |
  114. ### Closed-source / EXE-based tools
  115. These tools wrap commercial or locally-installed software, so PowerMCP stores the local path in `~/.powermcp/config.toml` (captured by `powermcp install`, or set manually with `powermcp config set`):
  116. | Tool | Config keys | Example |
  117. |---|---|---|
  118. | PSS/E | `psse.python_lib`, `psse.bin`, optional `psse.bus_size` | `powermcp config set psse.python_lib "C:\Program Files\PTI\PSSE36\36.2\PSSPY311"`. The engine starts at the bus size set in the PSS/E GUI; for a larger case, `powermcp config set psse.bus_size 150000` |
  119. | PSLF | `pslf.python_lib` | `powermcp config set pslf.python_lib "C:\Program Files\GE PSLF\PSLF_PYTHON"` |
  120. | PowerFactory | `powerfactory.python_path` | `powermcp config set powerfactory.python_path "...\DIgSILENT\PowerFactory 2024\Python\3.11"` |
  121. | LTSpice | `ltspice.exe` *(auto-detected)* | Found automatically in standard locations β€” usually no setup needed. Override: `powermcp config set ltspice.exe "C:\Program Files\ADI\LTspice\LTspice.exe"` |
  122. | HOPE | `hope.repo_root`, `hope.julia_bin`, `hope.julia_depot_path` | `powermcp config set hope.repo_root "C:\src\HOPE"` |
  123. | GenX | `genx.repo_root` | `powermcp config set genx.repo_root "/home/me/GenX.jl"` β€” the GenX.jl checkout; `GENX_DIR` overrides it |
  124. | PowerWorld | *(none)* | `esa` auto-discovers a running, licensed Simulator via COM; the `powerworld` extra also installs `numba` (required by esa) |
  125. | PSCAD | *(none)* | `pip install "powermcp[pscad-windows]"` provides `mhi-pscad`; PSCAD must be installed |
  126. | PLEXOS database | *(none)* | The upstream `plexosdb-mcp` package is not on PyPI yet; install it as described in [PLEXOSDB/README.md](PLEXOSDB/README.md) |
  127. > The Codex *Desktop* app on Windows has been reported to overwrite `~/.codex/config.toml`; the Codex *CLI* is unaffected. If you use both, re-run `powermcp install` after Desktop edits.
  128. ### Case compilation between servers (PowerIO)
  129. PowerIO IR is the exchange format of this repository. PowerMCP runs the
  130. server shipped in PowerIO 0.11.2 (`powermcp run powerio` is `python -m
  131. powerio.mcp`); that server parses every grid exchange format, emits every
  132. target, summarizes, diagnoses, normalizes, lowers multiconductor networks, and
  133. calculates matrices. Its `parse` tool returns serialized **PowerIO IR
  134. generation 2** (`"schema": "pio-ir"`, `"version": 2`), a typed module carrying
  135. the electrical value, its provenance and its diagnostics. Every other server
  136. here consumes that document: the pandapower, PyPSA, ANDES and Egret adapters
  137. turn it into their own model with PowerIO's writers. PowerMCP itself never
  138. re-parses, re-validates, or recomputes what PowerIO states; it routes a
  139. declared value to a consumer that accepts it and owns only the final step into
  140. one simulator.
  141. ```python
  142. parsed = parse(path="case9.raw") # powerio server
  143. ir = parsed["powerio_ir"]
  144. summarize(powerio_ir=ir)
  145. calc_matrix(matrix="ptdf", powerio_ir=ir) # rows and columns carry bus ids and branch identities
  146. diagnostics(powerio_ir=ir)
  147. import_case_from_json(powerio_ir=ir, output_path="case9.nc") # PyPSA
  148. load_network_from_json(powerio_ir=ir) # pandapower
  149. load_model_from_json(powerio_ir=ir) # Egret
  150. load_network_from_json(powerio_ir=ir, out_path="case9.m") # ANDES
  151. emit(format="psse", destination="case9.raw", powerio_ir=ir)
  152. ```
  153. `powerio_ir` is the argument every adapter takes; `network_json` remains an
  154. alias for the same document. A `ScenarioSet` requires `scenario_id`; a
  155. `TimeSeries` requires `time_index`; nested collections require both. An
  156. operating point entry reaches the solver as the network it states. The
  157. `operating_point` argument remains an alias for `time_index`.
  158. ```python
  159. import_case_from_json(
  160. powerio_ir=ir, output_path="dispatch.nc",
  161. scenario_id="high-demand", time_index=3,
  162. )
  163. ```
  164. Every adapter response carries the same tail: `value_type` (the PowerIO
  165. structural type that was selected), `selection`, `diagnostics` (full PowerIO
  166. records with code, severity, target, spans and suggested action) and
  167. `warnings`. The powerio adapters add the emission `fidelity`
  168. (`exact_same_format` when PowerIO echoed retained source bytes, `canonical` for
  169. fresh output) and the typed `edits` report described below, because they own
  170. the conversion into their own model. The `package` key keeps the IR context
  171. earlier clients read.
  172. #### Typed edits before a solver import
  173. The powerio adapters accept `edits`, a JSON list of what-if changes PowerIO
  174. applies as typed updates before the conversion. The whole list is validated
  175. first, then applied in list order; consecutive updates of one class apply as
  176. one atomic batch, and a bus load reallocation sees the values produced by the
  177. edits before it. The response reports the changed components, in application
  178. order, under `edits`.
  179. | op | keys |
  180. |---|---|
  181. | `set_load_active_power` | `load`, `mw`, `terminal?` |
  182. | `set_load_reactive_power` | `load`, `mvar`, `terminal?` |
  183. | `set_generator_active_power` | `generator`, `mw`, `terminal?` |
  184. | `set_generator_reactive_power` | `generator`, `mvar`, `terminal?` |
  185. | `set_generator_voltage_magnitude` | `generator`, `vm_pu` |
  186. | `set_generator_in_service` | `generator`, `in_service` |
  187. | `set_branch_in_service` | `branch`, `in_service` |
  188. | `set_transformer_tap_ratio` | `transformer`, `tap_ratio` |
  189. | `set_transformer_phase_shift` | `transformer`, `shift_degrees` |
  190. | `set_switch_closed` | `switch`, `closed` |
  191. | `set_branch_thermal_rating` | `branch`, `mva`, `terminal?` |
  192. | `set_bus_load_active_power` | `bus`, `mw`, `allocation` (`proportional_to_current_active_power` or `equal`) |
  193. Component ids are the stable identities PowerIO reports (`loads:0`,
  194. `branches:3`, or the source uid). A bus demand edit names an allocation rule
  195. because PowerIO never assigns aggregate demand to an arbitrary load.
  196. ```python
  197. load_network_from_json(
  198. powerio_ir=ir,
  199. edits='[{"op": "set_load_active_power", "load": "loads:0", "mw": 91.5},'
  200. ' {"op": "set_branch_in_service", "branch": "branches:3", "in_service": false}]',
  201. )
  202. ```
  203. #### Distribution networks
  204. A multiconductor value is rejected by a balanced solver until the caller asks
  205. for the transformation: pass `to_balanced=True` (and `base_mva`) and the
  206. response carries PowerIO's readiness report under `lowering`, or call the
  207. powerio server's `to_balanced_report` and `to_balanced` tools first. Retaining
  208. a component does not establish that the selected solver models it. Use `emit`
  209. for a backend that needs files: OpenDSS output is a directory bundle whose
  210. master DSS artifact `compile_opendss_file` accepts; `bmopf-json@0.1.0` and
  211. `bmopf-json@0.2.0` select the BMOPF schema version (the latter writes draft
  212. BMOPF 0.2, subject to Task Force approval); `geo-json` writes a geographic
  213. layer.
  214. The retired `Package`, `model-json`, `package_json` and package `study_commit`
  215. formats require migration: re-parse the original case and pass its
  216. `powerio_ir`.
  217. PowerIO MCP paths support local files and `file://` URIs. Set
  218. `POWERIO_MCP_ALLOWED_ROOTS` to an `os.pathsep` separated directory list to
  219. constrain the shared path policy. With no root variable set, paths stay beneath
  220. the directory the server process started in, which is rarely the directory an
  221. operator means. Legacy single-root environment aliases remain supported.
  222. Directory inputs check every descendant, and generated directories install from
  223. private sibling staging paths. Place `POWERMCP_HOME` under an allowed root for
  224. solver run artifacts. These checks cannot prevent another process from
  225. replacing a path after validation.
  226. ### Running from a clone (without installing)
  227. Every bundled server is still a standalone script. Clone the repo and run any server directly for use in Claude Desktop:
  228. ```bash
  229. python pandapower/panda_mcp.py
  230. python PSSE/psse_mcp.py # uses ~/.powermcp/config.toml if present, else legacy default paths
  231. python -m powerio.mcp # powerio ships its own server; the clone holds no copy
  232. ```
  233. ### Testing with your LLMs
  234. > **Note:** All MCPs should be tested via an MCP client (Claude Desktop, Claude Code, or Codex) before submitting a PR to ensure consistency.
  235. `powermcp install` writes the client configuration for you. Each generated entry runs `<python> -m powermcp run <tool>` with the absolute interpreter path, because GUI clients such as Claude Desktop don't inherit your shell `PATH`. [`config.json`](config.json) shows the shorter form that works when `powermcp` is on `PATH`. For clients the installer doesn't write (Cursor, VS Code, and others), add the same command and arguments by hand; [`llms-install.md`](llms-install.md) has an example. (The **[PowerMCP Tutorial PDF](PowerMCP_Tutorial.pdf)** covers the older manual / low-code setup and isn't needed for the package install.)
  236. ## πŸ“š Documentation
  237. For detailed documentation about MCP, please visit:
  238. - [Model Context Protocol documentation](https://modelcontextprotocol.io/introduction)
  239. - [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
  240. - [Other General MCP Servers](https://smithery.ai/)
  241. ## 🀝 Contributing
  242. We welcome contributions! Please see our [Contributing Guidelines](https://poweragent.seas.harvard.edu/) for details, and join the conversation in the [PowerAgent Slack community](https://join.slack.com/t/poweragentslack/shared_invite/zt-3c14g1lv4-LfwB2DQU1_ZwTyxJO6k_5Q).
  243. ## πŸ“„ License
  244. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  245. ## πŸ™ Acknowledgments
  246. ### Core Team
  247. PowerAgent leads: [Qian Zhang](https://qianzhang.xyz/) (student lead) and [Le Xie](https://seas.harvard.edu/person/le-xie) (faculty lead)
  248. PowerMCP: [Qian Zhang](https://qianzhang.xyz/), [Steven Black](https://www.linkedin.com/in/steven-black-09322b31/), [Paulo Radatz](https://www.linkedin.com/in/pauloradatz/), [Andrea Pomarico](https://www.linkedin.com/in/andrea-pomarico-2695a2218/), [Muhy Eddin Za'ter](https://scholar.google.com/citations?user=_IFFYFAAAAAJ&hl=en), [Luan Lopes dos Santos](https://www.linkedin.com/in/luan-lopes/), [Stephen Jenkins](https://www.linkedin.com/in/stephenjenkins2/), [Maanas Goel](https://www.linkedin.com/in/maanas-goel/), [Shen Wang](https://www.linkedin.com/in/swang16/), [Drew Gray](https://www.linkedin.com/in/drew-gray-b09ba426/), [Samuel Talkington](https://samueltalkington.com/), [Laura Hwa](https://www.linkedin.com/in/laurahwa/), [Leo Winiecki](https://www.linkedin.com/in/leo-winiecki-3337b716a/), [Brian Horakh](https://www.linkedin.com/in/brianhorakh/), [Aswin Krishna Poyil](https://www.linkedin.com/in/aswinkrishnapoyil/), [Burhan Abdullah](https://www.linkedin.com/in/burhanabdullah/)
  249. The full PowerAgent team, including PowerFM, PowerSkills, PowerWF, and the PowerAgent Platform, is listed at [poweragent.seas.harvard.edu](https://poweragent.seas.harvard.edu/).
  250. ### Special Thanks
  251. - All contributors who help make this project better
  252. - [The Power and AI Initiative (PAI) at Harvard SEAS](https://pai.seas.harvard.edu/)
  253. - PowerFactory development and validation contributions by Aswin Krishna Poyil
  254. at the Institute of Electrical Energy Systems,
  255. Friedrich-Alexander-UniversitΓ€t Erlangen-NΓΌrnberg (FAU), with supervision
  256. and support from Tobias Lorz and Timon Conrad, who provided the opportunity
  257. to pursue this work independently

Ratings and comments

Sign in to rate this skill.

Sign in

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