> For the complete documentation index, see [llms.txt](https://rootai.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://rootai.gitbook.io/docs/mcp.md).

# MCP

## What is the rootAI MCP Server?

Model Context Protocol (MCP) is an open standard that lets AI assistants call external tools and live data sources in real time instead of relying on stale training data.

The rootAI MCP server sits on top of Edge's data layer, giving any MCP-compatible AI assistant live access to crypto market intelligence: prices, funding rates, open interest, orderbook depth, options chains, news, on-chain discovery, Base swaps, TradFi stocks and more — across Hyperliquid, Binance, Pyth, DexScreener and Base.

```
Your AI assistant  →  rootAI MCP server  →  Edge data layer  →  live exchange + onchain data
```

**Public endpoint:** `https://mcp.rootedge.ai/mcp`

The endpoint is read-only and non-custodial. Market data, news, signals, discovery, and unsigned Base transaction calldata. The MCP never holds keys; on-chain actions are returned as unsigned calldata for the user to sign in their own wallet.

### Setup Guides

#### Claude.ai: Web (Recommended)

No installs. Under a minute.

1. Go to **claude.ai** and sign in
2. Navigate to **Customize → Connectors**

<figure><img src="/files/bT7GHLJV8PbMSGhZgSJv" alt=""><figcaption></figcaption></figure>

1. Click **Add custom connector**

<figure><img src="/files/ZpuAeA6FyZhqNQf0xPaQ" alt=""><figcaption></figcaption></figure>

1. Paste the URL: `https://mcp.rootedge.ai/mcp`

<figure><img src="/files/TbwAsWsrMQZJ60ZlxRJ6" alt=""><figcaption></figcaption></figure>

1. Verify by asking:

   > What perp markets are live on Hyperliquid right now?

   A list of trading pairs means you're connected.

<figure><img src="/files/wKtVjrNa3ArS0ZxzTMue" alt="" width="552"><figcaption></figcaption></figure>

#### Claude Desktop

1. Open or create the config file
   * **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
   * **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
2. Add the rootAI server:

   ```json
   {
     "mcpServers": {
       "rootai": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-fetch"],
         "env": {
           "MCP_SERVER_URL": "https://mcp.rootedge.ai/mcp"
         }
       }
     }
   }
   ```
3. Restart Claude Desktop fully (not just the window)
4. Look for the 🔌 tools indicator in the chat input — confirms MCP is active

#### Cursor

1. Open **Settings → MCP**
2. Add a new server entry:

   ```json
   {
     "rootai": {
       "url": "https://mcp.rootedge.ai/mcp",
       "type": "sse"
     }
   }
   ```
3. Reload the window and the server will appear in your MCP tools list

## Complete Tool Reference

The public rootAI MCP endpoint exposes 98 free tools across Hyperliquid, Binance, DexScreener, Polymarket, Base, Robinhood Chain, TradFi, and Edge intelligence.

```
https://mcp.rootedge.ai/mcp
```

### `hyperliquid_*` — Hyperliquid Data

Read-only Hyperliquid market data.

* `hyperliquid_meta` — universe of perpetuals, decimals, max leverage
* `hyperliquid_summaries` — 24h volume, open interest, mark price
* `hyperliquid_mids` — best mid for every coin
* `hyperliquid_book` — full L2 orderbook
* `hyperliquid_candles` — OHLCV candles by interval
* `hyperliquid_funding` — current and historical funding rates
* `hyperliquid_stock_rwa` — Hyperliquid-listed RWA / equity perps, including HIP-3 markets

### `binance_public`

Generic Binance public market data wrapper for spot, USD-M futures, and Coin-M futures.

Example use cases:

* spot ticker price
* 24h ticker stats
* futures funding context
* exchange info
* public klines

### `dex_*` — DexScreener Token & Pair Discovery

Use these for token discovery, pair lookup, liquidity context, boost monitoring, and market-narrative scans.

* `dex_search` — search tokens or pairs by symbol, name, or contract address
* `dex_pair` — full market data for a single pair
* `dex_tokens` — token-level lookups
* `dex_token_pairs` — all known pairs for a token
* `dex_token_orders` — token order/payment metadata
* `dex_trending_metas` — trending narrative metadata
* `dex_meta` — metadata for a specific chain or token context
* `dex_top_boosts` — top paid boosts
* `dex_latest_boosts` — latest paid boosts
* `dex_latest_ads` — latest paid ads
* `dex_latest_profiles` — latest token profiles
* `dex_recent_profile_updates` — recently updated token profiles
* `dex_latest_community_takeovers` — latest community takeover signals

### `polymarket_*` — Polymarket Prediction Markets

For any specific event question, always start with `polymarket_search` using the most precise query you can build. Include sport, league, team, candidate, date, or season when relevant.

Avoid `polymarket_events` as a first move for a specific event. It returns a broad listing and is easy to misread.

If the user's term is ambiguous, enrich the query first or ask a clarifying question. Always check each candidate event's status before quoting odds. Closed or resolved events can return last-known prices that are not live.

#### Discovery

* `polymarket_search` — full-text search across markets, events, and series
* `polymarket_events` — list events for broad browsing or trend scans
* `polymarket_event` — single event with child markets
* `polymarket_event_by_slug` — single event lookup by slug
* `polymarket_event_tags` — event taxonomy
* `polymarket_market_tags` — market taxonomy
* `polymarket_tags` — tag list
* `polymarket_tag` — single tag lookup
* `polymarket_series` — multi-event series
* `polymarket_series_detail` — detailed series lookup
* `polymarket_sports` — sports metadata
* `polymarket_teams` — team metadata

#### Markets

* `polymarket_markets` — list markets with filters
* `polymarket_market` — single-market lookup
* `polymarket_market_by_slug` — single-market lookup by slug
* `polymarket_market_by_token` — single-market lookup by token ID
* `polymarket_simplified_markets` — compact market list for quick scans
* `polymarket_clob_markets` — CLOB-tradeable markets only

#### Prices & Quotes

* `polymarket_price` — last trade price for one token
* `polymarket_prices` — last trade prices for many tokens
* `polymarket_last_trade_price` — most recent fill for one token
* `polymarket_last_trade_prices` — most recent fills for many tokens
* `polymarket_midpoint` — bid/ask midpoint
* `polymarket_midpoints` — bid/ask midpoints for many tokens
* `polymarket_spread` — bid/ask spread
* `polymarket_spreads` — bid/ask spreads for many tokens
* `polymarket_tick_size` — minimum price increment for a market
* `polymarket_prices_history` — historical price series for charting

#### Orderbook & Flow

* `polymarket_orderbook` — L2 book for one token
* `polymarket_orderbooks` — L2 books for many tokens
* `polymarket_trades` — recent trade tape
* `polymarket_open_interest` — outstanding YES/NO contracts per market
* `polymarket_holders` — wallet-level holder distribution

#### Wallet Activity

Public on-chain Polymarket wallet data.

* `polymarket_activity` — recent activity for a wallet
* `polymarket_positions` — open positions
* `polymarket_closed_positions` — realized positions
* `polymarket_user_value` — total portfolio value for a wallet

### `base_*` — Base Chain Calldata

Base tools prepare unsigned calldata only. They never broadcast.

* `base_prepare_swap` — swap calldata for the user's wallet
* `base_prepare_send` — ERC-20 or ETH transfer calldata

These tools return an unsigned `calls` array for the user to approve and sign in their own wallet.

Typical response shape:

```json
{
  "chain": "base",
  "calls": [
    {
      "to": "0x...",
      "value": "0x...",
      "data": "0x..."
    }
  ],
  "_quote": {
    "input_amount": "...",
    "out_values": ["..."],
    "price_impact": 0.003,
    "gas_estimate": 203276
  }
}
```

For direct execution from chat, use the Edge dashboard at <https://app.rootedge.ai>. It ingests the MCP's `base_prepare_*` calldata and forwards it to the connected wallet for signing.

### `hood_*` — Robinhood Chain

Robinhood Chain tools cover canonical stock/ETF tokens, USDG/WETH markets, token discovery, wallet context, trading context, swap quotes, unsigned swap prep, and transaction status.

#### Core Tools

* `hood_canonical_assets` — official Robinhood Chain canonical assets: USDG, WETH, stock tokens, and ETFs
* `hood_stock_intel` — stock/ETF token intelligence, ERC-20 metadata, UI multiplier, supply, and oracle pause fields
* `hood_token_intel` — dynamic token lookup using canonical registry, DexScreener-visible markets, RPC metadata, and a capped recent Transfer-log scan
* `hood_wallet_intel` — wallet summary for native ETH, canonical Robinhood assets, and optionally provider-visible token holdings
* `hood_trading_context` — trading context for canonical stocks/ETFs, memecoins, and other Robinhood tokens
* `hood_market_search` — dynamic provider-visible Robin

### Troubleshooting

Still stuck? File an issue with:

* The tool name + arguments you called
* The exact error string
* Your MCP client (claude.ai web / Claude Desktop / Cursor / other) + version

### Tips for Best Results

* **Be explicit about the venue.** Say *on Hyperliquid*, *on Base*, or *on Polymarket,* some tools require it.
* **Chain tools in one prompt.** MCP calls stack: ask for price + funding + signals + news in a single message for a full picture.
* **Ask for interpretation, not just data.** *Is this funding rate extreme? What does it imply for positioning?* gets you more than a raw number.
* **Fear & Greed is directional, not a trade signal.** Use it for regime context alongside price and funding data.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://rootai.gitbook.io/docs/mcp.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
