MCP — connect your AI assistant

gex.live for AI assistants (MCP)

Point your assistant at one URL and it can read dealer positioning for 1,000+ finished SPX sessions — and, with your account connected, compile and backtest ideas in the Lab without leaving the conversation.

gex.live speaks the Model Context Protocol:

Endpoint   https://mcp.gex.live/mcp   (streamable HTTP)
Registry   live.gex/gex-mcp   (official MCP registry)

Everything served is a measurement verifiable against the free history — no buy/sell signals, by design. Only derived per-session aggregates cross this interface, one session per call.

Free tools — no account, no key

tool	returns
`list_sessions`	`{ limit? }` — up to 50 days per call. Finished trading days in the archive, newest first.
`get_session`	`{ day: "YYYY-MM-DD" }` One session: OHLC, zero-gamma flip and crossings, call/put walls, hold band, net-gamma percentile, ATM IV.
`get_levels`	`{ day: "YYYY-MM-DD" }` Just the level set and where the session closed against it.

Connect

Claude.ai and Claude Desktop

Settings → Connectors → Add custom connector → paste https://mcp.gex.live/mcp. The free tools appear immediately; press Connect to sign in with your gex.live account and the Lab tools unlock too — no keys to copy. See Sign in (OAuth).

Claude Code

claude mcp add --transport http gex https://mcp.gex.live/mcp

Cursor

// .cursor/mcp.json
{ "mcpServers": { "gex": { "url": "https://mcp.gex.live/mcp" } } }

Any MCP client, or curl

The server is plain streamable HTTP: POST JSON-RPC to the endpoint, no session state.

curl -s https://mcp.gex.live/mcp -H "content-type: application/json" -d '{
  "jsonrpc": "2.0", "id": 1, "method": "tools/call",
  "params": { "name": "get_session", "arguments": { "day": "2026-08-13" } }
}'

Sign in with gex.live (OAuth)

Clients that speak MCP authorization — claude.ai and Claude Desktop custom connectors among them — need no token at all. Add the connector and press Connect: your browser opens gex.live, you sign in (or create an account right there), one consent page spells out what the assistant can and cannot do, and ALLOW finishes the handshake. The client is holding a Lab credential seconds later; nothing is copied by hand.

What the consent grants — and what it cannot:

It can compile ideas and run backtests & quant optimizes, spending your Lab credits.
It cannot touch the live stream, billing, or your account settings — the credential is scoped to LAB only.
Revoke any time — it lists on your account page as “AI connector (OAuth)”, next to your other Lab tokens.

Under the hood this is standard OAuth 2.1 as the MCP spec requires — clients discover and register themselves, so there is no client id or secret to create.

Scripts and clients without OAuth support use a manual token instead — same credential, created by hand: see Lab tools.

Lab tools — your account, your credits

Signed in (or with a Lab token attached), five more tools appear. They drive the Lab's conveyor — the same one the LAB page drives. Every idea walks the same road, in order:

plain words --> rule --> BACKTEST --> QUANT OPTIMIZE --> your desk
      (compile)          (1 credit)     (1 credit)

tool	what it does	cost
`lab_compile`	`{ message, id? }` Turns a plain-words idea — “fade a +3σ stretch above vwap on top-decile volume” — into a testable rule, or amends an existing idea by id. Answers with the compiled spec, a clarifying question, or compile errors. Amending an idea resets it to the start of the conveyor: a re-test is owed.	free, needs a positive balance
`lab_run`	`{ id, kind: "backtest" \| "quant" }` Runs the idea's current conveyor step — `kind` is not a menu: `"backtest"` first (rule → tested), then `"quant"` (tested → ready). Returns the engine's verdict: per-leg era tables (all / this year / holdout), the full rule against its core-only baseline, and `interesting: true` only when the rule clears costs out-of-sample and beats that baseline there. The quant optimize returns every variant — never a picked winner.	1 credit per run, refunded on failure
`lab_state`	no arguments Everything in one call: your ideas with their stages and results, which idea currently holds the conveyor, and your credit balance.	free
`lab_thread`	`{ id }` The compile-chat history for one idea — how the rule got to its current wording.	free
`lab_idea`	`{ id, action: "desk" \| "drop" \| "delete" \| "set", on?, draw?, alert? }` Desk actions on an idea you own: `desk` (ready → onto the desk, frees the conveyor), `drop` (back to the start, frees the conveyor), `delete`, and `set` (desk display and alert options: `on`, `draw`, `alert`).	free

You never type this JSON yourself: your assistant discovers every tool's schema automatically and builds the calls — you ask in plain words. The shapes above are what it sends under the hood. Out of credits, a paid run answers 402 {"error":"no credits","buy":"lab"} — top up on the LAB page.

Manual token (scripts, clients without OAuth)

Create a token on your account page (LAB & API section — shown once, revocable, scoped to LAB only), then attach it as a header:

claude mcp add --transport http gex https://mcp.gex.live/mcp \
  --header "Authorization: Bearer labk_YOUR_TOKEN"

// .cursor/mcp.json
{ "mcpServers": { "gex": {
  "url": "https://mcp.gex.live/mcp",
  "headers": { "Authorization": "Bearer labk_YOUR_TOKEN" }
} } }

One idea, end to end

# 1. plain words -> a compiled rule (free)
lab_compile  { "message": "fade a +3 sigma stretch above vwap on top-decile volume" }
         ->  { "kind": "spec", "idea": { "id": "i_4f2a", "name": "...", "spec": { ... } } }

# 2. backtest the rule (1 credit; this is the step the idea is on)
lab_run      { "id": "i_4f2a", "kind": "backtest" }
         ->  { "result": { legs, era tables: all / this year / holdout, verdict },
               "state":  { balance, ideas } }

# 3. quant optimize the parameters (1 credit; only after a backtest)
lab_run      { "id": "i_4f2a", "kind": "quant" }
         ->  every variant scored -- no picked winner, that judgment stays yours

# 4. keep it: onto the desk, conveyor freed
lab_idea     { "id": "i_4f2a", "action": "desk" }

Then ask things like: “compile this idea — fade a +3σ stretch above vwap on top-decile volume — backtest it, and show me the holdout verdict.”

Full request/response shapes: Lab API docs — the MCP tools mirror those endpoints one to one.

Not investment advice. Options trading carries substantial risk of loss. Backtested performance does not guarantee future results.