RobotBase MCP Server

One MCP endpoint for agents: search the web, read any page, verify on-chain payments, and pay per call — no API keys.

免鉴权 · 无追踪 · 只读 ｜ 自建裸金属全节点，对 Agent 暴露统一的「验证 + 风控」语义入口

Hosted endpoint: 72 tools — ten web tools (search, fetch, screenshot, map, batch, feed, metadata, crawl, extract, act), on-chain verification & risk on Bitcoin · Ethereum · Monero · Zcash · Tron, and 16 CyberLibrary book tools. This repository is the dependency-free reference implementation: 45 tools (41 free verification + 2 risk + 2 web); the hosted endpoint additionally bundles 3 free XMR wallet/merchant tools, 16 CyberLibrary tools and 8 more web tools.

• Install guide for agents: llms-install.md · Privacy: https://robotbase.cc/privacy · Security: SECURITY.md

Base and Solana data tools were retired on 2026-10-18. The five-chain surface is Bitcoin, Ethereum, Monero, Zcash and Tron. x402 payments still settle in USDC on Base or Solana; that is a payment rail, not a data service.

Hosted endpoint: https://robotbase.cc/mcp · Landing page: https://robotbase.cc/mcp · Server card: https://robotbase.cc/mcp/server.json · Live usage audit: https://robotbase.cc/mcp/stats

Listed in the official MCP Registry as io.github.wygogogo19/robotbase-mcp · indexed by Glama · published on Smithery (wygogogo/robotbase-mcp).

Why

An autonomous agent handling crypto has exactly two blocking questions: did this payment actually settle, and what will the next one cost. Ask an LLM those today and it has nowhere reliable to look — the MCP ecosystem is rich in wrappers around hosted indexers and thin on self-run infrastructure.

The hosted endpoint answers with 68 strictly read-only tools (44 free verification tools + 2 metered risk tools + 15 metered CyberLibrary book tools + 7 metered web tools); this reference implementation ships 45 of them (41 free + 2 risk + 2 web). Everything is backed by our own full nodes, local indexes and a metered web layer: btc_get_transaction for the settlement check, btc_get_fee_rates and btc_get_mempool_state for the price of the next one, zec_get_pool_status for Zcash shielded-pool supply, a full Monero surface (xmr_get_fee_rates, xmr_get_transaction, xmr_verify_payment, …) read straight off our own monerod, an Ethereum surface (eth_get_transaction, eth_get_fee_rates, eth_read_contract) on our own Reth node, and a Tron surface (tron_read_contract, tron_get_transaction) on our own java-tron node.

Related MCP server: Blockscout MCP Server

Pricing

Base and Solana are a payment rail only. x402 settles in USDC on Base or Solana, but RobotBase does not serve Base or Solana chain data: those eight data tools were retired on 2026-10-18, and the roster is Bitcoin, Ethereum, Monero, Zcash and Tron.

Every metered answer carries its own _metering block (allowance, reset time, calls left), and a call that fails local validation — a malformed address or txid — does not consume the allowance. Past the free allowance the tool returns Payment Required and names the top-up page instead of a partial result.

There is no API key, no account and no subscription — from 2026-10-16 the paid tier is x402 machine payment only. When the free allowance runs out the tool answers 402 Payment Required with the full machine-readable terms in structuredContent.accepts[]. An agent settles one credit pack (EIP-3009 on Base, a signed transfer on Solana), then re-sends that same payment payload in params._meta["x402/payment"] on every later call: settlement is idempotent per payment nonce, so the payload is never charged twice — each call simply spends one credit until the pack is empty. Buy another pack to continue.

Replay works the same on both networks. For Solana the payload carries only the signed transaction, so the server recovers the payer from the settled-payment ledger by the transaction hash — it never re-simulates a transaction that already landed.

The x402 payment layer (open source)

x402_pay.py is the complete paid-tier implementation and it ships in this repo. It is standard library only — it talks HTTP to your facilitator and keeps a sqlite ledger. It never touches a private key and never submits a transaction.

What it does:

Enable it entirely through environment variables (see examples/x402.env.example):

