# PlatformIO (pypi · platformio.mcp)

PlatformIO for AI agents: build, flash, serial monitor, tests, crash decoding, size reports.

- Trust score: 47/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-22

## Components

- pypi · `platformio.mcp`: 47/100 (this document), [markdown](https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp.md), [page](https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp)

## Channel facts

- Registry: `pypi`
- Package: `platformio.mcp`
- Version: `0.1.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-22.

- **Supply Chain Security**: 43/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs a script at install time (build_backend) that we could not recognise. It may be perfectly ordinary, but we do not read the published tarball, so we cannot say what it does.
  - 2 of 30 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 35/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (MIT License) isn't a recognized OSI-approved license.
  - Actively maintained (last published 3 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 70/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 2644 tokens (~91/item across 29 items; 29 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "pio_clean" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 30 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the PlatformIO MCP server?

PlatformIO runs locally as a PyPI package, launched with uvx platformio.mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add powerdragonfire-platformio-mcp -- uvx platformio.mcp
```

### Cursor

```json
{
  "mcpServers": {
    "powerdragonfire-platformio-mcp": {
      "command": "uvx",
      "args": [
        "platformio.mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "powerdragonfire-platformio-mcp": {
      "command": "uvx",
      "args": [
        "platformio.mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add powerdragonfire-platformio-mcp -- uvx platformio.mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "powerdragonfire-platformio-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "platformio.mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add powerdragonfire-platformio-mcp --command uvx --arg platformio.mcp
```

### Hermes

```yaml
mcp_servers:
  powerdragonfire-platformio-mcp:
    command: "uvx"
    args: ["platformio.mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "powerdragonfire-platformio-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "platformio.mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add powerdragonfire-platformio-mcp -t stdio -c uvx -a platformio.mcp
```

### Other

