Rhumb Mcp

io.github.supertrainedPublished by GitHub account supertrainedv0.8.2Updated Oct 24, 2026

Agent gateway for Index discovery, AN Score evaluation, and Resolve governed execution

VerifiedSTDIODesktop onlyFinance Developer Tools AI & ML

Server details

Identifier: io.github.supertrained/rhumb-mcp
Transport: STDIO
Runtime: Desktop only
Trust: Verified
Published: Sep 16, 2026

Security note

MCP servers receive tool arguments from a conversation and may perform external actions. Review what a server can do before you enable it, and give it only the access it needs.

The registry verified the GitHub account supertrained for this listing. That does not show the account is the product's maker.

SourceWeft's checks cover whether the listing is complete and the endpoint answered; they do not review the server's code or what its tools do.

Add a badge to your README

Show readers this MCP server is listed on SourceWeft. The badge links to this page.

[![Listed on SourceWeft](https://sourceweft.com/badge/mcp/io.github.supertrained%2Frhumb-mcp.svg)](https://sourceweft.com/mcp/io.github.supertrained%2Frhumb-mcp?utm_source=readme&utm_medium=badge)

Overview

AI-generated overview

Rhumb gateway MCP server that lets an assistant discover, score, route and execute third-party API capabilities, with receipts, budgets and spend tracking.

What you can do: Search and compare services, read AN Score breakdowns, alternatives and known failure modes
Browse and resolve capabilities to ranked providers with health, cost and auth guidance
Estimate and execute capability calls through Rhumb Resolve, then fetch signed execution receipts
Inspect credential readiness and get step-by-step credential setup instructions
List, inspect and run published Layer 3 recipes (beta, catalog currently sparse)
Manage spending limits, balances, payment links, ledger and usage telemetry
When to use it: Useful when an assistant needs to pick a third-party API for a task (email, extraction, generation, enrichment) and then call it through one routed, metered gateway instead of wiring each provider separately. Discovery and scoring work without an account; execution, billing and operations tools need a governed key.
Requirements: Runs locally via npx (Node.js) over stdio. Discovery needs no credentials. Execution, financial and operations tools need a governed API key in RHUMB_API_KEY; per-call payment can instead use an x402 wallet address and private key. Network access to the Rhumb API is required.

Before you install

Execution tools perform real third-party actions and spend money; budget and spend tools exist because calls are billed. The x402 option asks for a wallet private key, which is high-risk to store in config. A governed key and wallet credentials are secrets. Execution breadth is limited to a small set of callable providers, and the recipe catalog is largely empty.

Installation

In SourceWeft

Open Rhumb Mcp in the dashboard and add it to a workspace.
Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

Rhumb MCP Server

Agent-native tool intelligence for the Model Context Protocol.

Three execution layers: raw provider access (Layer 1), intelligent routing (Layer 2), and deterministic composed recipes (Layer 3, beta with a truthful public catalog). Every provider rated with the AN Score. Every execution produces a chain-hashed receipt.

Website: https://rhumb.dev
Docs: https://rhumb.dev/blog/getting-started-mcp
Pricing: https://rhumb.dev/pricing
Repo: https://github.com/supertrained/rhumb

Zero-config quickstart

No governed API key needed for discovery. Install and start immediately:

Or add to Claude Desktop / Cursor / any MCP client:

json

{  "mcpServers": {    "rhumb": {      "command": "npx",      "args": ["-y", "--package", "rhumb-mcp@latest", "rhumb-mcp"]    }  }}

{  "mcpServers": {    "rhumb": {      "command": "npx",      "args": ["-y", "--package", "rhumb-mcp@latest", "rhumb-mcp"]    }  }}

Ask your agent:

"Find me the best email API for agents"
"What's the AN Score for Stripe?"
"Check whether any Rhumb recipes are published yet"

Current callable scope

Rhumb is strongest today for research, extraction, generation, and narrow enrichment.

Treat it as capability infrastructure first, not as a general business-agent automation layer yet. Layer 2 is the real production surface today; Layer 3 is still beta with an intentionally sparse public catalog.

Discovery breadth is wider than current execution breadth: Rhumb scores 999 services and exposes 435 capability definitions, but current governed execution is concentrated in 28 callable providers.

Resolve mental model

Service = vendor Rhumb evaluates and compares
Capability = executable action your MCP client can route and execute
Recipe = deterministic multi-step workflow on top of capabilities (beta, sparse public catalog)
Layer 2 is the default path — discover → resolve → estimate → execute
Default auth for repeat traffic = governed API key or wallet-prefund on X-Rhumb-Key
Bring BYOK or Agent Vault only when provider control is the point
Use x402 only when zero-signup per-call payment is the point

Canonical onboarding map: https://rhumb.dev/docs#resolve-mental-model

What's new in v2.0.0

Rhumb Resolve — three execution layers:

Layer	What	How
Layer 1	Raw provider access	You pick the provider. Escape hatch + trust anchor.
Layer 2	Capability routing	Rhumb routes to the best-fit supported provider for the call, using AN Score, availability / circuit state, estimated cost, latency proxy, credential mode, and explicit policy constraints.
Layer 3	Deterministic recipes (beta)	Compiled DAG workflows. Multi-step, budget-enforced, content-firewalled. No published recipes yet.

New infrastructure:

Execution receipts (chain-hashed, HMAC-signed)
Route explanations (why this provider was chosen)
AN Score structural separation (read-only cache, auditable)
Billing event stream (chain-hashed, 15+ event types)
Trust dashboard inputs for observed availability, costs, and reliability
Recipe safety controls (content firewall, idempotency, nesting depth, fan-out rate limiting)
Kill switches (per-agent, per-provider, per-recipe, global with authenticated two-person auth)
Audit trail (append-only, chain-hash verification, export API)

Migration from 0.x

All v1 endpoints remain fully backward compatible — no breaking changes
New v2 endpoints available alongside v1
execute_capability now returns _rhumb_v2 metadata with attribution and receipts
New tools for recipe-catalog inspection, receipts, and telemetry
Update: npx -y --package rhumb-mcp@latest rhumb-mcp

Discovery tools (no auth, 6 tools)

Tool	What it does
`find_services`	Search indexed Services by what you need them to do
`get_score`	Get the full AN Score breakdown for a Service: execution quality, access readiness, autonomy level, tier label, and freshness
`get_alternatives`	Find alternative Services, ranked by AN Score
`get_failure_modes`	Get known failure patterns, impact severity, and workarounds for a service
`discover_capabilities`	Browse Capabilities by domain or search text
`resolve_capability`	Given a Capability ID, and optionally a credential mode, returns ranked providers with health status, cost per call, auth methods, endpoint patterns, execute guidance, and machine-readable recovery fields like recovery_hint.resolve_url, recovery_hint.credential_modes_url, and, when applicable, recovery_hint.alternate_execute_hint or recovery_hint.setup_handoff, plus typo recovery when the capability ID is wrong

Execution tools (auth required, 8 tools)

json

{  "mcpServers": {    "rhumb": {      "command": "npx",      "args": ["-y", "rhumb-mcp@latest"],      "env": {        "RHUMB_API_KEY": "rk_your_key_here"      }    }  }}

{  "mcpServers": {    "rhumb": {      "command": "npx",      "args": ["-y", "rhumb-mcp@latest"],      "env": {        "RHUMB_API_KEY": "rk_your_key_here"      }    }  }}

Get a governed API key at https://rhumb.dev/auth/login (GitHub, Google, or email — 30 seconds).

Tool	What it does
`execute_capability`	Call a Capability through Rhumb Resolve
`estimate_capability`	Estimate the active execution rail, cost, and health before a Capability call; anonymous direct system-of-record paths also preserve machine-readable execute_readiness handoffs
`credential_ceremony`	Get step-by-step instructions to obtain API credentials for a Service
`check_credentials`	Inspect live credential-mode readiness, globally or for a specific Capability
`rhumb_list_recipes`	List the current published Rhumb Layer 3 recipe catalog
`rhumb_get_recipe`	Get the full published definition for a Rhumb recipe, including input/output schemas and step topology
`rhumb_recipe_execute`	Execute a published Rhumb Layer 3 recipe once one is live in the public catalog
`get_receipt`	Retrieve an execution receipt by ID

Financial tools (auth required, 5 tools)

Tool	What it does
`budget`	Check or set your call spending limit
`spend`	Get your spending breakdown for a billing period: total USD spent, call count, average cost per call, broken down by Capability and by provider
`check_balance`	Check your current Rhumb credit balance in USD
`get_payment_url`	Get a checkout URL to add credits to your Rhumb balance
`get_ledger`	Get your billing history: charges (debits), top-ups (credits), and auto-reload events

Operations tools (auth required, 2 tools)

Tool	What it does
`routing`	Get or set how Rhumb auto-selects providers when you don't specify one in execute_capability
`usage_telemetry`	Get your execution analytics — calls, latency, errors, costs, and provider health for your Rhumb usage

21 MCP tools

Discovery (free): find_services, get_score, get_alternatives, get_failure_modes, discover_capabilities, resolve_capability

Execution (auth): execute_capability, estimate_capability, credential_ceremony, check_credentials, rhumb_list_recipes, rhumb_get_recipe, rhumb_recipe_execute, get_receipt

Financial (auth): budget, spend, check_balance, get_payment_url, get_ledger

Operations (auth): routing, usage_telemetry

Discovery spans 999 scored services, but current governed execution spans 28 callable providers.

Best current fit: research, extraction, generation, and narrow enrichment. Treat general business-agent automation as future scope, not the current callable promise.

Common workflows

1) Discover tools (no auth)

"I need an email provider for agents."

find_services → search the landscape
get_score → inspect a specific provider
get_failure_modes → see where it breaks in practice

2) Route a capability (no auth)

