Molpha MCP

Official registry Security

MCP server that lets AI agents create, fetch, verify, and publish Molpha oracle data.

Install

Add this to your client's MCP configuration (Claude Desktop: claude_desktop_config.json; Cursor: .cursor/mcp.json; VS Code and others use the same "mcpServers" shape).

NPM package @molpha/mcp

Claude Code

claude mcp add molpha-mcp -e 'SIGNER_BACKEND=memory' -e 'OWNER_KEYPAIR=<OWNER_KEYPAIR>' -e 'KEYCHAIN_BACKEND=<KEYCHAIN_BACKEND>' -e 'PRIVY_APP_ID=<your privy_app_id>' -e 'PRIVY_APP_SECRET=<your privy_app_secret>' -e 'PRIVY_WALLET_ID=<your privy_wallet_id>' -e 'PRIVY_WALLET_ADDRESS=<PRIVY_WALLET_ADDRESS>' -e 'TURNKEY_API_PUBLIC_KEY=<your turnkey_api_public_key>' -e 'TURNKEY_API_PRIVATE_KEY=<your turnkey_api_private_key>' -e 'TURNKEY_ORGANIZATION_ID=<your turnkey_organization_id>' -e 'TURNKEY_WALLET_ADDRESS=<TURNKEY_WALLET_ADDRESS>' -e 'SOLANA_RPC=https://api.devnet.solana.com' -e 'GATEWAY_ENDPOINTS=<GATEWAY_ENDPOINTS>' -e 'MOLPHA_EVM_NETWORKS=evm-sepolia' -e 'MOLPHA_STARKNET_NETWORKS=starknet-sepolia' -e 'MOLPHA_DRY_RUN=false' -e 'MOLPHA_MAX_EXECUTES_PER_DAY=100' -e 'MOLPHA_X402_MAX_PRICE_USDC=1' -e 'MOLPHA_X402_MAX_SPEND_PER_DAY_USDC=10' -e 'MOLPHA_X402_GATEWAY_PDA=<MOLPHA_X402_GATEWAY_PDA>' -- npx -y @molpha/mcp@0.1.2

JSON configuration (Claude Desktop, Cursor, VS Code)

{
    "mcpServers": {
        "molpha-mcp": {
            "command": "npx",
            "args": [
                "-y",
                "@molpha/mcp@0.1.2"
            ],
            "env": {
                "SIGNER_BACKEND": "memory",
                "OWNER_KEYPAIR": "<OWNER_KEYPAIR>",
                "KEYCHAIN_BACKEND": "<KEYCHAIN_BACKEND>",
                "PRIVY_APP_ID": "<your privy_app_id>",
                "PRIVY_APP_SECRET": "<your privy_app_secret>",
                "PRIVY_WALLET_ID": "<your privy_wallet_id>",
                "PRIVY_WALLET_ADDRESS": "<PRIVY_WALLET_ADDRESS>",
                "TURNKEY_API_PUBLIC_KEY": "<your turnkey_api_public_key>",
                "TURNKEY_API_PRIVATE_KEY": "<your turnkey_api_private_key>",
                "TURNKEY_ORGANIZATION_ID": "<your turnkey_organization_id>",
                "TURNKEY_WALLET_ADDRESS": "<TURNKEY_WALLET_ADDRESS>",
                "SOLANA_RPC": "https://api.devnet.solana.com",
                "GATEWAY_ENDPOINTS": "<GATEWAY_ENDPOINTS>",
                "MOLPHA_EVM_NETWORKS": "evm-sepolia",
                "MOLPHA_STARKNET_NETWORKS": "starknet-sepolia",
                "MOLPHA_DRY_RUN": "false",
                "MOLPHA_MAX_EXECUTES_PER_DAY": "100",
                "MOLPHA_X402_MAX_PRICE_USDC": "1",
                "MOLPHA_X402_MAX_SPEND_PER_DAY_USDC": "10",
                "MOLPHA_X402_GATEWAY_PDA": "<MOLPHA_X402_GATEWAY_PDA>"
            }
        }
    }
}

Environment variables

