How to connect Keel MCP with Cursor

Returns a link to view and manage this strategy in the Keel web app. A strategy id (`str_...`) links to the strategy editor, a backtest run id (`btr_...`) to the tearsheet and charts, a running strategy's id (`dep_...`) to its page, and a share id (the token in a `usekeel.io/share/<id>` URL) to the public share page. It returns the link as `url`; nothing is opened.

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.

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.

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.

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`.

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`.

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.

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`.

Search the Keel pipeline component catalog — the chosen candidates go to `keel_components_get_many`, which verifies their types and slots. It matches `keyword` (narrows), a natural-language `query` (ranks), `category`, `input_type` / `output_type`, or pipeline position (`after` / `before`); `clock_direction` filters to one re-clocking direction (resample raw data fine → coarse, project signals coarse → fine). Domain concepts (beta hedge, regime) are components, found here. Returns compact entries (name, category, description, input/output type); one component's full contract is `keel_components_get`.

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`.

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.

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`.

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`.

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.

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.

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.

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.

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`.

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.

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.

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`).

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`.

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`.

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`.

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.

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`.

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.

Search and list the org's strategies — the entry point for an EXISTING strategy, before `keel_strategy_get`. It matches `query` (name substring) and pages with `limit` and `cursor`; each result carries the strategy id, name and last-updated time. The Keel Library's published entries are `keel_library_list`; components are `keel_components_search`.

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.