export RB_X402_ENABLED=1
export RB_X402_FACILITATOR_URL=https://facilitator.example
export RB_X402_OPTIONS='[{"network":"eip155:8453","asset":"0x…","pay_to":"0x…","decimals":6, …}]'
export RB_X402_PACKS='[{"amount_atomic":"100000","calls":10,"label":"10 calls"}]'
export RB_X402_LEDGER_DB=./x402_credit.db
python3 server.py

With those unset, the server runs the free tier only. This repo ships the 45 chain/web tools as a reference implementation — the only differences from the hosted endpoint are where the per-chain backends point (your RB_* variables instead of ours) and the hosted-only CyberLibrary bridge (16 book tools) and eight additional web tools (screenshot, map, batch, feed, metadata, crawl, extract, act), which are not included here.

Check a payer's balance without spending a call:

GET https://robotbase.cc/mcp/credits?payer=<the address that paid>
→ { "found": true, "credits_remaining": 19, "calls_charged": 1,
    "last_payment": { … }, "packs": [ … ] }

EVM addresses are case-insensitive; there is no authentication because the balance is derived from public on-chain payments.

Connect (3 lines)

{
  "mcpServers": {
    "robotbase": { "url": "https://robotbase.cc/mcp" }
  }
}

Works with Claude Desktop, Cursor, VS Code (remote MCP), and any MCP client supporting Streamable HTTP (2025-06-18). No API key needed.

curl -s https://robotbase.cc/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"btc_get_fee_rates","arguments":{}}}'

Tools (45 — reference implementation)

The hosted endpoint https://robotbase.cc/mcp has 72 tools: these 45 plus 3 free XMR wallet/merchant tools, the 16 CyberLibrary book tools (cyberlibrary_catalog_index, cyberlibrary_language_shard, cyberlibrary_book_meta, cyberlibrary_get_toc, cyberlibrary_get_chapter, cyberlibrary_get_markdown, cyberlibrary_cite, cyberlibrary_search_books, cyberlibrary_fulltext_search, cyberlibrary_service_info, cyberlibrary_get_chunks, cyberlibrary_verify_quote, cyberlibrary_search_passages, cyberlibrary_rag_context, cyberlibrary_semantic_search, cyberlibrary_search) and eight additional web tools (web_screenshot, web_map, web_fetch_batch, web_feed, web_metadata, web_crawl, web_extract, web_act).

Risk intelligence (metered)

Two tools answer what a free block explorer cannot. They are aggregation over public datasets refined in our own middle layer; the TRON settlement check reads our own node inside its retention window and falls back to TronGrid for older transactions.

Base and Solana are a payment rail, not a data service. x402 settles in USDC on Base or Solana; the Base/Solana on-chain data tools were retired on 2026-10-18 and no external RPC is queried for chain data.

Each one returns risk_level, a 0-100 safety_score, the verbatim upstream flags it was derived from, a not_covered list and a disclaimer — it relays public labels and forms no legal opinion. Issuer-backed tokens (regulated stablecoins) are read as issuer control rather than as a rug signal, and that decision is stated in the response.

Boundary worth stating plainly: RobotBase does not index Monero transactions, wallets or ring signatures, and does not label or risk-score Bitcoin addresses. Where a node cannot answer, the tool says so instead of guessing.

Web tools (high-frequency)

The hosted endpoint exposes seven web tools: web_search, web_fetch, web_screenshot, web_map, web_fetch_batch, web_feed and web_metadata. This reference implementation ships the first two; the other five are hosted-only.

Two general-purpose web tools sit next to the on-chain surface. They are the entry point an agent uses before it verifies: search the live web, read the one page that looks authoritative, then check the claim on chain. No API key is needed to call them.

Independent free allowance: web_search 20 calls/day per IP and web_fetch 50 calls/day per IP, in separate buckets from the 5/day risk allowance — searching can never consume the risk tools' free calls. A cached search still counts as one call against the free allowance; a paid call answered from cache does not spend a credit. Past the allowance each call is 1 x402 credit ($0.01), charged through the same USDC credit balance as the risk tools.

