MCP App Store
by KeenEthics
Keel icon

Keel MCP Server for Claude and ChatGPT

By Keel Software, Inc.

Overview

Keel turns your ideas into systematic strategies for Hyperliquid crypto perpetual futures (perps). Connect it to Claude, describe a strategy, and Claude builds it from Keel's strategy components, backtests it on real Hyperliquid history with fees and slippage, and explains the results. With Keel in Claude you can: - Build and edit strategies by describing them - Backtest them and compare runs side by side - Start from a verified strategy in the Keel library - Keep notes on strategies and share a result by link - See how the strategies you run in Keel are doing Everything you create stays in your Keel workspace. Nothing is public unless you share it. Claude can't move money, place orders, or run a strategy with real capital. You start and stop strategies in the Keel web app. Keel measures the strategies you design. It does not give investment advice or recommendations, and backtest results do not predict future returns.

How to connect

  1. Claude: Open the Keel listing in the Claude connectors directory and choose Connect. Claude listing Keel exposes 29 tools here.
  2. ChatGPT: Open the Keel listing in the ChatGPT app directory and choose Connect. ChatGPT listing Keel exposes 35 tools here.

Tools

keel_account_status

ChatGPT
Report who is signed in to Keel, on which plan and with how much quota left — plan usage per unit is keel_plan_usage, a failing connection keel_connection_check. It carries the account and plan, the remaining quota (backtest runs, compute seconds) with the reset instant, and what this connector can do: research and backtests; it cannot place orders, move funds or connect wallets; strategies that are running are managed in the Keel web app.

keel_backtest_compare

ChatGPT
Compare 2–8 completed backtests side by side — one run alone is keel_backtest_summarize. One table with deltas against the first id and each run's cost profile (resizes, turnover, fees), overlaid equity curves, notes when windows, engines, carry or strategies differ, and — when the sources resolve — a declaration and step diff. It takes every id in one call; saved versions of one strategy compare the same way, and keel_strategy_restore makes a chosen version the latest.

keel_backtest_positions

ChatGPT
The positions of ONE completed backtest, entry to exit — what drove its result. Default: a summary (count, win rate, P&L by asset, five best, five worst). asset and/or start/end: one page of positions (entry/exit time and price, side, entry value, net P&L, fees) and a cursor. compare_to pairs two runs' positions for one asset.

keel_backtest_run

ChatGPT
Submit a NEW backtest run of a strategy — a finished run's result is keel_backtest_summarize, a running one's wait keel_backtest_watch. Runs server HEAD unless version pins one. Defaults: the window is the platform's default for the strategy's timeframe, to today UTC (end_date exclusive) — and a realistic cost model (starting capital, ~4.5 bps fees + ~4.5 bps slippage); the result names the window, any start move, and the declarations and pipeline that ran. Returns run_id; with wait=true (the default) also summary_metrics and the tearsheet link, or status_url on a polling timeout. Each call spends one run of quota; keel_plan_usage reports what is left.

keel_backtest_summarize

ChatGPT
Show ONE completed backtest run in full — several runs together are keel_backtest_compare, a still-running one keel_backtest_watch. The card carries return, max drawdown, Sharpe, win rate, turnover, carry, the window, the equity curve and the tearsheet link. Complete only at a terminal status. exposure says how much of the window held positions; start / end / capital report part of the run as slice.

keel_backtest_watch

ChatGPT
Wait on a running backtest (started by keel_backtest_run) until it finishes or the timeout elapses — a finished run in full is keel_backtest_summarize. It polls to a terminal status (succeeded, failed, cancelled) and returns the latest snapshot even while the run is going (terminal=false: watch again). Returns the status, and when complete the final metrics and the tearsheet link hero_url.

keel_components_get

ChatGPT
Fetch the full contract for ONE known pipeline component — several at once are keel_components_get_many. It carries the parameter list, type signature, slot reads and writes, examples and common pitfalls: the exact names, types and slots a ComponentRef(...) in the DSL passed to keel_strategy_compose has to match. name is case-sensitive. Discovering components is keel_components_search.

keel_components_get_many

ChatGPT
Fetch the full contract of SEVERAL components in one call — one component alone is keel_components_get. Each entry carries the parameter list, type signature, slot reads and writes and examples — what a pipeline's wiring is checked against. Candidates come from keel_components_search. The result gives each name's contract with found / missing counts; an unknown name is reported as missing, not a failed call.

keel_connection_check

ChatGPT
Check this connection to Keel when a call fails for an environmental reason — identity and quota are keel_account_status. One pass over sign-in, API reachability and the tool surface this server loads, returned as a checks list (name, ok, detail). A call failing twice on one root cause is a setup question, and a report for a human is keel_feedback.

keel_feedback

ChatGPT
Send feedback about Keel to the Keel team — friction, praise or a bug report in goal, kind and text — when the user asks or agrees; a failing connection is keel_connection_check. It sends only these fields (plus optional severity and context_ref), nothing else from the conversation; text is required. Returns delivered (true only when Keel stored the note) and, on a problem, a note; no one replies within the session.