SIGNER_BACKEND required Signing backend: memory (local keypair) or keychain (Privy / Turnkey).
OWNER_KEYPAIR Path to a Solana JSON keypair file. Required when SIGNER_BACKEND=memory.
KEYCHAIN_BACKEND Keychain provider: privy or turnkey. Required when SIGNER_BACKEND=keychain.
PRIVY_APP_ID secret Privy app ID. Required for KEYCHAIN_BACKEND=privy.
PRIVY_APP_SECRET secret Privy app secret. Required for KEYCHAIN_BACKEND=privy.
PRIVY_WALLET_ID secret Privy wallet ID. Required for KEYCHAIN_BACKEND=privy.
PRIVY_WALLET_ADDRESS Solana address for the Privy wallet.
TURNKEY_API_PUBLIC_KEY secret Turnkey API public key. Required for KEYCHAIN_BACKEND=turnkey.
TURNKEY_API_PRIVATE_KEY secret Turnkey API private key. Required for KEYCHAIN_BACKEND=turnkey.
TURNKEY_ORGANIZATION_ID secret Turnkey organization ID. Required for KEYCHAIN_BACKEND=turnkey.
TURNKEY_WALLET_ADDRESS Solana address for the Turnkey wallet.
SOLANA_RPC Solana RPC endpoint.
GATEWAY_ENDPOINTS Comma-separated Molpha gateway URLs. Leave empty to use the SDK default.
MOLPHA_EVM_NETWORKS Comma-separated EVM verifier networks.
MOLPHA_STARKNET_NETWORKS Comma-separated Starknet verifier networks.
MOLPHA_DRY_RUN Preview all write and spend operations without submitting them.
MOLPHA_MAX_EXECUTES_PER_DAY Process-local daily Solana submit cap.
MOLPHA_X402_MAX_PRICE_USDC Refuse to fund an x402 round priced above this amount (decimal USDC).
MOLPHA_X402_MAX_SPEND_PER_DAY_USDC Process-local daily x402 spend cap (decimal USDC).
MOLPHA_X402_GATEWAY_PDA Optional settling gateway PDA (base58) to skip discovery when the escrow is already funded.

Documentation

From the project's README on GitHub, refreshed weekly. Links open on GitHub.

Contents

Molpha MCP
Quick start
Tools
Setup
Example prompts
How it works
Development
Documentation
License

Molpha MCP

A Model Context Protocol (MCP) server that lets AI agents fetch signed Molpha oracle data, publish it on Solana, and build verifier calldata for EVM and Starknet.

Molpha turns HTTP API responses into threshold-signed payloads that can be verified on Solana, EVM, and Starknet. This server exposes that workflow as MCP tools, with signing behind a local, Privy, or Turnkey wallet, or, on mcp.molpha.io, behind your own wallet.

[!WARNING] This release targets Solana Devnet and Sepolia verifier networks. Treat it as testnet software, not a production security boundary. Write tools spend SOL, and round tools may consume subscription quota or pay USDC for x402 rounds, unless dry-run mode is enabled.

Quick start

Two recommended ways to connect:

	mcp.molpha.io	Local (stdio)
Install	Nothing: add the URL to your client	`npx`, Node.js 24 or later
Signer	Your own wallet. The server holds no key.	Local keypair, Privy or Turnkey, held by the server
Subscription rounds	Sign in with SIWX, then `execute_subscription_round`	`execute_subscription_round`
Spending limits	Your wallet's own policy	Dry-run lock and daily caps in the server
Best for	Getting started, agents that bring their own wallet	Unattended agents, private API sources

mcp.molpha.io

Nothing to install, and no keys to hand over. Add the URL to your client.

Claude Code:

claude mcp add --transport http molpha https://mcp.molpha.io/mcp

Cursor (.cursor/mcp.json):

{ "mcpServers": { "molpha": { "url": "https://mcp.molpha.io/mcp" } } }

The read tools work straight away. The server has no wallet of its own, so name the one you mean: submitter for describe_feed and get_latest_value, payer for get_x402_status.

Anything that needs a signature is returned for your own wallet to sign, so each such operation is two or three tool calls around one signature:

Operation	Tools, in order	The wallet signs
Subscription round	`begin_session` → `complete_session` → `execute_subscription_round`	A text message, once per session
x402 round	`prepare_x402_round` → `execute_x402_round`	A USDC transfer, not broadcast
Solana submit	`prepare_submit_attestation` → `send_signed_transaction`	The submit transaction

autoSubmit, dryRun and encryptSecrets are not offered here. Set spending limits in the wallet's own policy, and use the local server for private API work.

A subscription round on mcp.molpha.io is authorized by a sign-in session: the wallet signs one Sign-In-With-X text message (the x402 sign-in-with-x extension, in its Solana form), and the gateway issues a short-lived bearer token. The message is not a transaction and moves no funds.