"I need email.send. What should I use?"

discover_capabilities → find the capability ID
resolve_capability → get ranked providers, optional credential-mode filtering, machine-readable recovery fields like recovery_hint.resolve_url, recovery_hint.credential_modes_url, and, when applicable, recovery_hint.alternate_execute_hint or recovery_hint.setup_handoff, or search suggestions when the capability ID is wrong

3) Check readiness (auth required)

"Can I call deployment.list right now, and on which rail?"

check_credentials → call without params for account-wide configured BYOK/direct-bundle readiness, or pass a capability to inspect provider-level mode status and ceremony availability

4) Execute (auth required)

"Send the email with the cheapest provider above my quality floor."

estimate_capability → check the active execution rail, health, and cost before execution
execute_capability → perform the action
get_receipt → verify the HMAC-signed execution record

5) Check recipe availability / run a recipe (auth required)

"Is there already a published Rhumb workflow for this?"

rhumb_list_recipes → check what is actually live in the public catalog
rhumb_get_recipe → inspect a recipe only after it appears there
rhumb_recipe_execute → run the compiled recipe once it is published
Public note: the Layer 3 catalog is currently sparse/empty, so most real work should use Layer 2 capabilities today

x402 micropayments

No account needed — pay per call with USDC on Base:

Local development

Test and build

API: https://api.rhumb.dev/v1 (v1 compat) / https://api.rhumb.dev/v2 (Resolve v2)
npm: https://www.npmjs.com/package/rhumb-mcp
MCP Registry: https://registry.modelcontextprotocol.io (search "rhumb")
GitHub: https://github.com/supertrained/rhumb

License

MIT

Source: packages/mcp/README.md at commit 957abf9

Tools

SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

v0.8.2LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

Reached in the last 30 days25 pts
Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.
Auth declared10 pts
Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.
Tools listed15 pts
Answer tools/list without a credential, or ship a package that starts in a sandbox without one.
DescriptionRequired15 pts
Logo10 pts
Documentation15 pts
License10 pts