```json
{
  "mcpServers": {
    "powerdragonfire-platformio-mcp": {
      "command": "uvx",
      "args": [
        "platformio.mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-17 (score 47, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-16 (score 62)

First indexed and scored.

## MCP tools (29)

### `pio_system_info` (~69 tokens)

Check that PlatformIO is installed and report its version, core directory, the active safety policy (full | build_only | read_only), the log directory, and any open serial monitor sessions. Call this first in a session; if PlatformIO is missing the result tells you how to install it.

### `pio_list_boards` (~112 tokens)

Search PlatformIO's board catalogue (~1,700 boards). Query matches board id, name, MCU, or vendor, e.g. 'esp32-s3', 'uno', 'STM32F4', 'DOIT'. Returns board ids plus MCU, clock, RAM, flash, and frameworks. Use the returned `id` in platformio.ini or pio_project_init.

Input parameters:

- `framework`
- `limit` (integer)
- `platform`
- `query` (string, required)

### `pio_board_info` (~55 tokens)

Full details for one board id: MCU, clock, RAM and flash sizes in bytes, supported frameworks, connectivity, and debug probes. Use it to learn memory limits before writing code.

Input parameters:

- `board_id` (string, required)

### `pio_project_init` (~137 tokens)

Create a new PlatformIO project (or add an environment to an existing one) with `pio project init`. Give an absolute project_dir, a board id from pio_list_boards, and optionally a framework (arduino, espidf, stm32cube, zephyr, ...). project_options are extra platformio.ini keys like 'monitor_speed=115200' or 'lib_deps=bblanchon/ArduinoJson'. Never hand-write platformio.ini for a new project; use this.

Input parameters:

- `board` (string, required)
- `framework`
- `project_dir` (string, required)
- `project_options`

### `pio_project_envs` (~60 tokens)

Read platformio.ini and list every environment with its board, platform, framework, monitor/upload settings, lib_deps, and build_flags, plus which envs are default. Cheap; call before building or flashing.

Input parameters:

- `project_dir`

### `pio_project_metadata` (~60 tokens)

Computed build metadata per environment: defines, include paths, compiler paths and flags, library dirs. Useful for understanding what the compiler actually sees. Triggers platform/toolchain install on first use.

Input parameters:

- `env`
- `project_dir`

### `pio_build` (~96 tokens)

Compile the project (`pio run`). Returns a status, parsed compiler errors and warnings with file/line/column, RAM and Flash usage percentages, the last 40 lines of output, and a path to the full log. Fix the listed errors, then build again. First builds may take minutes while toolchains download.

Input parameters:

- `env`
- `jobs`
- `project_dir`
- `verbose` (boolean)

### `pio_upload` (~80 tokens)

Build and flash firmware to the connected board (`pio run -t upload`). Refuses while a serial monitor session holds the port; stop it first. Pass upload_port when several boards are attached. Blocked when PLATFORMIO_MCP_POLICY is build_only or read_only.

Input parameters:

- `env`
- `project_dir`
- `upload_port`

### `pio_clean` (~51 tokens)

Delete build artifacts for an env (`pio run -t clean`); full=true also removes downloaded dependencies (fullclean).

Input parameters:

- `env`
- `full` (boolean)
- `project_dir`

### `pio_list_targets` (~48 tokens)

List extra build targets the platform offers for this project, such as buildfs, uploadfs, erase, size, or menuconfig.

Input parameters:

- `env`
- `project_dir`

### `pio_run_target` (~74 tokens)

Run one named target from pio_list_targets (e.g. 'buildfs', 'uploadfs', 'erase', 'size'). Flash-related targets follow the same policy rules as pio_upload.

Input parameters:

- `env`
- `project_dir`
- `target` (string, required)
- `upload_port`

### `pio_list_devices` (~64 tokens)

List serial ports (`pio device list`) and flag which ones look like USB dev boards (CP210x, CH340, FTDI, ESP, Arduino, ST-Link...). Use the port with pio_upload, pio_monitor_start, or pio_monitor_capture.

### `pio_monitor_start` (~115 tokens)

Open a background serial monitor session and return a session_id. Port and baud default from platformio.ini (monitor_port/monitor_speed) when project_dir is given, else the single detected dev board and 115200. Output is buffered (ring buffer, max_lines); read it with pio_monitor_read. The session holds the port, so stop it before pio_upload.

Input parameters:

- `baud`
- `env`
- `max_lines` (integer)
- `port`
- `project_dir`

### `pio_monitor_read` (~119 tokens)

Read new serial lines from a session since `cursor` (start at 0) and get the next cursor back. Set wait_for to a regex to block up to timeout_s until a matching line arrives (e.g. wait_for='setup done|Guru Meditation'). Without wait_for and with timeout_s>0 it waits for at least one new line.

Input parameters:

- `cursor` (integer)
- `max_lines` (integer)
- `session_id` (string, required)
- `timeout_s` (number)
- `wait_for`

### `pio_monitor_write` (~59 tokens)

Send text to the device over the open session's serial port (newline appended by default). Blocked under build_only/read_only policy.

Input parameters:

- `newline` (boolean)
- `session_id` (string, required)
- `text` (string, required)

### `pio_monitor_stop` (~28 tokens)

Close a serial monitor session and release the port.

Input parameters:

- `session_id` (string, required)

### `pio_monitor_list` (~28 tokens)

List open serial monitor sessions with port, baud, buffered line count, and next cursor.

### `pio_monitor_capture` (~103 tokens)

One-shot serial capture with no session to manage: open the port, collect output for up to `seconds` (or until regex `until` matches), close the port, and return the lines. Ideal right after pio_upload to grab the boot log.

Input parameters:

- `baud`
- `env`
- `max_lines` (integer)
- `port`
- `project_dir`
- `seconds` (number)
- `until`

### `pio_test` (~140 tokens)

Run PlatformIO unit tests (`pio test`, Unity framework) and return per-case pass/fail with file, line, and message. Tests live in test/test_<name>/. Native envs run on the host; embedded envs build, flash, and read results over serial (set without_uploading=true to only build them). filter/ignore take glob patterns like 'test_math*'.

Input parameters:

- `env`
- `filter`
- `ignore`
- `project_dir`
- `upload_port`
- `verbose` (boolean)
- `without_building` (boolean)
- `without_uploading` (boolean)

### `pio_check` (~97 tokens)

Static analysis (`pio check`, cppcheck by default; clangtidy/pvs-studio if configured). Returns defects grouped and sorted by severity with file, line, CWE, and message. severity is the minimum level to report (low|medium|high).

Input parameters:

- `env`
- `pattern`
- `project_dir`
- `severity` (string)
- `skip_packages` (boolean)
- `tool`

### `pio_pkg_search` (~73 tokens)

Search the PlatformIO registry for libraries (default), platforms, or tools. Returns owner/name specs with the latest version and description. Example query: 'ArduinoJson', 'ssd1306 display', 'mqtt'.

Input parameters:

- `page` (integer)
- `query` (string, required)
- `type` (string)

### `pio_pkg_install` (~101 tokens)

Install a library/platform/tool into the project and add it to platformio.ini (`pio pkg install -l spec`). spec examples: 'bblanchon/ArduinoJson@^7', 'adafruit/Adafruit NeoPixel', 'https://github.com/user/repo.git'. Restrict to one env with env=.

Input parameters:

- `env`
- `project_dir`
- `spec` (string, required)
- `type` (string)

### `pio_pkg_uninstall` (~49 tokens)

Remove a library/platform/tool from the project and platformio.ini.

Input parameters:

- `env`
- `project_dir`
- `spec` (string, required)
- `type` (string)

### `pio_pkg_list` (~37 tokens)

List resolved platform, toolchain, and library packages for the project with versions.

Input parameters:

- `env`
- `project_dir`

### `pio_pkg_outdated` (~31 tokens)

Show which project dependencies have newer versions available.

Input parameters:

- `env`
- `project_dir`

### `pio_pkg_update` (~33 tokens)

Update dependencies within the version ranges declared in platformio.ini.

Input parameters:

- `env`
- `project_dir`

### `pio_decode_backtrace` (~167 tokens)

Turn a crash dump into source locations. Give `text` containing an ESP32/ESP-IDF 'Guru Meditation' register dump and 'Backtrace: 0x...:0x...' line, or a Cortex-M HardFault pc/lr dump, or give `session_id` of an open monitor session to scan its buffer. Resolves every program-counter address with the toolchain's addr2line against the env's firmware.elf and returns function, file, line (with inlined frames) per address, plus the crash cause and reset reason. The ELF must be from the same build that was flashed.

Input parameters:

- `env`
- `include_all_hex` (boolean)
- `project_dir`
- `session_id`
- `text`

### `pio_size_report` (~130 tokens)

Explain where flash and RAM go in the built firmware.elf: text/data/bss totals with percent of the board's flash and RAM, loaded sections classified as flash/ram, the biggest symbols (demangled, with file:line), and per-source-file totals. Use it to shrink firmware on purpose: drop the largest fonts/tables, remove unused features, tune build flags. Run pio_build first; `filter` is a regex applied to symbol names and file paths.

Input parameters:

- `env`
- `filter`
- `project_dir`
- `top` (integer)

### `pio_flash_and_verify` (~208 tokens)

Hardware-in-the-loop check with no human: build + flash (`pio run -t upload`), then open the serial port and watch the boot log until `expect` (regex) matches -> verdict pass, or `fail_on` matches -> verdict fail with the crash automatically decoded to file:line, or timeout_s elapses -> verdict timeout. Port and baud come from platformio.ini (monitor_port/monitor_speed) or the single detected board. Set expect to a line your firmware prints once it is healthy, e.g. 'WiFi connected'. Blocked under build_only/read_only policy.

Input parameters:

- `baud`
- `env`
- `expect` (string)
- `fail_on` (string)
- `max_lines` (integer)
- `monitor_port`
- `project_dir`
- `settle_s` (number)
- `stop_open_sessions` (boolean)
- `timeout_s` (number)
- `upload_port`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp#diagnostics

## Score history

- 2026-09-22: 47
- 2026-09-21: 47
- 2026-09-20: 47
- 2026-09-19: 47
- 2026-09-18: 47
- 2026-09-17: 47
- 2026-09-16: 62

## Common questions

### What is the PlatformIO MCP server?

PlatformIO is an MCP server listed in the public MCP registry as io.github.powerdragonfire/platformio.mcp. PlatformIO for AI agents: build, flash, serial monitor, tests, crash decoding, size reports. This page covers its PyPI package (platformio.mcp).

### Is the PlatformIO MCP server safe to use?

PlatformIO scores 47 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 September 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the PlatformIO MCP server expose?

PlatformIO exposes 29 tools: pio_system_info, pio_list_boards, pio_board_info, pio_project_init, pio_project_envs, and 24 more. Their descriptions and schemas cost roughly 2,424 tokens of context every time the server is loaded.

### Is the PlatformIO MCP server still maintained?

PlatformIO is still listed as active in the MCP registry. We last reached this channel on 22 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- PyPI project: https://pypi.org/project/platformio.mcp/
- Socket report: https://socket.dev/pypi/package/platformio.mcp
- Repository: https://github.com/powerdragonfire/platformio.mcp
- Changelog RSS feed: https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp.json
- HTML version of this page: https://verifymcp.io/servers/powerdragonfire-platformio-mcp/platformio-mcp