Parano1d node

parano1d-mcp

An unofficial MCP server for a Parano1d node. 18 tools over stdio, read-only by default. The node's wallet signs; the server never sees a private key.

Unofficial community project, not affiliated with the Parano1d Core team.

parano1d-mcp connects an MCP client — an editor, a desktop app, or any agent that speaks the Model Context Protocol over stdio — to a Parano1d node on the same machine. It maps the node's JSON-RPC API onto typed tools and enforces access modes, spend caps and activation gates in code.

It exists because raw RPC access is all-or-nothing: any client that can reach the node can also spend from its wallet. This server makes spending a separate, explicit, capped action, while keeping reads unrestricted.

Status

v0.1.5, pre-release. Read-only mode is the supported deployment. Wallet mode is opt-in and capped; admin mode and contract/native writes have not been exercised on mainnet (sends, consolidation, contract and native writes have been exercised on a private test network). The server has not been independently audited.

Safety at a glance

• Read-only by default. wallet and admin are explicit opt-in modes.
• No key material and no signing code. The node's wallet signs.
• Loopback-only HTTP. No remote RPC, no TLS, no listening port.
• Every spend needs a per-call cap. NOID sends also need a one-time plan and an exact confirmation; consolidation and native writes need a one-time plan; contract funding and calls need an explicit fee and are checked against the node's preview.
• Writes never retry.

What it is

• A local stdio MCP server for one Parano1d node. One process per node.
• A typed view of the node's RPC: 79 methods on node v2.1.0, 68 on v2.0.4, detected at runtime.
• A guard layer: mode gates, per-call spend caps, quote-bound sends, native activation gating, and a read-only RPC passthrough.
• A single Rust binary. No runtime, no TLS stack, no telemetry, no filesystem access.

What it is not

• Not a wallet or signer. It holds no keys, has no signing code, and cannot create or export a seed. In wallet mode it can ask the node's wallet to send, within caps.
• Not a node, miner, or process supervisor. It does not start, restart, or supervise the node. The only control call is an admin-only graceful stop.
• Not a remote or multi-user service. It opens no port, has no authentication, and refuses non-loopback RPC URLs.
• Not an HTTP MCP server. The transport is stdio only.
• Not a sandbox. Any local process that can reach 127.0.0.1:9601 already has the node's owner scope, with or without this server.
• Not a generic blockchain tool. It targets Parano1d's RPC and tracks its method surface.
• Not audited.

Requirements

• Parano1d node v2.0.4 or v2.1.0, RPC at http://127.0.0.1:9601 (default). No node yet? See Get a Parano1d node.
• Rust 1.96 to build; prebuilt binaries need no toolchain.
• The server must run on the same host as the node, because the RPC URL is restricted to loopback.

Get a Parano1d node

parano1d-mcp is a bridge: every tool reads from, or writes through, a Parano1d node running on the same machine. Without one, each tool (and --check) answers *"No Parano1d node answered at http://127.0.0.1:9601. Install and start one: https://parano1d.org (Downloads), then retry."* Get the node from the official Parano1d project; this repository links to it and does not redistribute it.

Desktop app (simplest). Download the GUI wallet for your computer from parano1d.org (Downloads): Windows x86-64, macOS (Apple Silicon or Intel), or Debian/Ubuntu (x86-64 or ARM64). The app runs its own full node and serves JSON-RPC on 127.0.0.1:9601, this server's default, so no configuration is needed; keep the app open while you use the MCP server. Verify the download against SHA256SUMS from the same release.

Headless (servers, automation). Download the Core archive for your platform (parano1d-core-vVERSION- , with parano1d, parano1d-cli and parano1d-miner) and SHA256SUMS from the official releases: git.parano1d.org/ignotusnemo/parano1d/releases (canonical) or the GitHub mirror github.com/proof-native/parano1d/releases. Check the digest before extracting, then:

./parano1d --check-hardware                          # must end with: NODE READY

./parano1d --mode node --rpc-listen 127.0.0.1:9601 # an ordinary, non-mining node

In another terminal, ./parano1d-cli status shows the node, and parano1d-mcp --check shows what this server sees. 127.0.0.1:9601 is the node's default RPC listener; keep it on loopback and never expose port 9601. On first start the node creates ~/.parano1d/parano1d.toml and ~/.parano1d/data/ (--data-dir PATH picks another directory). To run it as a service, follow upstream's Run a node on Linux. If your node listens elsewhere on loopback, set PARANOID_RPC_URL (see Configuration).

What the node needs.

• CPU: x86-64 with SSE4.1 and PCLMULQDQ, or ARM64 with NEON and PMULL. --check-hardware confirms it; a VM can hide these instructions even on a newer host.
• Memory: upstream qualified verifying nodes on 4 CPU cores and 8 GiB RAM, with a 1.65 GiB peak under full workloads. A v2.1.0 mainnet node has also kept up with the tip on a 1 GB RAM VM.
• Disk: no fixed figure: a node keeps compact headers, the current UTXO State and only the latest 42 block bodies, so it grows with State, not with chain age. Leave room for one staged snapshot. A desktop node's data directory measured about 45 MB on 2026-11-06 (du -sh ~/.parano1d/data). Use an SSD.
• Sync: a new node bootstraps from a proof: it authenticates the current State and verifies the recent blocks instead of replaying the whole history.
• Network: persistent outbound TCP; inbound TCP 9600 only for a public node.

Quick start

Install from crates.io

cargo install parano1d-mcp --locked

This builds the server from source with the pinned dependency set and puts parano1d-mcp in ~/.cargo/bin. MCP clients then run it by name (or by its full path). Prebuilt binaries are listed below.

Build from the repository

git clone https://github.com/noidium/parano1d-mcp

cd parano1d-mcp cargo build --release --locked

The binary is target/release/parano1d-mcp (or ~/.cargo/bin/parano1d-mcp after cargo install). It reads environment variables and speaks MCP on stdin/stdout. --check, --version and --help are diagnostic entry points; there is no config file.

./target/release/parano1d-mcp --check

--check probes the node, prints its capabilities and exits 0 (or 1 if the node could not be read). It does not start the MCP server.

Register with an MCP client

Add a stdio server entry that runs the binary. Cursor (.cursor/mcp.json) and VS Code (.vscode/mcp.json) accept this shape; VS Code uses a servers object with "type": "stdio" and passes the same fields.

{

"mcpServers": { "parano1d": { "command": "/absolute/path/to/parano1d-mcp", "env": { "PARANOID_MCP_MODE": "read" } } } }

Start a new session and ask for the node overview. node_overview returns mode: "read", the chain tip, and the node's contract and native capabilities. Any client that can launch a process and speak MCP over stdio works.

Prebuilt binaries

Each release attaches archives for macOS (arm64), Linux (x86_64) and Windows (x86_64), a SHA-256 checksum file and build-provenance attestations. Verify a download before running it:

sha256sum -c SHA256SUMS                       # or: shasum -a 256 -c SHA256SUMS

gh attestation verify parano1d-mcp-v0.1.5-macos-arm64.tar.gz --repo noidium/parano1d-mcp

The binaries are built with cargo auditable, so cargo audit bin also audits the exact dependency set that shipped.

Configuration

All configuration is environment variables. There are no secrets and no config file.

Mode changes require restarting the server.

Modes

Modes are cumulative and enforced per method in src/manifest.rs. A tool that is not allowed in the current mode returns an error; it does not silently no-op.

Tools

Method semantics follow the node's JSON-RPC API. The compiled manifest in src/manifest.rs is the authoritative list of exposed methods, access classes and activation gates.

| wallet_send | wallet | Send NOID from the active address. Requires a ma