keel_help

ChatGPT
Fetch one Keel knowledge or DSL-reference document by topic — components are keel_components_search, one component's contract keel_components_get. With no topic it lists the topic names. topic="skills" lists the agent skills (also served as MCP prompts) and topic="skill:<name>" returns one in full; topic="rule:<CODE>" explains a validation issue code and rules lists them.

keel_library_fork

ChatGPT
Fork a verified Keel Library entry into the caller's org as an editable strategy — a copy of a Keel strategy or a share link is keel_strategy_fork. The fork is a full copy with its own history; its evidence comes from its own keel_backtest_run, not the entry's published metrics. A variant_id from keel_library_get selects a published preset; ma-crossover-crypto is the simple entry new web users start from.

keel_library_get

ChatGPT
Read one Keel Library entry's verified facts before a fork — forking it is keel_library_fork. They are its headline metrics, backtest window, data freshness and published variants (parameter presets with their own metrics), from the library's verified run; a fork's own numbers come from its own keel_backtest_run.

keel_library_list

ChatGPT
List the Keel Library — the verified, backtested strategy entries published in the product; the caller's own strategies are keel_strategy_search. Each row carries the slug, name, category, risk band and headline metrics from the entry's verified run. One entry's full facts are keel_library_get; starting from one is keel_library_fork.

keel_live_monitor

ChatGPT
Read-only monitoring of the strategies running on the caller's account; acting on one happens in the Keel web app (keel_app_link returns the link). view picks a slice (overview, positions, equity, pnl, stats, weights, portfolio, …); with no arguments it returns the portfolio summary, and deployment_id narrows to one. freshness qualifies the data: positions is a live read of the caller's linked Hyperliquid account, a snapshot that can include holdings beyond one running strategy; the other views are recorded backend state.

keel_paper_control

ChatGPT
Pauses, resumes, stops, restarts or updates one simulated paper-trading run; no real orders are placed and no real capital is at risk. update moves the run onto the strategy's newest saved version and keeps its record; restart starts a fresh record of the same version; stop ends the record for good and frees its paper slot. A repeated call is refused when the run is already in that state. Running a strategy with real capital is a step you take in the Keel web app. The run's id comes from keel_paper_deploy or keel_live_monitor, which also reads the run.

keel_paper_deploy

ChatGPT
Starts a paper-trading run of a saved strategy: fills are simulated at live Hyperliquid prices under Keel's published fill model, no real orders are placed and no real capital is at risk. The run starts here without a confirmation step and needs no exchange account. Each plan has a number of concurrent paper runs; keel_plan_usage reports this plan's. Running it with real capital is a step you take in the Keel web app. The response carries the auto-pause rules; keel_live_monitor reads the run, and keel_paper_control pauses, updates or stops it; stopping frees its slot. Each call starts another run; after a timeout keel_live_monitor shows whether one started.

keel_plan_usage

ChatGPT
Report the org's own Keel plan and its backtest usage this period — auth, identity and visible tools are keel_account_status. It returns the plan name, the period, and for backtest runs and backtest compute seconds the limit, the used and remaining counts, and the reset instant. It changes nothing and spends no quota.

keel_screener_list

ChatGPT
List screens: your own and the ones you follow (the default), or one scope: mine, following or Keel's curated keel. Each row gives the name, version or status, auto-refresh, link, and the id keel_screener_view takes. It starts no run.

keel_screener_run

ChatGPT
Run a screen — a Keel file with Outputs(...) in place of Execution(...) — and return its outputs ranked across its universe at the last closed bar, the coins its view passes, and one series; a strategy runs through keel_backtest_run. Top movers, carry extremes, who pays while losing: questions like these are screens. strategy_id runs a saved screen; source (with an optional view) an unsaved one. Each call queues one run, counted as a backtest run.

keel_screener_view

ChatGPT
Show a screen's latest completed run without starting one: outputs ranked at the last closed bar, the coins its view passes, those that entered or left, and one series; a backtest is keel_backtest_summarize. Pass strategy_id, run_id or a published share_id; with none, your newest run. view previews control values without saving; include_view_source=true adds the saved view source and revision for keel_screener_view_set.

keel_screener_view_set

ChatGPT
Replace a saved screen's view — title, description, column labels, which coins pass, sort, top-N and charts — with a complete view source and the revision it was read at. It changes how results are shown, not what the screen computes; a new series is a new version through keel_strategy_compose. Start from keel_screener_view(include_view_source=true) and change only the asked-for lines. Earlier revisions are kept; revert_to restores one as a new revision. dry_run=true checks without saving.

keel_share_create

ChatGPT
Publish a strategy (str_*) or a backtest (btr_*) at a public usekeel.io/share/<id> URL. The page shows the strategy's name, description, backtest metrics, fork count, live status, market count and risk settings; include_source (or permission) decides whether viewers also see and can copy the DSL source. expires_at ends it later. What recipients copied cannot be taken back. Returns share_url, share_id and the applied include_source, permission and expires_at.

