How to Give Claude and ChatGPT Live Bitcoin & Ethereum Risk Data (MCP Server Guide)

Ask Claude or ChatGPT "is now a good time to add Bitcoin?" and you get one of two answers. Either a polite disclaimer, or a confident paragraph built from training data that may be months old. Neither knows the current price, funding rate, volatility, or whether the market is in a liquidation cascade right now.

Web search helps a little, but it returns headlines, not state. A news article saying "Bitcoin slides" does not tell the assistant how crowded leverage is, how far price sits from its 200-week moving average, or how much exposure is reasonable in the current regime.

The fix is to give the assistant a tool it can call for live, structured market state. That is exactly what an MCP server does.

MCP (Model Context Protocol) is an open standard, introduced by Anthropic and now supported by ChatGPT as well, that lets an AI assistant call external tools during a conversation. A remote MCP server is just a URL. You add it to your assistant once, and from then on the assistant can decide to call it whenever your question needs that data.

When you ask "what's the risk state of BTC?", the assistant calls the tool, receives structured data (a policy level, a maximum position size, the market regime), and writes its answer from that data rather than from memory. You can see the tool call in the chat, so you always know when the answer came from live data.

The RiskState connector at https://api.riskstate.ai/mcp exposes three read-only tools, one per engine:

get_risk_state (Risk Engine). The current risk policy for BTC or ETH: one of five policy levels from BLOCK to GREEN, the maximum position size, the leverage cap, direction bias, allowed and blocked actions, plus the market regime, volatility regime and cycle phase.

get_market_structure (Structure Engine). Structural events firing now, the distance to the next bullish and bearish triggers, key levels such as the all-time high, the 200-week moving average and the 180-day range, and a friction map of support and resistance walls.

get_playbook_status (Playbook Engine). The registry of rule-based trade setups for BTC and ETH and which ones are firing right now, with cooldown state. Strategy-level only: no prices, sizes or portfolio data.

All three are free and need no account. Data refreshes roughly every two minutes and every response carries its own timestamp.

Custom connectors are available on Claude Pro, Max, Team and Enterprise plans, in claude.ai and the desktop app.

1. Open Settings → Connectors.

2. Click "Add custom connector", name it RiskState and paste https://api.riskstate.ai/mcp. No authentication is needed, so leave the auth fields empty.

3. In a chat, make sure the connector is enabled in the search and tools menu, then ask: "What's the current risk state of BTC?"

In Claude Code, one command does the same: claude mcp add --transport http riskstate https://api.riskstate.ai/mcp

ChatGPT needs a paid plan with developer mode (Plus is enough).

1. Go to Settings → Apps & Connectors → Advanced settings and turn on Developer mode.

2. Back in Apps & Connectors, create a connector, name it RiskState, paste https://api.riskstate.ai/mcp and set Authentication to "No authentication".

3. Start a chat, enable the RiskState connector for the conversation, and ask: "What's the current risk state of BTC?"

Once the connector is on, natural questions work. These are good starting points:

"What's the current risk state of BTC?" The assistant reports the policy level, maximum position size and what is blocked, and explains which condition is driving it.

"Is now a good time to add ETH exposure?" A useful reframe: instead of a price prediction, you get how much exposure the current conditions permit.

"What support and resistance levels matter for BTC right now?" Pulls the structure map: triggers, the 180-day range and the nearest walls.

"Are any trading playbooks firing right now?" Lists active setups and which ones are in cooldown because they already alerted.

Two habits make answers more reliable. If the assistant does not call the tool, ask explicitly: "Use RiskState to check BTC." And if you need a number, ask it to quote the field directly instead of summarising, since assistants sometimes round or paraphrase.

The connector serves a public summary. It covers the policy level, maximum size, direction bias, the composite, structural and tactical scores, regime, structure events and playbook status.

The full API response, which needs an API key, adds what a production system needs: a policy_hash on every decision for audit and non-repudiation, composite subscores, positioning detail (funding percentiles, open interest z-scores, squeeze direction), macro detail with per-source data status, and the portfolio-level endpoints for aggregation and stress tests.

For developers and autonomous agents there is also a local MCP server, published on npm as @riskstate/mcp-server. It runs over stdio, takes your API key as RISKSTATE_API_KEY, and adds a fourth tool, check_trade, which evaluates a proposed position together with what you already hold and returns whether it is allowed and at what size cap.

None of these tools can place an order, change a limit or override a decision. That is deliberate. A risk layer is only useful if the system it governs cannot move its own limits. If an agent could rewrite the policy, the policy would stop meaning anything, and the audit trail would be decorative.

So the flow runs one way: the engine computes, the assistant or agent reads and complies. Even check_trade only answers "would this be allowed", never "allow this".

The connector covers BTC and ETH only, against USD, and applies to spot, perpetual futures and DeFi borrowing. It returns risk governance data: how much exposure the current market state permits. It does not tell you what to buy, and nothing it returns is financial advice.

It also does not see you. The connector needs no account, receives only the tool call (for example "BTC"), and never sees your conversation or your holdings. If you want a decision that accounts for your own positions, that is what the keyed portfolio endpoints and check_trade are for.