Enables AI agents to interact with Robinhood Chain, reading stock-token positions, quoting swaps, and executing swaps on the Robinhood Chain network.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@rhc-mcp Quote 1 NVDA to USDC"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server for Robinhood Chain — the on-chain agentic surface Robinhood's own agent can't reach.
Robinhood's Agentic Trading exposes an MCP server so any Claude / ChatGPT / MCP agent can trade — but it's off-chain, US-only, equities-only. It can't see or touch the tokenized Robinhood Chain stock tokens.
rhc-mcp is the complement: point any MCP-speaking agent at Robinhood Chain and let it read
on-chain stock-token positions, see the real total-return value ERC-20 reads hide, quote, and swap —
over the same Model Context Protocol. Read tools need no key; swapping is off by default and heavily
guarded.
Swaps go through Robinhood Chain's Uniswap v4 UniversalRouter directly — nothing to deploy. One
catch worth knowing: the chain forks the v4 swap struct with an extra minHopPriceX36 field, so stock
Uniswap SDK calldata reverts. This encoder adds it (verified byte-identical to real on-chain swaps). The
sibling repo RHCSwap is an alternate route (a tiny contract
that hits the v4 PoolManager directly) if you'd rather not touch Permit2.
flowchart LR
A["AI agent<br/>(Claude · ChatGPT · any MCP client)"]
subgraph RH["Robinhood's MCP"]
O["off-chain brokerage<br/>US · equities only"]
end
subgraph THIS["rhc-mcp (this repo)"]
T["get_positions · quote_swap · execute_swap"]
end
subgraph CHAIN["Robinhood Chain (Arbitrum Orbit, id 4663)"]
R["stock tokens<br/>balanceOf + uiMultiplier"]
Q["Uniswap v4 Quoter"]
S["UniversalRouter + Permit2<br/>(v4 swap)"]
end
A -->|off-chain trades| O
A -->|on-chain, this repo| T
T --> R
T --> Q
T --> SRelated MCP server: robinhood-mcp
Tool | Access | What it does |
| read | Chain / RPC / contract addresses; reports whether swapping is enabled or read-only. |
| read | A wallet's stock-token positions: raw balance, |
| read | Exact-input single-hop quote via the Uniswap v4 Quoter. Proves the pool has liquidity and sizes |
| write | Executes a swap via the Uniswap v4 UniversalRouter (+ Permit2 for ERC-20 input) — no deployed contract. Dry-run by default; guarded (see Safety). |
uiMultiplier insightStock tokens are ERC-8056 total-return tokens: raw balanceOf
is static, and uiMultiplier() (1e18-scaled) grows as in-kind dividends reinvest and on splits.
A naive ERC-20 balance read understates what a holder actually owns. get_positions surfaces both
and the gap between them — the on-chain yield an agent would otherwise miss.
git clone https://github.com/jumpboxtech/rhc-mcp && cd rhc-mcp
npm install && npm run build
cp .env.example .env # edit for swapping; read tools need nothingClaude Code:
claude mcp add rhc-mcp -- node /absolute/path/to/rhc-mcp/dist/index.jsClaude Desktop / any MCP client (claude_desktop_config.json):
{
"mcpServers": {
"rhc-mcp": {
"command": "node",
"args": ["/absolute/path/to/rhc-mcp/dist/index.js"],
"env": { "RHC_RPC_URL": "https://rpc.mainnet.chain.robinhood.com" }
}
}
}Then ask your agent: "What are my Robinhood Chain positions for 0x…?" or "Quote 1 NVDA to USDG."
execute_swap moves real funds, so it is deliberately locked down:
Read-only by default — with no RHC_PRIVATE_KEY, the server can only read; swaps are refused.
Key never touches the tool surface — the signer comes only from RHC_PRIVATE_KEY, never a tool
argument, and is never returned or logged.
Dry-run by default — execute_swap returns the plan (expected out, enforced min out, and which
Permit2 approvals a real run would send) without sending unless the caller passes dryRun: false.
Hard size cap — RHC_MAX_SWAP_AMOUNT (whole input tokens, default 1) bounds any single swap.
Slippage always enforced — a real minAmountOut is required, taken from the argument or derived
from a fresh quote minus slippageBps.
Scoped Permit2 grant — the Permit2 → router allowance is scoped to amountIn with a short (~1h)
expiry, not an unbounded standing approval.
Env | Required for | Meaning |
| – | RPC endpoint (defaults to the public mainnet RPC). |
| swapping | Signer key. Unset ⇒ read-only. Keep it in a real secret store. |
| swapping | Per-swap input cap in whole tokens (default |
4663)Contract | Address |
UniversalRouter (the real one; 2 decoys exist) |
|
Permit2 |
|
Uniswap v4 PoolManager |
|
StateView |
|
Quoter |
|
RPC: https://rpc.mainnet.chain.robinhood.com · Explorer: robinhoodchain.blockscout.com
Exact-input, single-hop, hookless pools — deliberately minimal. Exact-output and multi-hop aren't
covered (and haven't been checked for the same minHopPriceX36 quirk). The known-token registry is a
small starter set (USDG, NVDA); pass any 0x address directly. Unaudited — read it before you route
funds through it.
MIT © jumpbox — jumpbox.tech · @jumpbox_tech
Execute an exact-input single-hop swap through Robinhood Chain's Uniswap v4 UniversalRouter (no deployed contract needed). SAFETY: dryRun defaults to true (returns the plan + which Permit2 approvals a real run would send, without sending); amountIn is capped by RHC_MAX_SWAP_AMOUNT; a real minAmountOut is always enforced (from the arg or a fresh quote minus slippageBps). ERC-20 input flows through Permit2. Output is taken to the signer. Requires RHC_PRIVATE_KEY to actually send.
| Name | Required | Description | Default |
|---|---|---|---|
| fee | No | pool fee (default 3000) | |
| dryRun | No | default true; set false to actually send the transaction | |
| tokenIn | Yes | input token symbol or 0x address | |
| amountIn | Yes | human-readable input amount | |
| tokenOut | Yes | output token symbol or 0x address | |
| recipient | No | must equal the signer if given; output is always taken to the signer | |
| slippageBps | No | slippage tolerance in bps when minAmountOut omitted (default 50 = 0.5%) | |
| tickSpacing | No | pool tick spacing (default 60) | |
| minAmountOut | No | explicit minimum output (human units); overrides slippageBps |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description fully covers behavior: dryRun safety, amountIn cap, minAmountOut enforcement via slippageBps or explicit, Permit2 flow, output to signer, and private key requirement for actual send. Highly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise and well-structured. Main action in first sentence, safety details in bullet-style paragraph. No wasted words. Front-loaded with core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description explains return behavior (plan for dry run, transaction for real). Covers all key aspects: inputs, safety, requirements, and result. Complete for a complex swap tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. Description adds value by explaining dryRun default and safety, amountIn cap, slippageBps default, and recipient restriction, beyond schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it executes an exact-input single-hop swap via Uniswap v4 UniversalRouter. Distinguishes from siblings (rhc_info, get_positions, quote_swap) by focusing on execution rather than info or quoting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides when to use (executing a swap) and key safety guidelines (dryRun defaults to true, amount cap, minAmountOut enforced). Implicitly suggests alternative quote_swap for quotes. Lacks explicit when-not-to-use, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a wallet's Robinhood Chain stock-token positions. Returns raw balance, uiMultiplier, the real total-return balance (raw * multiplier / 1e18), and the accrued appreciation % that raw ERC-20 reads hide. Omit tokens to scan the known-token registry.
| Name | Required | Description | Default |
|---|---|---|---|
| tokens | No | token symbols or 0x addresses; omit to scan known tokens | |
| wallet | Yes | wallet address to inspect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It reveals return details (raw balance, uiMultiplier, real balance, appreciation %) and the behavior of omitting tokens to scan the registry. It does not mention auth requirements or rate limits, but it is clear it is a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is just two sentences with no wasted words. The first sentence front-loads purpose and key returns; the second provides a practical usage tip. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return values and their computation. It covers the key outputs (raw balance, multiplier, real balance, appreciation %). It could specify the structure (e.g., array of objects) but is sufficient for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema: 'Omit `tokens` to scan the known-token registry' repeats the schema description. No additional parameter context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads wallet positions for Robinhood Chain stock-tokens with a specific verb 'Read' and resource. It distinguishes itself from siblings (rhc_info, quote_swap, execute_swap) by focusing on positions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for reading positions but provides no explicit guidance on when to use this tool versus siblings or when to avoid it. It lacks alternative tool mentions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Quote an exact-input single-hop swap through the Uniswap v4 Quoter on Robinhood Chain. Proves the pool has liquidity and sizes minAmountOut before executing. Reverts if there is no/thin pool for the given fee + tickSpacing.
| Name | Required | Description | Default |
|---|---|---|---|
| fee | No | pool fee (default 3000 = 0.3%) | |
| tokenIn | Yes | input token symbol or 0x address | |
| amountIn | Yes | human-readable input amount, e.g. "1" or "0.5" | |
| tokenOut | Yes | output token symbol or 0x address | |
| tickSpacing | No | pool tick spacing (default 60) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry full burden. It discloses that the call proves liquidity, sizes minAmountOut, and reverts on no/thin pool. However, it does not state whether the call is read-only or has side effects, nor does it discuss authentication requirements. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that front-load the purpose and include critical behavior upfront. Every word adds value; no unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description should explain the return value (e.g., output amount). It fails to mention what the quote returns. Also lacks information about error messages or where to find pool info. Incomplete for a quoting tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description does not add additional meaning beyond what the schema provides, such as more detailed usage examples or constraints. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (quote), resource (swap via Uniswap v4 Quoter on Robinhood Chain), and specific constraints (exact-input, single-hop). It effectively distinguishes from sibling tools like execute_swap and rhc_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Indicates it should be used to prove liquidity and size minAmountOut before executing a swap, implying it precedes execute_swap. It also warns about reversion on no/thin pools. Could explicitly mention when not to use or alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Chain, RPC, core contract addresses, known stock tokens, and whether this server can swap (a signing key is configured) or is read-only.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It discloses behavioral traits: whether the server can swap (signing key configured) or is read-only. This adds value beyond a simple listing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that conveys all necessary information without waste. Front-loaded with key terms.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description covers all relevant aspects: chain ID, RPC, addresses, tokens, and server mode. Complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters. The description fully explains what the tool returns, so no additional parameter meaning is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific nouns: Chain, RPC, core contract addresses, known stock tokens, swap capability. It clearly distinguishes from sibling tools (get_positions, quote_swap, execute_swap) which handle trading operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states what the tool provides and hints at when to use it (e.g., checking read-only status before swapping). No explicit exclusions or alternatives, but the context is clear given sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0execute_swapget_positionsquote_swaprhc_infoEach tool has a clearly distinct purpose: rhc_info provides chain and contract info, get_positions reads wallet positions, quote_swap quotes a swap, and execute_swap executes a swap. No overlap.
All tool names follow a consistent verb_noun pattern (rhc_info, get_positions, quote_swap, execute_swap) with snake_case, making them predictable.
4 tools is well-scoped for this server's purpose: info retrieval, position reading, swap quoting, and swap execution. Not too few or too many.
The tool set covers the core swap workflow on Robinhood Chain but lacks a dedicated token list or price query tool, though rhc_info and get_positions partially address this.
Trade across 22+ exchanges and brokers from any MCP-capable AI agent, no install required.
Non-custodial limit, stop-loss and DCA trading on Epsilon (Robinhood Chain) for AI agents
Non-custodial MCP for Stock Tokens on Robinhood Chain (4663): quotes, plans, Morpho Earn.
Non-custodial trading for AI agents: 1,900+ assets — US stocks, treasuries, gold, 250+ perps.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jumpboxtech/rhc-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server