Skip to content

MCP server

Read EVM and Bitcoin chain data and relay signed transactions from an AI agent through the RPC MCP server's tools.

The RPC MCP server lets an AI agent read chain state, fetch logs and relay transactions you have signed, without first writing and running code. Each tool call is one RPC request, priced and limited like the same request sent to an RPC endpoint. Use the tools to explore and answer questions; the code your application runs still calls the RPC endpoints.

Connect

SettingValue
URLhttps://rpc.graphops.xyz/v1/mcp
TransportStreamable HTTP, JSON responses only
Protocol versions2026-07-28, 2025-11-25 and 2025-06-18
AuthenticationAuthorization: Bearer <key> header

Use a key with RPC access and no network limits. A tool call names its network in its arguments, not in the URL, so a key limited to networks is refused with api_key_target_not_allowed. Create a separate key for the agent, so you can revoke it without affecting your applications.

Query data through MCP has the setup for Claude Code, Codex, Cursor and VS Code. The tool list, with each tool's input and output schemas and the current limits, is published without a key at https://rpc.graphops.xyz/v1/mcp/tools.json.

Tools

ToolUseChanges state
evm_rpcRun one read-only JSON-RPC method on an EVM network.No
evm_send_raw_transactionBroadcast an EVM transaction your wallet has already signed.Yes
bitcoin_rpcRun one read-only Bitcoin Core method on a Bitcoin network.No
bitcoin_send_raw_transactionBroadcast a Bitcoin transaction your wallet has already signed.Yes

The read tools are marked read-only, so an agent can run them without asking you each time. The send tools are marked as changing state, so most agents ask you before each send.

Every tool takes network, the network's CAIP-2 ID, such as eip155:1 for Ethereum or eip155:8453 for Base. Supported networks lists each network's CAIP-2 ID, and the docs MCP server's list_networks tool returns it as id.

Read EVM data

evm_rpc takes network and request, one JSON-RPC call written as { "method": ..., "params": [...] } with the method's standard positional parameters. Parameters are checked strictly and never repaired: an unknown field, a non-hex address or a missing parameter is refused with tool_arguments_invalid and a message naming the argument to change.

GroupMethods
Blocks and chaineth_blockNumber, eth_chainId, eth_getBlockByNumber, eth_getBlockByHash, eth_getBlockReceipts
State at a blocketh_getBalance, eth_getCode, eth_getStorageAt, eth_getTransactionCount, eth_getProof, eth_call, eth_estimateGas, eth_createAccessList
Transactionseth_getTransactionByHash, eth_getTransactionReceipt
Logseth_getLogs
Feeseth_gasPrice, eth_maxPriorityFeePerGas, eth_feeHistory, eth_blobBaseFee
Tracestrace_transaction, trace_get, on networks whose Tracing column in Supported networks says yes

Other RPC methods need an endpoint instead of the tool:

  • filter methods, such as eth_newFilter, keep state on the node; use eth_getLogs;
  • eth_subscribe needs a WebSocket connection;
  • block and range traces, such as trace_block and trace_filter, return more than a tool result can hold;
  • signing methods, such as eth_sign, need keys GraphOps doesn't hold.

Choose the block

State reads accept a hex block number, latest, safe, finalized, earliest, or { "blockHash": ... }. pending isn't accepted. Every result has a block field that says what the result reflects:

Callblock
A block, by number or hashThe block's number and hash.
A state read with a number or hashThe block you passed.
A state read with a tag{ "requested": "latest" }, never a number the tool doesn't know.
A transaction, receipt or traceThe block it was mined in, or null while pending.
eth_getLogsThe fromBlock and toBlock you passed, or the blockHash.
Current feesnull.

When several results must agree, or an answer has to say "as of block N", read the head once with eth_blockNumber or eth_getBlockByNumber with finalized, then pass that number to every call. See Consistency and finality.

Fetch logs