Step	Call	Result
1	`describe_access({ address, owner? })`	Whether the wallet is a subscription `owner` or `delegate`, and its limits
2	`begin_session({ address, owner? })`	The `message` to sign and an opaque `challenge`
3	The wallet signs `message`	An Ed25519 signature over its exact UTF-8 bytes
4	`complete_session({ challenge, signature })`	A `sessionToken` and its `expiresAt`
5	`execute_subscription_round({ sessionToken, apiConfig, signaturesRequired, chains })`	The signed attestation and verifier arguments

Who can sign in. The subscription owner, or a delegate the owner added with add_delegate. A delegate passes the owner's address as owner.
How to sign. The message as returned: raw UTF-8, no prefix, no envelope, no trailing newline. The signature may be base58, base64 or hex. solana sign-offchain-message wraps the text and is refused with invalid_signature.
What the token is. A credential for one wallet and one gateway, valid 30 minutes by default and never past the subscription term. It only identifies the caller: the gateway re-reads the subscription and delegate from chain on every round, so remove_delegate ends access whatever tokens exist. It passes through this server and is never stored or logged.
What it needs. A gateway with sessionAuth: true in GET /v1/info. Otherwise begin_session answers sessions_unavailable and x402 rounds remain available.

The full walkthrough, with a signing example, delegate setup, gateway routes and error codes, is in docs/integration.md.

Local (stdio)

The server runs on your machine and holds the signer, so one tool call runs a round or submits to Solana, and MOLPHA_DRY_RUN keeps every write a preview until you turn it off.

Needs Node.js 24 or later. Nothing to clone or build.

1. Look around, no wallet. Read-only: capabilities, providers, sourceIds, prices, feed values.

claude mcp add molpha -- npx -y @molpha/mcp@0.2.0 --read-only

2. Build with a testnet wallet. Put your signer settings in a .env file (see Setup), then check them. The doctor prints a ready-to-paste config for your client, with secrets left as placeholders:

npx -y @molpha/mcp@0.2.0 doctor

A config like this keeps every write a preview (MOLPHA_DRY_RUN=true):

claude mcp add molpha -e SIGNER_BACKEND=keychain -e KEYCHAIN_BACKEND=privy -e PRIVY_APP_ID='<privy-app-id>' -e PRIVY_APP_SECRET='<privy-app-secret>' -e PRIVY_WALLET_ID='<privy-wallet-id>' -e PRIVY_WALLET_ADDRESS='<base58-solana-address>' -e MOLPHA_DRY_RUN=true -- npx -y @molpha/mcp@0.2.0

3. Spend only when you mean to: fund the wallet, then set MOLPHA_DRY_RUN=false in the server's config. The full guide, with Cursor, VS Code, Codex and Claude Desktop, is docs/integration.md.

With no signer configured the server starts read-only and offers only the read tools (runLevel: "read-only" in get_capabilities). --read-only or SIGNER_BACKEND=none forces it.

Tools

Tool	Access	Description
`get_capabilities`	Read	Run level, program id, registry version, nodes, gateways, chains, verifier addresses, x402 caps and source-payment policy.
`derive_source_id`	Read, local	Derive an `apiConfig`'s `sourceId` (how). No transaction, no wallet.
`describe_feed`	Read	Read the Solana feed for `(sourceId, signaturesRequired, submitter)` and the signer's subscription status.
`get_latest_value`	Read	Read the latest attested value stored in a Solana feed account.
`describe_access`	Read	Whether a wallet is a subscription owner or delegate, with the plan's and the delegate's limits.
`get_x402_status`	Read	Quote the next x402 round, show where payment goes, and read a payer's USDC balance and remaining daily budget.
`list_providers`	Read	The data providers the gateway integrates and the flows it serves (providers).
`get_provider`	Read	One provider's flows, disclosure and ready-made feeds, each with a complete `apiConfig` and `sourceId`.
`quote_source_payment`	Read	Price a paywalled source with one unpaid request, including the worst-case total.
`execute_subscription_round`	Spends quota	Run a round paid from a USDC subscription; return the signed attestation plus verifier arguments. `autoSubmit: true` settles Solana in the same call.
`execute_x402_round`	Spends USDC	Run a round paid per request over x402; same output.
`build_verifier_calldata`	Read, local	Build EVM/Starknet verifier address and `verify()` call arguments. Calldata only: it verifies nothing.
`submit_attestation`	Write	Submit a signed attestation to Solana. Accepts a round tool's output unmodified.

On mcp.molpha.io the one-call round and submit tools become prepare/sign/execute pairs (above). Every tool returns structuredContent and carries MCP annotations; see Structured output and annotations. For tolerance-mode aggregation and the full configuration table, see docs/reference.md.

