The configured API key's permissions, limits, and current usage.

Cheap. Call early in a session — before planning work — to learn what this key can do instead of discovering limits through failed calls.

Returns: scopes: the permission scopes the key carries. limits: requests per minute and per day, max concurrent requests, and the per-run bar cap (null when uncapped). usage: current consumption against those limits, with reset countdowns in seconds. capabilities: feature flags such as server-side data fetch and the full metric set. A small fixed-shape record, returned as the engine sent it.

Engine version, API contract number, and health.

Free (not quota-counted). Call once at the start of a session to confirm the engine is reachable and which contract it serves.

Fetch one engine reference catalog.

Catalogs (cheap, cacheable per session):

• 'operators' — comparison operators for condition expressions

• 'execution-modes' — entry/exit anchors and fill algorithms, with the validity matrix by market type

• 'stop-types' — stop-loss types, re-entry modes, and their parameters

• 'sizing-methods' — position-sizing methods and their parameters

• 'bar-frequencies' — supported bar frequencies and the signal x execution validity matrix (which combinations are allowed)

• 'sections' — the full metric catalog: every statistic's stable id, display label, section, and description

Fetch the relevant catalog BEFORE building a strategy or config; build only from values it lists — never guess parameter names or frequencies.

List indicators, or fetch one indicator's full schema.

Cheap, cacheable per session.

With no arguments: a compact catalog — {"indicators": [...], "count": N} — where each entry carries id, name, category, kind, and value_dtype (no description, to keep the discovery scan small). Use it to discover what exists. Pass name='rsi' (id or name, case-insensitive) to get that single indicator's complete entry including its description and params_schema — do this before adding an indicator to a strategy so its parameters are exactly right. Pass compact=False for full entries for everything (large; the MCP server may cap it and set truncated_by_mcp — prefer compact or name=).

Wire optimization: the compact discovery path asks the engine to omit per-entry descriptions (descriptions=false) since they are stripped locally anyway; the name= and compact=False paths request them. This is a pure saving — if the engine ignores the param it returns full entries and the local compact strip still yields a lean result.

List predesigned strategy templates, or fetch one in full.

Cheap, cacheable per session. The engine returns the templates available to the calling key.

With no arguments: a compact catalog — {"templates": [...], "count": N} — where each entry carries id, origin, name, and description. Use it to discover what exists. Pass name='sma-cross' (id or name, case-insensitive) to get that single template's complete entry: its strategy logic (condition_tree + indicators, the same shape validate_strategy and run_backtest accept) plus parameter metadata — defaults (starting parameter values), requires, and locked_params (parameters that must keep their template values). Pass compact=False for complete entries for everything (large; the MCP server may cap it and set truncated_by_mcp — prefer compact or name=).

JSON Schema for the strategy document (condition_tree + indicators).

Fetch this before composing a strategy by hand; the validate_strategy tool checks against the same rules.

Validate a strategy document without running a backtest.

A cheap quota separate from backtest runs, so validate freely and ALWAYS before run_backtest.

Args: strategy: The strategy document — name, indicators[], and condition_tree (see get_strategy_schema for the exact shape). injected_indicators: Names of custom time-series columns the caller will supply via data_inputs at run time, so conditions referencing them validate.

Returns: On success: {"valid": true, "warmup_bars": ..., referenced indicators/columns}. On failure: {"valid": false, "errors": [...]} where each error carries a machine code, the location in the document, a message, and context (e.g. the list of valid column names). A failed validation is a NORMAL result, not an error — read the errors, fix the document, and validate again before running.

Run a historical backtest against the engine.

Quota-counted and compute-bound. Validate the strategy first (validate_strategy is far cheaper). On a 504 compute timeout, do NOT retry the same request — reduce the date range, use a coarser frequency, or simplify the strategy. On 429/503, wait for the advertised Retry-After before retrying.