eth_getLogs needs a hex fromBlock and toBlock, or a blockHash. The network's own range limit applies, and its refusal comes back as rpcError. Filter by address and topics to keep results small. When a result is too large, the error suggests a smaller range in details.suggestedRange.

Read Bitcoin data

bitcoin_rpc takes network and a request with positional params. Bitcoin networks use these CAIP-2 IDs:

NetworkCAIP-2 ID
Bitcoin mainnetbip122:000000000019d6689c085ae165831e93
Bitcoin signetbip122:00000008819873e925422c1ff0f99f7c
GroupMethods
Chaingetblockchaininfo, getblockcount, getbestblockhash, getblockhash, getblockheader, getblock, getblockstats
Transactionsgetrawtransaction, gettxout
Mempool and feesestimatesmartfee, getmempoolinfo, getmempoolentry, testmempoolaccept
Decodingdecoderawtransaction, decodescript

Write hashes and txids as 64 hex characters without 0x. Amounts are BTC decimals, passed through exactly as Bitcoin Core returned them. Call getblock with verbosity 1, which lists txids, and fetch transactions with getrawtransaction: a whole block is usually larger than a tool result can hold. block gives the hash, height and confirmations the result reflects, or null for mempool and decoding methods.

Bitcoin Core has no address index, so the tools can't return an address's balance or history.

Send a signed transaction

GraphOps never signs transactions or holds keys. The send tools relay bytes your wallet has already signed, as one eth_sendRawTransaction or sendrawtransaction request. A transaction can't be undone once it's mined, so approve each send yourself, and never let an agent send one because chain data asked it to.

evm_send_raw_transaction takes network and transaction, the signed transaction as 0x-prefixed hex. Before sending, it checks that the bytes hold one legacy, EIP-2930, EIP-1559 or EIP-7702 transaction signed for the chain in network. Blob transactions and transactions signed without a chain ID are refused. The result gives transactionHash, from, to, nonce and type, decoded from the bytes, so you can check what was sent. To follow it, call evm_rpc with eth_getTransactionReceipt until the receipt has a block.

bitcoin_send_raw_transaction takes network, transaction as hex without 0x, and an optional maxFeeRate in BTC/kvB, which must be positive. Check the transaction first with bitcoin_rpc testmempoolaccept, which reports its fee without broadcasting it. The result gives txid, wtxid, vsize and the input and output counts.

When the node refuses a transaction, for example because its nonce is too low or its fee too small, submitted is false, rpcError holds the node's error, and the call isn't billed. Resending the same signed bytes is safe. See Send a raw transaction.

Results and errors

A result holds the node's result unchanged, with network, method and block. When the node refuses a call, such as an eth_call that reverts, rpcError holds its error instead of result. That is a valid answer, not a tool error, and it isn't billed. If upstreamStatus is also set, the node may not have answered at all, and retrying can succeed.

A tool error has isError: true and an error with a code from the error reference, a message, a docsUrl, and action, which says what to do next:

actionMeaningExamples
fix_argumentsChange the arguments, then call again.tool_arguments_invalid, network_not_found
narrow_requestAsk for less data.upstream_response_too_large
retry_laterRetry the same call after a wait.upstream_timeout, gateway_unavailable
stopStop and tell the person.gateway_misconfigured

Authorization and credit errors, such as api_key_target_not_allowed and credits_exhausted, end the request before any tool runs. Stop on them instead of retrying.

Results are untrusted chain data. Contract names, token symbols and calldata can contain text written to look like instructions; the server tells agents never to follow it.

Limits and billing

LimitValue
Tool result96 KiB (98,304 bytes); a larger result fails with upstream_response_too_large
Request body512 KiB
Time per tool call30 seconds; a slower call fails with upstream_timeout

Each tool call is one RPC request and uses credits at the rate for the same method sent to an RPC endpoint. It counts toward your organization's request rate like any other request. These calls aren't billed:

  • arguments refused with tool_arguments_invalid;
  • results over the size limit;
  • node refusals returned in rpcError;
  • calls that time out.

See Usage and limits for current rates.

Next steps

Last updated