# supertrained/rhumb [Health: Active]

**Category:** 🔗 Aggregators  
**Repository:** https://github.com/supertrained/rhumb  
**GitHub Stars:** 5  
**npm Downloads (last month):** 245  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/supertrained-rhumb

## Description
Agent-native tool intelligence across 1,000+ scored services. 21 MCP tools: discover services, check AN Scores, compare alternatives, resolve capabilities to ranked providers, execute through 3 credential modes (managed, BYOK, agent vault), track costs with receipts, and inspect failure modes. Zero-signup option via x402 micropayments.

## Tools
Capabilities this server exposes over MCP:

- **find_services** — Search indexed Services by what you need them to do. Returns ranked Services with AN Scores. Use this when you know the problem but not which Service to call. For Capability-level search (e.g. 'email.send'), use discover_capabilities instead.
- **get_score** — Get the full AN Score breakdown for a Service: execution quality, access readiness, autonomy level, tier label, and freshness. Use after find_services to evaluate a specific Service.
- **get_alternatives** — Find alternative Services, ranked by AN Score. Use when a Service doesn't meet your needs or you want to compare options in the same category.
- **get_failure_modes** — Get known failure patterns, impact severity, and workarounds for a service. Use BEFORE integrating to write defensive code, or AFTER hitting an error to diagnose it.
- **discover_capabilities** — Browse Capabilities by domain or search text. A Capability is an action (e.g. 'email.send', 'payment.charge') that multiple providers can fulfill. Use this when you know WHAT you need to do but not which Service does it. Returns Capability IDs for resolve_capability. Different from find_services: find_services searches Services, this searches Capabilities.
- **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. If the capability ID is wrong, returns a capability search URL plus suggested capabilities instead of a blank dead end. This is the core routing decision: 'I need email.send, and maybe a specific credential mode, which provider or recovery handoff should I use?' Call this before execute_capability to understand your options.
- **execute_capability** — Call a Capability through Rhumb Resolve. Typical workflow: discover_capabilities → resolve_capability → estimate_capability → execute_capability. Default credential mode is auto: Rhumb uses Rhumb Resolve when an active managed config exists, otherwise falls back to byok. Legacy 'byo' is still accepted as an input alias. Other explicit modes: rhumb_managed — zero-config through Rhumb Resolve when available; byok — BYOK via agent_token + method + path; agent_vault — use a key from credential_ceremony via agent_token + method + path. Alternative: pass x_payment for a per-call USDC payment with no account needed. Use check_credentials to inspect live readiness globally or for a specific Capability before choosing a rail.
- **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. Returns cost in USD, circuit health, and endpoint pattern. Default credential mode is auto: Rhumb uses Rhumb Resolve when an active managed config exists, otherwise falls back to byok. Legacy 'byo' is still accepted as an input alias. Always call this before execute_capability for cost-sensitive workflows — no charge for estimates.
- **credential_ceremony** — Get step-by-step instructions to obtain API credentials for a Service. Returns signup steps, expected token format (prefix, pattern), verification endpoint, estimated time, and whether human intervention is needed. Use before calling in agent_vault mode. Call without params to list all Services with available ceremonies.
- **check_credentials** — Inspect live credential-mode readiness, globally or for a specific Capability. Call without params to see which BYOK bridges or direct bundles are already configured and which Capabilities are ready now through Rhumb-managed rails. Pass a Capability to inspect provider-level mode status, configured readiness, and ceremony availability for that specific path.
- **budget** — Check or set your call spending limit. Budgets are enforced BEFORE a call — you get HTTP 402 (not a surprise bill) when you'd exceed your limit. Call with no params to check current budget and remaining balance.
- **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. Use to audit costs or optimize routing.
- **routing** — Get or set how Rhumb auto-selects providers when you don't specify one in execute_capability. Controls the tradeoff between cost, speed, and quality. Also sets a quality floor (minimum AN Score) and optional per-call cost ceiling.
- **usage_telemetry** — Get your execution analytics — calls, latency, errors, costs, and provider health for your Rhumb usage.
- **check_balance** — Check your current Rhumb credit balance in USD. Also shows whether auto-reload is enabled. If balance is low, use get_payment_url to top up.
- **get_payment_url** — Get a checkout URL to add credits to your Rhumb balance. Present this URL to a human to complete payment. Credits are available immediately after payment.
- **get_ledger** — Get your billing history: charges (debits), top-ups (credits), and auto-reload events. Each entry shows amount, balance after, description, and timestamp. Most recent first.
- **rhumb_list_recipes** — List the current published Rhumb Layer 3 recipe catalog. Use this to check what is actually live before assuming a deterministic multi-step workflow exists; the public catalog can be empty while Layer 3 remains in beta.
- **rhumb_get_recipe** — Get the full published definition for a Rhumb recipe, including input/output schemas and step topology. Call this only after rhumb_list_recipes confirms the recipe is currently in the public catalog.
- **rhumb_recipe_execute** — Execute a published Rhumb Layer 3 recipe once one is live in the public catalog. Rhumb runs the multi-step workflow through the existing Layer 2 capability rail, applies recipe safety controls, and returns per-step results plus a recipe-level receipt chain hash.
- **get_receipt** — Retrieve an execution receipt by ID. Every Resolve v2 execution produces an immutable, chain-hashed receipt containing: provider used, cost breakdown, latency, routing explanation, and integrity hash. Use this to audit, debug, or verify any past execution. The receipt_id is returned in every execute_capability response when v2 policy parameters are used.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

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