Boundaries: web_fetch reads one public URL, never a batch or a whole site; it does not log in, break paywalls, follow noindex tricks or bypass robots.txt. All fetching is SSRF-guarded: only http/https, only ports 80/443, private / loopback / link-local / reserved / CGNAT addresses are rejected, every redirect hop is re-validated, the resolved IP is pinned to the connection, and the response body is capped at 2 MB. Audit stores no query string and no URL — only the tool name, latency, result and a truncated IP hash.

Provider configuration (optional). The reference implementation is standard library only. Set RB_SERPER_KEY for the primary search provider, and optionally RB_TAVILY_KEY / RB_BRAVE_KEY for the fallback chain (cn.bing RSS needs no key). Set RB_TAVILY_DAILY_CREDITS (default 15) to cap daily Tavily credits, and RB_SERPER_DAILY_CALLS (default 200) to cap Serper calls. With no provider key at all, web_search degrades to the zero-key cn.bing RSS feed and web_fetch still works for directly reachable pages.

Beyond a generic reader

Most MCP servers wrap a third-party API. These come from infrastructure we operate, which is why they are hard to find elsewhere:

1. Settlement verification — btc_get_transaction / btc_get_block / btc_get_address answer the first question an agent has once a payment is claimed, from our own txindex node.

2. Fee & mempool oracles — btc_get_fee_rates + btc_get_mempool_state answer the second: what the next transaction will cost, and whether now is a good moment.

3. Local indexes — zec_get_pool_status reads our own Zebra node and value-pool index (all six pools with deltas) rather than a public explorer.

4. Optional relay — broadcast_raw_transaction lets an agent sign locally and use us purely as a high-availability broadcast path; it is disabled unless the operator sets RB_ENABLE_BROADCAST=1.

Architecture

   AI Agent (Claude / Cursor / VS Code / custom)
            │  HTTPS · MCP Streamable HTTP (2025-06-18)
            ▼
   https://robotbase.cc/mcp          ← hosted, no auth required
            │
            ▼
   MCP server (dependency-free Python, this repo)
            ├── BTC  : Bitcoin Core RPC + electrs (address/tx index)
            ├── ETH  : Reth (execution) + Lighthouse (consensus)
            ├── XMR  : monerod JSON-RPC (node telemetry only)
            ├── ZEC  : Zebra RPC (valuePools → shielded-pool supply)
            ├── TRON : java-tron lite full node (tip state + a ~6 day window)
            ├── meta : gateway service aggregation
            └── web  : Serper / Tavily / Brave / cn.bing RSS search (optional keys),
                       direct fetch + standard-library extraction, Tavily /extract fallback

Privacy & limits

• No auth at all — robotbase.cc issues no API key, and sending X-API-Key changes nothing.

• 120 req/min per IP, one tier (X-MCP-Plan / X-RateLimit-Limit response headers). Paid access is x402 credit and does not raise the per-IP rate limit.

• Audit stores only a truncated SHA-256 of the client IP — never query parameters.

• Read-only: no trading, signing, custody, or write methods. BTC transactions are looked up with txindex.

• Responses are trimmed to ~3.8 KB per call to protect LLM context; web_fetch is the exception (12,000 characters) because its whole point is to return a page's text.

• Web tools have an extra 20 req/min/IP limit on top of the 120/min/IP overall limit, and their free allowance (20 searches + 50 fetches/day/IP) is tracked in separate buckets.

Self-hosting (this repo)

server.py is a dependency-free reference implementation that talks to your own nodes. Configure everything with environment variables:

export RB_BIND=0.0.0.0            # bind address (default 127.0.0.1)
export RB_PORT=8090               # listen port
export RB_BTC_RPC_URL=http://127.0.0.1:8332
export RB_BTC_RPC_USER=rpcuser
export RB_BTC_RPC_PASS=...
export RB_BTC_DASHBOARD=http://127.0.0.1:8600            # optional: /api/node used by chain_status(btc)
export RB_ELECTRS_HOST=127.0.0.1  # electrs for btc_get_address
export RB_ELECTRS_PORT=50001
export RB_ZEC_BASE=http://127.0.0.1:8080                  # status API with /api/chaininfo
export RB_XMR_HELPER=http://127.0.0.1:18085/rpc           # monerod JSON-RPC (xmr_get_node_status)
export RB_HOME_BASE=http://127.0.0.1:8081                 # gateway aggregation: /api/nodes (eth + xmr telemetry) /api/services
export RB_USAGE_DB=./usage.db                             # optional usage audit
export RB_BILLING_DB=./billing.db                         # deprecated: API-key verification (no keys are issued since 2026-10-16)
export RB_RISK_DB=./risk_quota.db                         # optional: daily risk-tool allowance bookkeeping
export RB_WEB_CACHE_DB=./web_cache.db                     # optional: web result cache + web quota/spend tables
# web tools: no key is required. Optional provider keys buy quality/reliability:
export RB_SERPER_KEY=...                                  # primary search provider (best results)
export RB_TAVILY_KEY=...                                  # fallback search + fetch-extract fallback
export RB_BRAVE_KEY=...                                   # optional extra search fallback
export RB_SERPER_DAILY_CALLS=200                          # optional: daily Serper call cap
export RB_TAVILY_DAILY_CREDITS=15                         # optional: daily Tavily credit cap
export RB_WEB_SEARCH_FREE=20 RB_WEB_FETCH_FREE=50         # optional: per-IP free web allowance
export RB_WEB_SEARCH_GLOBAL=100 RB_WEB_FETCH_GLOBAL=200   # optional: site-wide free web caps
export RB_WEB_DAILY_BUDGET_USD=5                          # optional: daily upstream spend breaker
export RB_WEB_TRUNCATE=12000 RB_WEB_CACHE_MAX_MB=100      # optional: web_fetch cap / cache cap
export RB_WEB_UA='RobotBaseMCP/0.25.2 (+https://robotbase.cc/mcp)'  # optional: crawler User-Agent
# optional paid tier — see examples/x402.env.example for the full list
export RB_X402_ENABLED=1
export RB_X402_FACILITATOR_URL=https://facilitator.example
export RB_X402_OPTIONS='[ … ]'
export RB_X402_PACKS='[ … ]'
export RB_X402_LEDGER_DB=./x402_credit.db
python3 server.py

See examples/ for client configs, examples/env.example for the node variables and examples/x402.env.example for the payment variables. Endpoints exposed by the server itself: / (docs), /tools (tool list JSON), /server.json (server card), /stats (usage audit), /healthz.

Reference implementation history

• 2026-10-19 — v0.25.2: hosted surface reaches 72 tools (10 web tools incl. web_crawl/web_extract/web_act and OCR; self-hosted SearXNG primary for web_search; 16 CyberLibrary tools). This release also ports the defect fixes that shipped in the hosted service (v0.22.0/v0.22.1) into this 45-tool reference implementation. Highlights: JSON-safe truncation (responses over the transport cap stay valid JSON and carry _truncated / _original_chars metadata instead of being sliced mid-object); bech32m/BIP350 witness-v1+ and base58check address validation; Zcash Ironwood shielded-pool accounting; eth_read_contract raw selector and ABI-parameter prefix handling (no more silent lstrip("0x") corruption); TRON contract-revert detection, has_code via getcontract, USDT verdict finality split, confirmation off-by-one, risk-address base58 checksum + 41-hex validation and unactivated-account coverage notes; consistent isError for every tool; strict batch/HTTP handling (batch element validation, 405 for DELETE/PUT/HEAD, 413 body cap, 415 Content-Type, 404 path, complete CORS preflight, trusted client IP via X-Real-IP, Retry-After on 429); tool title + annotations (readOnlyHint etc.) and additionalProperties normalization in tools/list; web_fetch max_chars cap/budget and HTTP 4xx passthrough instead of a silent provider fallback; dynamic XMR output-distribution lag with the real chain tip; Monero proof-check error semantics; and fee estimates priced from eth_feeHistory percentiles (p50 tip for a transfer, p90 for an ERC-20 transfer) instead of a zero eth_maxPriorityFeePerGas. Version fields in server.json, mcp-registry.json and smithery.yaml follow; glama.json carries no version field.

License

MIT — see LICENSE.

RobotBase · verification & risk intelligence for Web3 agents · https://robotbase.cc/