Round timing. Rounds run on a fixed 100 ms tick. Requests for one feed (the same source and quorum) inside one tick share a round, so a feed runs at most 10 rounds per second, and one wallet gets at most one round per tick for a feed: a second request in the same tick is answered with HTTP 409, which the round tools retry a tick later before failing with round_conflict. See Round timing.

Setup

For the local server.

Signer. Put your settings in a .env file and check them with the doctor. It prints a ready-to-paste config for your client with secrets left as placeholders. Use a dedicated testnet wallet.

SIGNER_BACKEND=memory
OWNER_KEYPAIR=/absolute/path/to/owner-keypair.json
SOLANA_RPC=https://api.devnet.solana.com
MOLPHA_DRY_RUN=true

Privy and Turnkey settings are in docs/reference.md and .env.example.

npx -y @molpha/mcp@0.2.0 doctor

Dry-run lock. MOLPHA_DRY_RUN=true locks execute_subscription_round, execute_x402_round and submit_attestation to previews. A call with dryRun: false is refused with dry_run_locked, so going live is a change to the server's config, never to one tool call.

Subscription. Subscribing debits USDC, so it is kept out of the MCP tools and runs as a CLI command with the same signer configuration. --max-price-usdc is a cap in USDC base units (6 decimals); drop --dry-run to subscribe, or use extend to extend one.

npx -y @molpha/mcp@0.2.0 provision subscribe --plan Basic --max-price-usdc 20000000 --dry-run

Client. Every client launches the local server with npx. Snippets for Claude Code, Cursor, VS Code, Codex and Claude Desktop are in docs/integration.md, ready-to-edit copies are in examples, and Claude Desktop users can install the molpha-mcp.mcpb bundle attached to each release.

Example prompts

Discover. Use Molpha to inspect the current oracle capabilities. Summarize the registry version, node count, chains, gateways, and verifier addresses. Make no writes.

Derive. Derive a Molpha sourceId for https://api.example.com/v1/finalized/price using the JSON path $.price. Show me the canonical JSON and the sourceId. Do not send a transaction.

Fetch. For that source, run a subscription round with 3 signatures for the EVM chain. Summarize the value, timestamp, registry version and verifier call. Treat the signed attestation as the trust anchor, not the value alone.

Provider. List the integrated data providers, describe TickerLayer's btcusd feed, and run it with 3 signatures for Solana, passing the apiConfig exactly as given.

Check spend. Call get_x402_status for 3 signatures. Tell me the price, where payment goes, and my USDC balance before I authorize an execute_x402_round.

Publish. If I give you a newer signed attestation, preview submit_attestation with dryRun: true, explain the exact write, and wait for my confirmation before submitting.

Use a public endpoint that returns stable, independently reproducible data: live ticker endpoints may differ across oracle nodes and fail to reach quorum.

How it works

flowchart LR
    Client["MCP client"] <-->|"stdio / HTTP"| Server["Molpha MCP server"]
    Server --> Guardrails["Dry-run · daily caps · spend caps"]
    Server --> Signer["Signer adapter<br/>local · Privy · Turnkey"]
    Server --> SDK["Molpha SDK / x402 client"]
    SDK --> Gateway["Molpha gateway"]
    Gateway <--> Nodes["Oracle node quorum"]
    SDK <--> Solana["Solana program<br/>feeds · subscriptions"]
    Gateway --> Artifact["Threshold-signed attestation"]
    Artifact --> Server
    Server --> Args["EVM / Starknet verifier args,<br/>or submit_attestation on Solana"]

The server is an adapter and policy boundary, not a new source of truth. Oracle nodes independently fetch the committed API configuration and produce one aggregate signature after reaching quorum; the server returns that self-contained signed artifact. Consumers trust a value only after verifying the signed payload against its registry version.

Development

git clone https://github.com/molpha/mcp.git
cd mcp
npm ci
cp .env.example .env
npm run build

Point a client at the built server with node /absolute/path/to/mcp/dist/src/server.js.

npm run dev          # start from TypeScript
npm run typecheck && npm test && npm run build   # run before opening a pull request
npm run gen:install  # rewrite the generated install snippets in the docs and examples
npm run smoke:pack   # pack the tarball and run it with npx over stdio (needs network)
npm run pack:mcpb    # build the Claude Desktop bundle from an allowlist

@molpha/sdk is pinned to an exact version and resolved from the npm registry; to try a local checkout run npm install ../sdk and do not commit the result. Install snippets are generated from src/install-config.ts: edit the renderers, not the generated text, because npm test fails when a generated file is out of date.

Versioning and publishing use Changesets: if a pull request changes published behavior, run npx changeset. On merge to main, release.yml opens a "Version Packages" PR and, when that merges, publishes @molpha/mcp to npm (trusted publishing, no token) and server.json to the MCP registry.