Args: data_source: Either inline OHLCV ({"ohlcv": {dates, open, high, low, close, volume?}} as parallel arrays, ISO-8601 dates) or a server-side fetch ({"symbol", "start", "end", "frequency"} — requires a paid plan). strategy: Strategy document (indicators[] + condition_tree). Mutually exclusive with signals. signals: Precomputed signal series ({"dates": [...], "values": [-1|0|1, ...]}). Mutually exclusive with strategy. execution: Execution/cost/risk/sizing settings. Use values from get_catalog('execution-modes'/'stop-types'/'sizing-methods'); omit for engine defaults. benchmark: Optional benchmark data source (same shape as data_source) — adds benchmark-relative metrics. data_inputs: Optional custom time-series the strategy references (name -> {dates, values}). response_detail: 'summary' (default — headline metrics, smallest), 'stats' (every metric), 'full' (plus trades and series downsampled to a fixed, server-controlled number of points). include: Optional add-on blocks at summary/stats detail: 'trades', 'equity_curve', 'monthly_returns', 'yearly_returns'. trades_limit: Max trades returned when trades are included.

Returns: The shaped result at the requested detail; an oversized result is thinned and marked truncated_by_mcp. If the engine rejects the request as invalid (400/422), returns {"accepted": false, "error": ...} so you can fix the named field(s) and retry. Capacity, timeout, and permission failures (e.g. 429/503/504/401/403) raise a tool error carrying explicit recovery guidance.

Evaluate the strategy on the most recent bar only — no P&L, no stats.

Returns the latest signal (-1/0/1), which condition slots fired, and the bar timestamp. Use for "what would this strategy do right now" questions; use run_backtest for performance.

Run several strategies on the same data and compare side by side.

One quota-counted call, but compute scales with the number of strategies. The engine enforces a wall-clock budget for the whole comparison; when it runs out mid-way the response carries "truncated": true and the remaining strategies are missing — report that to the user rather than re-running blindly.

Args: data_source: Shared data source (same shape as run_backtest). strategies: List of {"label": str, "strategy": {...}, "execution": {...}?} entries. include_benchmark: Add a buy-and-hold benchmark to the comparison. response_detail: Shaping level applied to each strategy's result. trades_limit: Max trades per strategy when detail is 'full'.

Returns: {"strategies": [{"label", "result"}, ...], "equity_curves": {...}}, each result shaped at the requested detail. Two truncation flags are distinct and may both appear: the engine's "truncated" (wall-clock budget exhausted mid-comparison — strategies are missing) and the MCP size-cap marker "truncated_by_mcp". A 400/422 rejection returns {"accepted": false, "error": ...}; capacity/timeout/permission failures raise a tool error.

Compute the engine's performance metrics from a returns series.

Use when the returns came from somewhere other than run_backtest (an external system, a portfolio) — backtest results already include these statistics.

Args: returns: Per-bar log returns as {"dates": [...], "values": [...]} parallel arrays (ISO-8601 dates). trading_days_per_year: Required annualization factor — 252 for a daily equities calendar, 365 for 24/7 crypto. Must match the bar calendar of the returns series; a wrong value silently mis-annualizes Sharpe, volatility, and CAGR. benchmark_returns: Optional benchmark series, same shape — adds alpha/beta/capture metrics. trades: Optional trade records (entry_date, exit_date, direction, return_net, ...) — adds trade-level metrics. risk_free_rate: Annual risk-free rate as a decimal.

Returns: {"stats": {...}} — the metric set the API key's plan allows. See get_catalog('sections') for every metric's id and description.

Search available assets by ticker or name (relevance-ranked).

Use to resolve a user's asset mention ("bitcoin", "S&P") to the exact ticker before requesting a server-side data fetch. asset_class filters to 'stocks', 'crypto', 'forex', or 'indices'.

List available tickers, optionally filtered by asset class.

The full universe is very large, so the MCP server caps the returned list and marks it truncated_by_mcp — pass asset_class to narrow it, or use search_tickers to resolve a specific asset by name.

Available date range and estimated bar count for a symbol/frequency.

Available on paid plans. Call before a server-side fetch so the requested start/end stay inside what the provider can deliver and the bar count stays inside the key's per-run limit.