keel_strategy_compose

ChatGPT
Save a strategy from Keel DSL source — new, or with strategy_id its next version; components come from keel_components_search and keel_components_get_many. dry_run=true validates and compiles without saving. Each save of the source adds a new version to the strategy's history and makes it the latest; nothing is deleted, and its earlier versions and their backtests stay in its history. Declarations, then one Pipeline: Globals(target_timeframe='1d') Universe(mode='top_volume', top_n=30, market='perp') Execution(rebalance='buffered', buffer_threshold=0.2, buffer_mode='relative', rebalance_method='to_edge') Pipeline([ PriceDataLoader(), ROC(period=20), ForecastScaler(avg_abs_target=10.0), ForecastCapper(limit=20.0), ForecastWeightNormalizer(target_leverage=1.0), ], name='my_strategy') A forecast's sign is its direction (positive long, negative short); polarity is trend-following by default, and a mean-reversion signal is the inverted one. A 1d bar closes at 00:00 UTC; bar_offset moves that close, and with it every result. Unsupported Universe symbols are dropped and named in universe.note; HIP-3 markets (e.g. xyz:AAPL) are not supported yet, coming soon.

keel_strategy_diff

ChatGPT
What changed between two strategies or two versions of one (versions: keel_strategy_history; several runs' results: keel_backtest_compare). Reports added, removed and modified steps, parameter and declaration changes (ROC.period 20→42) and reordering, drawn as a diff card. With strategy_id the refs are versions; without it each is DSL source, so two strategies diff by their sources (from keel_strategy_get).

keel_strategy_fork

ChatGPT
Copy a strategy into the caller's org as a separate strategy with its own history; the original's source and versions are unchanged (saving a new version of a strategy is keel_strategy_compose). The copy starts with one version and no backtests; the original keeps its versions and their backtests. source is a strategy id (str_*) or the id in a usekeel.io/share/<id> URL showing its source, any organisation's; forking one adds to its public fork count. Sharing is keel_share_create.

keel_strategy_get

ChatGPT
Render a saved strategy as its structure card — a version's commit id alone is keel_strategy_history, with no card. version (HEAD, tag, sequence number or commit id) selects the version the card's structure, evidence and Code tab describe and include_source=true returns (a non-HEAD read names HEAD apart, as head_summary); include_versions=true lists recent versions; recent_runs lists its newest runs (up to 5) by the run_id keel_backtest_summarize, keel_backtest_compare and keel_share_create take. Changing it is keel_strategy_compose.

keel_strategy_history

ChatGPT
Show a strategy's commit history — each version's commit id, the ref keel_backtest_run pins and keel_strategy_diff compares. Each entry carries the sequence number, commit id, parent, message, timestamp and tags, newest first; limit defaults to 50 (server maximum 200). One commit's source is keel_strategy_get with version and include_source=true.

keel_strategy_notes_add

ChatGPT
Add a note to a strategy's saved notes, kept with the strategy in the user's Keel account and returned by keel_strategy_notes_read in later sessions. Each call appends one note; none is edited or removed. A note is a brief, strategy-specific record (a rationale, a baseline, a risk), not a transcript of the conversation. Changing the source is keel_strategy_compose.

keel_strategy_notes_read

ChatGPT
Read the notes saved on one of the caller's strategies — the durable context that outlives one session; adding one is keel_strategy_notes_add. The result carries notes: the most recent limit notes (default 10), newest first, each with its text, author and time — why prior changes were made, baseline metrics, known risks.

keel_strategy_readiness

ChatGPT
Report what evidence a saved strategy has and still lacks — a brief, a baseline backtest, named failure modes — and the one next step; a backtest is keel_backtest_run. Returns next_recommended_action, missing_evidence, a projection (stage, latest run id and metrics), and projection_available with unavailable_reason when the strategy is not visible to the caller.

keel_strategy_restore

ChatGPT
Add a new version of a strategy equal to an earlier one — a restore; the history is keel_strategy_history, the current strategy keel_strategy_get. ref is a sequence number, tag or commit id; that version's source becomes the next, latest version, labelled "Restored from vN" unless message names it. The history is kept and nothing is deleted.

keel_backtest_compare

Claude

keel_backtest_positions

Claude

keel_backtest_run

Claude

keel_backtest_summarize

Claude

keel_backtest_watch

Claude

keel_components_compose_help

Claude

keel_components_detail_batch

Claude

keel_doctor

Claude

keel_feedback

Claude

keel_help

Claude

keel_library_fork

Claude

keel_library_get

Claude

keel_library_list

Claude

keel_live_monitor

Claude

keel_open_in_app

Claude

keel_ownership_status

Claude

keel_plan_status

Claude

keel_share_create

Claude

keel_status

Claude

keel_strategy_compose

Claude

keel_strategy_diff

Claude

keel_strategy_fork

Claude

keel_strategy_get

Claude

keel_strategy_log

Claude

keel_strategy_memory_read

Claude

keel_strategy_memory_write

Claude

keel_strategy_restore

Claude

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/keel"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/keel)