**Requires environment variables:** `RHUMB_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What supertrained/rhumb does

The supertrained/rhumb MCP server provides two related surfaces for working with external services. Rhumb Index helps an agent search services, inspect AN Scores, compare alternatives, review known failure modes, and browse capability definitions. Rhumb Resolve handles supported executable capabilities by ranking providers and returning information such as health, estimated cost, authentication methods, endpoint patterns, and recovery guidance.

The catalog is broader than the callable execution surface. The stated best fit is research, extraction, generation, and narrow enrichment. Broader multi-system business automation is described as future scope rather than a current execution guarantee.

## How it works

An agent can begin by finding a service or capability, inspecting its score and alternatives, and checking failure patterns. For an executable capability, it can resolve providers, estimate the active execution rail and cost, then call the capability through Rhumb Resolve. Executions can produce receipts, and later calls can retrieve those receipts by ID.

Provider selection can consider AN Score, availability or circuit state, estimated cost, latency proxy, credential mode, and policy constraints. The server also exposes routing controls for automatic provider selection. Usage telemetry reports calls, latency, errors, costs, and provider health.

The supertrained/rhumb MCP server supports three credential approaches: Rhumb-managed credentials, provider keys supplied through BYOK, and keys stored in Agent Vault for injection at call time. Payment can use prepaid credits through a governed API key or, where supported, x402/USDC for per-call access without signup.

## Setup and configuration

Start the stdio server with:

```bash
npx -y --package rhumb-mcp@latest rhumb-mcp
```

This zero-configuration mode enables discovery tools without signup or a governed API key. To enable authenticated execution, provide a governed key:

```bash
RHUMB_API_KEY=your_key npx -y --package rhumb-mcp@latest rhumb-mcp
```

A governed API key is obtained through Rhumb authentication. The documentation also describes wallet-prefund and x402 payment paths, but the exact availability depends on the requested execution route. Public read-only API endpoints expose service scores and capability readiness; estimates and execution require an authenticated payment path.

## Tools and capabilities

The 21 tools cover these areas:

- Discovery: search services, inspect scores, find alternatives, review failure modes, and browse capabilities.
- Resolution and execution: rank providers, estimate calls, execute capabilities, inspect credential readiness, and obtain credential setup instructions.
- Recipes: list published Layer 3 recipes, inspect recipe definitions, and execute a published recipe when it is live in the public catalog.
- Account and operations: retrieve receipts, set or inspect budgets, review spending, check balances, obtain payment URLs, inspect the ledger, configure routing, and view usage telemetry.

The supertrained/rhumb MCP server is therefore suited to agents that need provider selection and execution controls, rather than a single fixed vendor integration.

## Limitations and notes

Discovery breadth does not imply execution readiness. Current callable coverage is narrower than the indexed catalog, and Layer 3 recipes have a sparse public catalog and beta status. Readiness, supported routes, costs, and provider health should be checked from current Resolve responses before execution. Discovery is unauthenticated, but execution is not generally free or unauthenticated; credential and payment requirements vary by route.

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