Bug reports and focused pull requests are welcome. For security issues, use GitHub's private vulnerability reporting instead of a public issue.

Documentation

Integration guide: install per client, spending, signing in with your own wallet (SIWX), and running the HTTP server yourself
Reference: sourceId, tolerance mode, x402, providers, configuration, signers
Molpha protocol documentation
Client configuration examples and the MCPB manifest

License

Released under the MIT License.

Frequently asked questions

What is Molpha MCP?

MCP server that lets AI agents create, fetch, verify, and publish Molpha oracle data.

How do I install Molpha MCP?

It runs on your machine. In Claude Code: claude mcp add molpha-mcp -e 'SIGNER_BACKEND=memory' -e 'OWNER_KEYPAIR=<OWNER_KEYPAIR>' -e 'KEYCHAIN_BACKEND=<KEYCHAIN_BACKEND>' -e 'PRIVY_APP_ID=<your privy_app_id>' -e 'PRIVY_APP_SECRET=<your privy_app_secret>' -e 'PRIVY_WALLET_ID=<your privy_wallet_id>' -e 'PRIVY_WALLET_ADDRESS=<PRIVY_WALLET_ADDRESS>' -e 'TURNKEY_API_PUBLIC_KEY=<your turnkey_api_public_key>' -e 'TURNKEY_API_PRIVATE_KEY=<your turnkey_api_private_key>' -e 'TURNKEY_ORGANIZATION_ID=<your turnkey_organization_id>' -e 'TURNKEY_WALLET_ADDRESS=<TURNKEY_WALLET_ADDRESS>' -e 'SOLANA_RPC=https://api.devnet.solana.com' -e 'GATEWAY_ENDPOINTS=<GATEWAY_ENDPOINTS>' -e 'MOLPHA_EVM_NETWORKS=evm-sepolia' -e 'MOLPHA_STARKNET_NETWORKS=starknet-sepolia' -e 'MOLPHA_DRY_RUN=false' -e 'MOLPHA_MAX_EXECUTES_PER_DAY=100' -e 'MOLPHA_X402_MAX_PRICE_USDC=1' -e 'MOLPHA_X402_MAX_SPEND_PER_DAY_USDC=10' -e 'MOLPHA_X402_GATEWAY_PDA=<MOLPHA_X402_GATEWAY_PDA>' -- npx -y @molpha/mcp@0.1.2. For other clients, paste the JSON configuration from this page into their MCP settings.

Does Molpha MCP need an API key?

Yes. It expects SIGNER_BACKEND, PRIVY_APP_ID, PRIVY_APP_SECRET, PRIVY_WALLET_ID, TURNKEY_API_PUBLIC_KEY, TURNKEY_API_PRIVATE_KEY, TURNKEY_ORGANIZATION_ID, which you set in its configuration.

Is Molpha MCP open source?

Yes. Its code is on GitHub under the MIT license.

Who maintains Molpha MCP?

It is published by molpha. AI.tn lists it but does not maintain or endorse it.

From the official MCP Registry. Listing is not an endorsement: review a server's code and permissions before giving it access to your data.

Server details

Listed in: Official MCP Registry
Publisher: molpha
Category: Security
Runs: Local
GitHub stars: ★ 2
License: MIT
Language: TypeScript
Last commit: Oct 11, 2026
Open issues: 2
Version: 0.1.2
Published: Jul 21, 2026

io.github.molpha/mcp

Similar servers

PatrolTech Security patrol management: missed rounds, suspicious scans, incidents and checkpoint s...
Eclipse Muzzle Secrets + PII scanner. A PASS verdict is scan evidence, not a guarantee of safety or no...
AINumbers Fintech Intelligence Suite 754 MCP tools across 1222 fintech tools: ChainGraph AP2 decisions, execution_hash. Zero...
Governance Gateway Deadline-aware governance for AI agents: PII scan always, safety check if it fits the d...
SEAL Large files and secrets between people and agents, never through the chat or the model.
Corvus Reverse engineering and security analysis of .NET and native binaries: decompile, compa...
mcp-warden Local credential broker: agents call APIs, SSH and DBs via scoped presets; secrets stay...
1Social Publish, schedule and verify social posts across eight networks from your AI assistant.

Security

Molpha MCP

Install

Documentation

Molpha MCP

Quick start

mcp.molpha.io

Sign in with your wallet (SIWX)

Local (stdio)

Tools

Setup

Example prompts

How it works

Development

Documentation

License

Frequently asked questions