# Molpha MCP [Health: Active]

**Category:** 💰 Finance & Fintech  
**Repository:** https://github.com/molpha/mcp  
**GitHub Stars:** 2  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/molpha-mcp

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

## Tools
Capabilities this server exposes over MCP:

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

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: high). Install path detected from listing signals. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "molpha-mcp": {
    "url": "https://api.devnet.solana.com"
  }
}
```

## Documentation

## What Molpha MCP MCP server does

Molpha MCP connects an MCP client to Molpha oracle workflows. It lets an agent inspect network capabilities, derive feed identifiers from an API configuration, read feed state, request signed data, prepare cross-chain verifier arguments, and publish a signed update to a Solana feed.

The server supports a workflow in which HTTP API responses become threshold-signed payloads. Those payloads can be used with Solana, EVM, and Starknet verifier deployments. The server itself settles the Solana leg, while EVM and Starknet operations stop at generated calldata for the agent or another transaction executor to submit.

## How it works

Feed identifiers can be derived locally from an API specification and the required signature count. This operation does not create a transaction or require a subscription. Feeds are created lazily when a result is first settled.

A signing round can be paid through an active USDC subscription, an x402 request, or an automatic choice between those methods. The response from `molpha_fetch_verified` contains the signed artifact and verifier arguments. That response can be passed directly to `molpha_execute`, without remapping fields, or used with `molpha_verify` to obtain EVM or Starknet call data.

`molpha_verify` deliberately does not submit a transaction or perform an on-chain verification. For Solana, the agent can submit through `molpha_execute` or request submission with `autoSubmit` during the fetch operation, then read the stored value using `molpha_get_latest`.

## Tools and capabilities

Molpha MCP MCP server provides these tools:

- `molpha_get_capabilities` reports registry, node, gateway, chain, verifier, and x402 information.
- `molpha_describe_feed` reads feed state and subscription status, using a feed ID or derivation inputs.
- `molpha_derive_feed` calculates a feed ID without sending a transaction.
- `molpha_agent_status` reads the current signer's x402 escrow balance, committed amount, and next quoted price.
- `molpha_fetch_verified` runs a signing round and returns signed data plus verifier arguments.
- `molpha_get_latest` reads the latest value in a Solana feed account.
- `molpha_verify` builds EVM or Starknet verifier addresses and calldata.
- `molpha_execute` submits a signed update to Solana.

## Setup and configuration

The documented setup requires Node.js 20 or newer. Install dependencies, copy `.env.example` to `.env`, and build the project with `npm ci` followed by `npm run build`. `npm run doctor` checks the compiled entry point, signer configuration, wallet availability, and Solana RPC settings.

For local signing, configure `SIGNER_BACKEND=memory`, set `OWNER_KEYPAIR` to a Solana JSON keypair path, and provide `SOLANA_RPC`. An absolute keypair path is recommended when an MCP client launches the process. Privy and Turnkey are also supported through the keychain backend and their respective credentials.

The wallet owns feeds, signs Solana transactions, authenticates gateway requests, and may fund x402 escrow. Keep wallet files, credentials, and `.env` outside source control. Subscription provisioning is performed with the repository's CLI rather than an MCP tool, and it supports dry-run previews and maximum-price caps.

The server communicates through stdio JSON-RPC. It can be connected to Claude Desktop, Cursor, or Codex using the built JavaScript entry point at `dist/src/server.js`. Claude Desktop also has a repository-provided MCP Bundle manifest. Restart the client after changing configuration or rebuilding.

## Limitations and notes

Molpha MCP MCP server targets Solana Devnet and Sepolia verifier networks in this release. Write operations spend SOL, and signing requests can consume subscription quota unless dry-run behavior is enabled.

EVM and Starknet verification is not submitted by the server. There is also no standalone Solana verification-simulation tool; the documented Solana path is to submit the update and then read the resulting value. Public API endpoints should return stable, independently reproducible data, because differing responses across oracle nodes can prevent quorum.

_Full upstream README: https://allmcps.com/mcp/molpha-mcp/readme_