MCP App Store
by KeenEthics
QuantDesk icon

QuantDesk MCP Server for ChatGPT

By QuantDesk

Overview

QuantDesk helps you research trading strategies just by describing them in ChatGPT. Build strategies in plain English. Describe an idea, for example "sell the NIFTY ATM straddle at 09:20 with a 25% stop-loss on each leg", and QuantDesk turns it into clear rules. You see a preview of every rule first, and the strategy is saved to your QuantDesk account only when you ask. Backtest on historical data. Test strategies on NSE and BSE index options, MCX commodity options and futures, NSE stocks, and US SPX and SPY options. Review the P&L, drawdown, key statistics and every trade. Look up historical market data. See past prices, indicators and the option chain for a chosen date and minute. Market data in this app is historical, up to the previous trading day. Understand your own LiveDesk strategies, read-only. Ask why a strategy did or didn't take a trade, and see your strategies, daily reports, trades, history and risk view, without changing anything. You sign in with your own QuantDesk account, and every tool works only on that account. This app never places a live order: going live is done by you on QuantDesk LiveDesk. Please note: QuantDesk is a research and education tool, not investment advice. Backtest results come from past data and are not a guarantee of future returns. Trading in derivatives involves risk, so please make your own decisions.

How to connect

  1. ChatGPT: Open the QuantDesk listing in the ChatGPT app directory and choose Connect. ChatGPT listing QuantDesk exposes 69 tools here.

Tools

available_dates

ChatGPT
Lists the trading dates with historical data for an instrument. Read-only. Details: Returns dates that have CSV data available for the given instrument + type. Type defaults to "options". US SPX/SPY: "options" = 0DTE, "options_week" = 1–5 DTE (one file per expiry per day), "spot".

available_instruments

ChatGPT
Lists the instruments QuantDesk has historical data for. Read-only. Details: Returns the list of trading instruments this MCP can query. India: NIFTY / BANKNIFTY / SENSEX / FINNIFTY / MIDCPNIFTY (IST). US (Pro): SPX / SPY — 1-minute spot + options 0–5 DTE in New-York time (ET); data tools, chain lookups and run_python_backtest (Python engine, intraday) only.

backtest_best_trade_times

ChatGPT
For one finished backtest (its jobId), returns the best and the worst entry minute and exit minute — once by win rate and once by average P&L — counting only minutes with at least minTradesPerBucket trades (default 3), plus the most frequent entry and exit minute and the holding time in minutes (average, spread, shortest, longest). Inputs: jobId (required); minTradesPerBucket (optional). Read-only: it only reads the stored results of that backtest; past results are not a prediction.

backtest_breakdown

ChatGPT
Breaks a finished backtest down by weekday, month, days to expiry and similar. Read-only. Details: Slices a completed backtest's trades by dimensions you choose. Returns per-bucket: count, netPnl, wins/losses, winRate, avgPnl, best/worst single trade. Dimensions: "dayOfWeek" (Mon/Tue/Wed/Thu/Fri), "month" (YYYY-MM), "exitReason" (SL/TARGET/ADJUST/TIME/etc.), "duration" (hold-time buckets: 0-15min, 15-60min, 1-3h, 3-6h, 6h+). Pass "all" to get every dimension. Use for: "which day of week is my strategy weakest?", "do my targets close more often than SLs?", "which trade duration band is most profitable?".

backtest_commodity_options_python

ChatGPT
Backtests Python strategy code on MCX (Multi Commodity Exchange) commodity options history. Counts toward the plan's backtest allowance. Historical simulation only. Details: PRO. Backtests a user-written PYTHON MCX commodity-OPTION strategy over recent option DAYS (monthly expiry, 1-minute chain). Write a class Strategy with on_init(self, params) and on_cycle(self, ctx) — called once per option day. ctx API: ctx.symbol, ctx.date, ctx.expiry, ctx.spot (front-future at entry), ctx.strikes (sorted data-driven list), ctx.atm, ctx.entry_time, ctx.otm(pct, "call"|"put") -> strike, ctx.premium(type, strike) -> entry premium (or None), ctx.candles(type, strike) -> [{t,o,h,l,c,oi,iv,...}], ctx.sell(type, strike, qty=1), ctx.buy(type, strike, qty=1). Set ctx.stop_pct / ctx.target_pct (% of gross premium at risk) for SL/target; else legs exit at the session close. Fills: entry at open, wick-based SL/target detection at the trigger level. Args: symbol (e.g. "GOLD"), code, params (dict), cycles (recent days to test, default 12, max 60), entry_time ("HH:MM" IST, default "09:30"), start + end (YYYY-MM-DD, optional), capital (default 100000), lots (default 1). Returns metrics (return%, win%, maxDD, profit factor, Sharpe) + per-day trade log. Example: class Strategy:\n def on_cycle(self,ctx):\n ctx.sell("call",ctx.atm)\n ctx.sell("put",ctx.atm)\n ctx.stop_pct=50\n ctx.target_pct=30. Research only — not advice.

backtest_date_range

ChatGPT
Returns the date range a backtest can cover for an instrument. Read-only. Details: Returns date-range coverage for each instrument × data-type combination — from-date, to-date, total trading days, and detected gaps (> 5 calendar days missing in a row, flagging likely data holes). instruments and types default to ALL combinations. Use this before picking a backtest range to avoid hitting empty days. Faster than calling available_dates separately for each instrument.

backtest_engine_docs

ChatGPT
Returns the documentation of QuantDesk's Python backtest engine (strategy class, order functions, intraday and positional rules, India / MCX / US specifics). Read-only. Details: BACKTEST LAB ONLY — if the user wants the strategy created / built / developed on QuantDesk or LiveDesk (to run it, paper-trade it, deploy it, or "no backtest"), do NOT use this: call strategy_builder_guide. Returns the full Strategy Author's Guide for the QuantDesk Python engine — what to ask the user before coding, the Strategy class shape, the Bar / Portfolio / Strangle / Leg APIs, the qd. helper modules (strike picking, options metrics, TA-Lib wrappers, stats, price action), sandbox restrictions, and three copy-paste worked examples. ALWAYS call this BEFORE writing or saving a new Python strategy from a user description — it contains the mandatory 4-phase workflow (Understand → Ask & Confirm with examples → Develop → Backtest) that prevents wasted iterations from misread specs. Pass section="workflow" for just the ask/confirm flow, "api" for the Strategy/Bar/Portfolio reference, "helpers" for qd. modules, "examples" for runnable patterns, "sandbox" for the import/builtin whitelist, "pipeline" for the validate→save→run→analyze chain, "positional" for MULTI-DAY / overnight strategies (params.positional — NSE/BSE indices and MCX: carry positions across days, bar.dte trading days to expiry, close by day/time, expiry settlement — with a worked example), "mcx" for MCX commodity options (CRUDEOIL, NATURALGAS, GOLD, SILVER … on the same engine). Default "all" returns everything.

backtest_equity_curve

ChatGPT
Returns the equity curve of a finished backtest: its mark-to-market (running profit and loss) series. Read-only. Details: Returns the daily mark-to-market / equity curve timeseries for a completed backtest. Each point is one trading day with: date, dayPnl (that day's realized P&L), pnl (running cumulative since day 1), dd (running drawdown — negative). Optionally include the running equity peak too. If the curve has more days than maxPoints, it's downsampled by even stride sampling (default 500 points — plenty for any chart). Use this when you want to plot equity, identify the worst drawdown window, or find days with outsized P&L.

backtest_futures_strategy_python

ChatGPT
Backtests Python strategy code on continuous index and MCX (Multi Commodity Exchange) futures history. Counts toward the plan's backtest allowance. Historical simulation only. Details: PRO. Backtests a user-written PYTHON strategy on CONTINUOUS daily futures (single or multi-symbol; index futures + MCX commodities). Write a class Strategy with on_init(self, params) and on_bar(self, ctx) — called once per trading day. ctx API: ctx.date, ctx.symbols, ctx.bar(sym)->{open,high,low,close,volume}, ctx.price(sym), ctx.series(sym, field="close", n=None)->numpy array up to now, ctx.position(sym)->+1/-1/0, ctx.buy(sym, size=1.0), ctx.sell(sym, size=1.0) (short), ctx.flat(sym). size = fraction of equity. Indicators: qd.ta / talib; numpy as np. Args: code, symbols (e.g. ["CRUDEOIL","GOLD"], max 10), params (dict), start + end (YYYY-MM-DD, optional), capital (default 100000). Returns metrics (return%, win%, maxDD, profit factor, Sharpe) + trade log. Example: class Strategy:\n def on_bar(self,ctx):\n c=ctx.series("CRUDEOIL")\n if len(c)<20: return\n if c[-1]>c[-20:].mean() and ctx.position("CRUDEOIL")==0: ctx.buy("CRUDEOIL")\n elif c[-1]<c[-20:].mean() and ctx.position("CRUDEOIL")>0: ctx.flat("CRUDEOIL")

backtest_intraday_pnl_by_day

ChatGPT
For one finished backtest (its jobId), returns each trading day's intraday mark-to-market curve summary: the P&L at the first and the last recorded minute, the highest and the lowest P&L with their times, and the range between them. Inputs: jobId (required); fromDate / toDate (YYYY-MM-DD, optional filter); dateLimit (default 60 days); includeSamples = true adds the per-minute curve, downsampled to maxSamplesPerDay points (default 50). Only backtests that recorded a per-minute curve have days to show (otherwise totalDaysCaptured is 0). Read-only.

backtest_intraday_pnl_summary

ChatGPT
For one finished backtest (its jobId), summarises its recorded day-by-day intraday mark-to-market curves: the average and median daily high and low P&L, the average intraday range, and up to 20 days in each of three lists: days that gave back profit (the day's high was at least giveBackThreshold times a positive closing P&L, default 2), days that recovered from a loss (the day's low was at least recoveryThreshold times the closing P&L in size, default 2) and the days with the widest intraday range. Inputs: jobId (required); giveBackThreshold and recoveryThreshold (optional). Only backtests that recorded a per-minute curve have data. Read-only.

backtest_metrics

ChatGPT
Returns the summary statistics of a finished backtest: profit and loss (P&L), win rate, maximum drawdown, Sharpe ratio and more. Read-only. Details: Returns ONLY the headline metrics of a completed backtest — net P&L, win rate, Sharpe, Sortino, Calmar, max DD, profit factor, total trades, avg win/loss, best/worst single trade with their dates, return %, total charges, longest win/loss streaks. Use this instead of backtest_run_details when you only need numbers (no trade log, no equity curve) — the response is ~20× smaller, letting the assistant reason over many backtests at once.

backtest_monte_carlo

ChatGPT
Monte Carlo resampling of a finished backtest's trades to estimate the range of possible outcomes. Read-only. Details: Bootstraps a completed backtest's trades N times (default 1000) by re-shuffling the order of closing trades and replaying the equity curve. Returns percentile distributions (p5/p25/p50/p75/p95 by default — override with percentiles[]) for: finalPnl, maxDD, winRate, longestWinStreak, longestLossStreak. Use this to answer: "How much of my strategy's performance was order-dependent luck?" or "What's the worst drawdown I could realistically expect from this trade distribution?" — the percentile gap between p5 and p95 maxDD is the volatility of outcomes. Pass an optional integer seed for deterministic results.

backtest_option_buying

ChatGPT
Backtests an option-BUYING (long call / put) strategy on the buy-side engine. The run is recorded and counts toward the plan's backtest allowance. Historical simulation only. Details: USE THIS for any OPTION-BUYING strategy (long CE/PE — you PAY premium and profit when it RISES; SL below entry; momentum / breakout / "ride the trend"). Do NOT route option-buying through run_preset_backtest / run_python_backtest — those are the SHORT (selling) engine and will invert the P&L. Runs the OPTION-BUYING (directional) backtest engine — the exact same JS engine as quantdesk-directional.html, loaded at runtime for 1:1 parity. Provide either template (see list_option_buying_templates) or a signals stack ([{id, params}] — e.g. rsi, macd, supertrend, vwap, orb15, cpr, pdhl...) plus combo (any|all|seq). Every engine setting is overridable: strike selection (moneyness/percent/premium/delta), entry window + fill style (next_open|break_high), SL basis (premium_pct|spot_points|candle_low), target/SL %, trailing, breakeven, pyramiding, daily max-loss/profit, costs. Fill semantics match the site: signal on bar close → entry next bar OPEN; SL/target fill AT the trigger level via wick-touch. Returns summary metrics (net P&L, win rate, PF, max DD, Sharpe, charges), monthly P&L, and the last 20 exits with explain text. Range capped at 250 trading days.

backtest_option_buying_python

ChatGPT
Runs a historical backtest of an option-BUYING strategy (it buys calls or puts) written in Python, on 1-minute NIFTY, BANKNIFTY, SENSEX, FINNIFTY or MIDCPNIFTY option data, and returns the result in the same reply (no job to poll): summary metrics, the P&L of each month and the last 20 trades with their charges and an explanation of each trade. Inputs: fromDate and toDate (YYYY-MM-DD, at most 90 calendar days apart); instrument (default NIFTY); either strategyName (an option-buying template from list_option_buying_python_templates, or the user's own saved option-buying script) or inline code with params; optional brokeragePerLot (default 1 rupee per lot), slippagePts (default 0.5 points) and capital (default 100,000). It counts toward the plan's backtest allowance. Historical simulation only: no order is placed and the result is not a prediction.

backtest_run_details

ChatGPT
Returns the settings and summary of a finished backtest run. Read-only. Details: Returns the full results of a completed backtest job: top-line metrics (P&L, win rate, Sharpe, max DD, profit factor, total trades, costs), and optionally the trade log, equity curve, and intraday MTM. Intraday data can be very large — only include it if you specifically need a chart of in-trade mark-to-market. maxTrades caps the trade-log size (default 2000); the trade count is always reported even if truncated.

backtest_status

ChatGPT
Shows the progress and final status of a backtest job. Read-only. Details: Lightweight status check for a backtest job by id. Returns status (queued / running / done / failed / cancelled), progressPct, progressLabel, elapsed seconds, and error message if failed. Does NOT return the result payload — use backtest_run_details once status="done".

backtest_stock_strategy_python

ChatGPT
Backtests Python strategy code on historical NSE (National Stock Exchange of India) stock prices. Counts toward the plan's backtest allowance. Historical simulation only. Details: Backtests a user-written PYTHON equity strategy on NSE/BSE stock history (single or multi-stock). Write a class Strategy with on_init(self, params) and on_bar(self, ctx) — called once per trading day. ctx API: ctx.date, ctx.symbols, ctx.bar(sym)->{open,high,low,close,volume}, ctx.price(sym), ctx.series(sym, field="close", n=None)->numpy array of history up to now, ctx.position(sym)->+1/-1/0, ctx.buy(sym, size=1.0), ctx.sell(sym, size=1.0) (short), ctx.flat(sym). size = fraction of equity. Indicators: qd.ta (e.g. qd.ta.rsi(ctx.series("RELIANCE"),14)) or talib; numpy as np. Args: code, symbols (e.g. ["RELIANCE","TCS"], max 10), params (dict to on_init), start + end (YYYY-MM-DD, optional), capital (default 100000). Returns metrics (return%, win%, maxDD, profit factor, Sharpe) + trade log. Example: class Strategy:\n def on_bar(self,ctx):\n c=ctx.series("RELIANCE")\n if len(c)<50: return\n sma=c[-50:].mean()\n if c[-1]>sma and ctx.position("RELIANCE")==0: ctx.buy("RELIANCE")\n elif c[-1]<sma and ctx.position("RELIANCE")>0: ctx.flat("RELIANCE")

backtest_trade_timing

ChatGPT
For one finished backtest (its jobId), groups the closed trades by the time of day they were entered and/or exited — per minute (09:16, 09:17 …) or per hour — and returns, for each time bucket, the number of trades, the win rate, the average P&L and the total P&L. Inputs: jobId (required); bucket = minute or hour (default minute); side = entry, exit or both (default both). Read-only: it only reads the stored results of that backtest; it is not a prediction.

backtest_trades

ChatGPT
Returns the trade-by-trade log of a finished backtest. Read-only. Details: Returns a filterable trade log from a completed backtest. Filters: fromDate / toDate (trade date range), winsOnly / lossesOnly (boolean), minPnl / maxPnl (net P&L thresholds), exitReason (substring match — e.g. "SL", "TARGET", "ADJUST", "TIME"). excludeEntries defaults to true so you only see closing trades (set false to include open events). sortBy: date | netPnl | absPnl | duration. Returns paginated rows (default 200, max 5000) plus a totals block (sum P&L, win count, loss count) for the filtered set. Use this for "show me the 10 worst trades", "trades that hit adjustment", "weekly P&L breakdown" etc.

biggest_intraday_moves

ChatGPT
Lists the largest historical intraday price moves of an index on a past day. Read-only. Details: Scans a day's spot data for the largest rolling-window moves. Returns the top-N intervals where |spot_end - spot_start| was greatest over a sliding windowMinutes window (default 5 min). Useful for finding the most active minutes of a day — when grid triggers fired, when SLs got hit, where to dig deeper.

check_backtest_code

ChatGPT
Checks Python strategy code for syntax and engine-format errors without running it. Read-only. Details: (Backtest Lab Python only — a strategy the user wants created on QuantDesk / LiveDesk is built with strategy_builder_guide, not Python.) Static lint of Python strategy code via the engine's sandbox — checks for syntax errors, banned imports (os, sys, subprocess, etc.), banned builtins (eval, exec, open), and that the code defines a class named Strategy. NO execution happens — fast (<100ms). Use this BEFORE save_backtest_script or before sending code to a user. Returns {valid, errors[], warnings[]}.

check_backtest_preset

ChatGPT
Checks a backtest preset's settings for errors without running it. Read-only. Details: Sanity-check a strategy settings object before saving. Reports missing required keys, missing recommended keys, and rule violations like: • max-loss > max-profit (asymmetric risk) • adj-stop-time >= tgt-time (adjustments firing past square-off) • entry-start outside 09:15-15:40 trading window Returns {valid, errors[], warnings[]}.

check_entry_rules_now

ChatGPT
Checks whether a strategy's entry rules (time window, weekday, session hours) would allow an entry right now at a spot price the user gives, and which at-the-money (ATM) and offset strikes it would pick. Pure calculation — no market data is fetched, no order is placed. Details: Given a strategy + current spot price (required) + optional date/time (defaults to now in IST), returns whether the strategy would ENTER a trade right now. Checks: entry-start <= time <= entry-end, day-of-week allowed, NSE / BSE F&O trading hours (09:15-15:40), and computes the expected ATM strike + suggested CE/PE strikes (with ce-offset/pe-offset applied). verdict.wouldEnter is true ONLY if all checks pass. blockers[] lists every failed check. Pure analysis — no API calls.

commodity_option_chain

ChatGPT
Returns a historical MCX (Multi Commodity Exchange) commodity option chain at a given past date and minute. Read-only. Details: PRO. Returns the MCX commodity OPTION chain around the money at a timestamp: per strike the call and put OHLC, IV, delta/gamma/theta/vega and OI, plus the front-month future price (spot) and the ATM strike. Args: symbol (e.g. "GOLD"), date (YYYY-MM-DD — use commodity_option_dates to find valid dates), time ("HH:MM" IST, omit for the first available minute), strikes_around (each side of ATM, default 8, max 25), option_type ("call"|"put"|"both", default "both"). Strikes are data-driven. IST timestamps. Research only — not advice.

commodity_option_dates

ChatGPT
Lists the dates with historical MCX (Multi Commodity Exchange) commodity option data. Read-only. Details: PRO. Lists the trading dates for which 1-minute MCX commodity-OPTION data is stored, for a symbol. Monthly expiry; strikes are data-driven (whatever the chain holds). Symbols: CRUDEOIL, CRUDEOILM, NATURALGAS, NATGASMINI, GOLD, GOLDM, SILVER, SILVERM, COPPER, ZINC (any MCX commodity with saved option data). Use this first to discover what to look at, then commodity_option_chain. Args: symbol (e.g. "GOLD", "CRUDEOIL"). Commodities have no spot index — the option chain's spot is the front-month future. Research only — not advice.

commodity_option_price

ChatGPT
Returns the historical price of one MCX (Multi Commodity Exchange) commodity option at a given past date and minute. Read-only. Details: PRO. Returns a single MCX commodity option (one strike + side) at a timestamp: its OHLC, IV, greeks and OI, with the front-future spot and ATM. Args: symbol (e.g. "CRUDEOIL"), date (YYYY-MM-DD), time ("HH:MM" IST, omit for first available minute), strike (number), option_type ("call"|"put"). Strikes are data-driven. IST. Research only — not advice.

compare_backtests

ChatGPT
Compares the results of two or more finished backtests side by side. Read-only. Details: Diff two completed backtests side-by-side. Returns: per-metric deltas (B minus A) for P&L / win% / Sharpe / Sortino / Calmar / max DD / trade count, common-trade-days (dates where BOTH ran), A-only-days, B-only-days, daily P&L Pearson correlation across common days, and which run was the winner per common day (count + percentage). Optionally include the full per-common-day breakdown (date, A dayPnl, B dayPnl, winner) — set includeDayBreakdown=true for that. Use this for "which version of my strategy is better risk-adjusted?", "find days where they disagreed most", or A/B-testing parameter sweeps.

delete_backtest_script

ChatGPT
Permanently deletes one of the user's own Backtest Lab Python strategies. Ask the user to confirm first. Details: Idempotent — returns {deleted: false, reason: "not_found"} if the strategy doesn't exist instead of erroring. Reversible only by re-saving via save_backtest_script.

find_strike_by_premium

ChatGPT
Finds the strike whose option premium was closest to (or at most / at least) a target at a given past date and minute. Read-only. Details: Returns the strike(s) whose OPEN premium matches a target ₹ value at a specific minute. mode: "closest" (default), "le" (≤ target), or "ge" (≥ target) — matches the spot-grid match-mode dropdown in the UI. Returns top N closest strikes per side (default 3) so you can see the neighbours too.

futures_price_history

ChatGPT
Returns historical continuous index and MCX (Multi Commodity Exchange) futures prices. Read-only. Details: PRO. Multi-year CONTINUOUS daily futures history (expiry-stitched) for an index or MCX commodity future — OHLC, volume and open interest. Symbols: NIFTY, BANKNIFTY, SENSEX, CRUDEOIL, CRUDEOILM, GOLD, GOLDM, SILVER, SILVERM, NATURALGAS, NATGASMINI, COPPER, ZINC. Args: symbol (e.g. "CRUDEOIL", "GOLD", "NIFTY"), start + end (YYYY-MM-DD, optional). Use this to study a future's long-term trend, ranges and OI; for a full strategy test use backtest_futures_strategy_python.

get_backtest_preset

ChatGPT
Returns one of the user's own Backtest Lab presets. Read-only. Details: Returns the FULL settings JSON for a strategy by name. Use this to inspect every parameter (entry window, SL/Target, adjustment sessions, pyramiding config, etc.) before suggesting changes or generating Python code. Names are case-sensitive and must match exactly — use list_backtest_presets to discover them.

get_backtest_script

ChatGPT
Returns one of the user's own saved Backtest Lab Python strategies (code and parameters). Read-only. Details: Returns the FULL metadata + Python source code for a saved custom strategy. Use this to inspect what was saved, copy/paste the code, or feed it back into save_backtest_script with modifications. Set includeCode=false to skip the .py source (returns just metadata — useful when listing details).

index_daily_candles

ChatGPT
Returns historical daily candles — open, high, low and close (OHLC) — with gap, weekday and expiry fields for an index over a date range. Read-only. Details: Bulk daily OHLC for an instrument across a date range — ONE row per trading day, aggregated from per-minute CSVs. Each row includes prevClose, gap (open−prevClose), gapPct, dayOfWeek, range, rangePct, AND dte / nextExpiry (days to next on/after expiry). Designed for multi-year historical studies — gap classification, day-of-week effects, regime detection, expiry-day behaviour — where calling one_day_minute_data per day would be 1000+ MCP calls. Server-side filters (all optional, applied AFTER the prevClose chain so gap calcs stay correct): • dayOfWeek — "Mon" / "Tue" / "Wed" / "Thu" / "Fri" (string or string[]) • dates — array of YYYY-MM-DD; returns only these specific days • dte — 0 for expiry day, 1 for T-1, etc. (number or number[]) • minGapPct — only rows with gapPct ≥ this value (e.g. 1 = ≥ +1% gap-up) • maxGapPct — only rows with gapPct ≤ this value (e.g. -1 = ≥ -1% gap-down) Examples: "all 0-DTE Thursdays since 2023" → dayOfWeek="Thu", dte=0. "every >1% gap-down Monday" → dayOfWeek="Mon", maxGapPct=-1. "these 12 specific dates" → dates=[...]. Defaults: type="spot", maxDays=2000 (~8 years). Bytes-per-row ≈ 140, so a 5-year unfiltered request is ~175KB — fits one response. For chain-level intraday detail use one_day_minute_data; for multi-day OHLCV at minute granularity use data.

indicator_history

ChatGPT
Returns historical indicator values (moving averages, RSI — relative strength index, VWAP — volume-weighted average price, and more) for an instrument. Read-only. Details: Per-bar indicator series for one trading day, computed by the engine's own indicator functions (2 prior days prepended for warm-up, so EMA-50/MACD/Ichimoku values are correct from the first bar). indicators: any of rsi, macd, ema (8/21/50 stack), supertrend, vwap, adx, bb, stoch, atr_filter, williams_r, obv, mfi, psar, donchian, keltner, ichimoku. Optional params keyed by indicator id (e.g. {"rsi":{"len":9}}). Returns OHLC + indicator values per bar, downsampled to ≤120 points.

list_backtest_presets

ChatGPT
Lists the user's own Backtest Lab strategy presets (these are not LiveDesk My Strategies). Read-only. Details: Returns your BACKTEST LAB preset library (JS backtest presets) — not LiveDesk "My Strategies" (for those use strategy_builder_my_builds / livedesk_deployments). Each entry includes name, category (e.g. Optional filters: category (path string), search (substring match on name + category). Result is metadata only — use get_backtest_preset for the full settings JSON of a specific strategy.

list_backtest_scripts

ChatGPT
Lists the user's own saved Backtest Lab Python strategies (metadata only). Read-only. Details: Each entry returns metadata only — name, category, savedAt, description, and whether a .py code file is present alongside the .json. Use get_backtest_script to fetch the full Python source for a specific one. Filter by substring search (on name + description) and/or category prefix.

list_option_buying_python_templates

ChatGPT
Lists the option-buying Python strategy templates. Read-only. Details: Lists the user's saved Python option-BUYING strategies (the same library the directional web page's 🐍 Python Strategies panel shows). Filters the shared custom_strategies store to BUY-tagged strategies only. Each entry has name, category, description, and saved parameters. Pass a name to backtest_option_buying_python to run it on the VPS engine.

list_option_buying_templates

ChatGPT
Lists the ready option-BUYING (long call / put) strategy templates of the buy-side backtest engine. Read-only. Details: Lists the 12 built-in option-BUYING strategy templates from the directional engine (ORB momentum, 9:20 straddle-direction, CPR narrow-range, VWAP reclaim, gap-and-go, Supertrend+ADX, 5-EMA reversal, expiry gamma blast, ...). Each entry has name, description, and the full cfg (incl. signal stack) — pass the name as template to backtest_option_buying.

list_running_backtests

ChatGPT
Lists the user's backtests that are still running. Read-only. Details: Lists currently queued + running backtest jobs (with progress %, elapsed seconds, and strategy name). Optionally set includeRecent=true to also include the most recent N finished/failed/cancelled jobs (useful for "what did I just run").

livedesk_deployments

ChatGPT
Lists the user's own LiveDesk deployments (paper and live) with mode, status and today's booked profit and loss (P&L). Read-only — it cannot change anything. Details: List all your LiveDesk strategies (paper + live) with today's booked gross/net P&L, mode and status. Your own account only. Returns counts (total, live, paper), overall todayGrossPnl / todayNetPnl, and per-strategy {id, name, strategyType, instrument, mode, status, multiplier, subscribed, ownedLogic, phase, entered, todayGrossPnl, todayNetPnl}. GROSS P&L is the primary figure; net is after charges.

livedesk_explain

ChatGPT
Explains why one of the user's LiveDesk strategies did or did not trade on a day, from its own reasoning log (entries, adjustments, exits). Read-only. Details: Why a strategy took its trades on a day — the strategy's own reasoning log (entries, adjustments, exits). Owned strategies only; a subscribed strategy's logic is the creator's. Args: name (required — strategy name or deployment id), date (YYYY-MM-DD, optional, default today).

livedesk_history

ChatGPT
Searches the user's booked LiveDesk day-by-day history (positional runs, legs, fills, profit and loss). Read-only. Details: Search your LiveDesk day-by-day BOOKED history — one strategy or all of them. Positional strategies (Positional Discretion, positional keyword strategies, Positional Weekday Short) book EVERY trading day they hold: each day row has grossPnl (that day's slice = realised + MTM change), runGrossToDate, run (counter) + dayOfRun, kind (carry = held overnight, exit = the run's last day, day = intraday), charges, the legs at that day's close (strike, CE/PE, side, lots, avg, close price, open) and the day's fills classified entry/adjust/roll/sl/target/exit. Also returns per-run summaries (daysHeld, gross, maxDrawdown on daily closes, best/worst day, open). Args: name (optional — strategy name or deployment id; omit or "all" = every strategy), from / to (YYYY-MM-DD, default the last 30 days, max 366), run (counter number), q (search: a strike like 23000, a symbol, or text), type (entry|adjust|roll|sl|target|exit|carry), limit (rows, default 200). GROSS is the primary figure. Subscribed strategies show positions + P&L without the creator's logic.

livedesk_keyword_catalogue

ChatGPT
Returns the keyword-engine reference (indicators, candles, price, time and position keywords, and actions) with worked examples. Read-only. Details: Call it before writing a keyword strategy; then ask for full argument detail of the keywords you will use (keywords: ["EMA", "RSI"] or category: "momentum"). The default answer STARTS with "quick_start" (one complete document) and the "cookbook" (how to express common plain-English rules); section: "cookbook" returns only those. Action names (e.g. "exit", "rebalance") resolve in keywords too, and category "actions" lists every action with its arguments. Free; it never changes anything. The US desk also runs US stocks / ETFs in shares (keyword strategies, intraday, long or short, one stock per strategy) and US single-stock options (keyword strategies on one US stock's listed CE / PE contracts, intraday, one stock per strategy); US stock backtests are coming next.

livedesk_report

ChatGPT
The user's booked LiveDesk profit and loss (P&L) for a day, overall and per strategy. Read-only. Details: Your LiveDesk BOOKED day P&L for a date — overall and per strategy. GROSS P&L is the primary figure (net, incl. charges, is secondary). Args: date (YYYY-MM-DD, optional — defaults to today). Your own account only.

livedesk_risk

ChatGPT
Shows which of the user's running LiveDesk strategies are down today, have pending broker lots, are blocked or errored, and what each will do next. Read-only — it cannot change anything. Details: Risk radar across your running strategies — which are down, have unfilled/pending broker lots, are blocked or errored, and what each is about to do next (the next adjustment / roll trigger). Args: minLoss (number, optional — also flag strategies down more than ₹X today). Returns { alerts:[...], all:[...] } sorted worst-first.

livedesk_strategy

ChatGPT
Day-by-day history and lifetime profit and loss of one of the user's LiveDesk strategies. Read-only. Details: Day-by-day history + summary for one of your strategies (any date range). Returns the strategy meta, lifetime P&L (gross + net), and a day-by-day breakdown. Args: name (required — the strategy name or its deployment id), from + to (YYYY-MM-DD, optional). If the name matches more than one strategy the result is { ambiguous: true, matches: [...] } — pick one and call again with the id. A positional strategy books every held trading day as its own row (same counter = same run). To search days by strike / event / run with legs and fills, use livedesk_history.

livedesk_trades

ChatGPT
The order fills of one of the user's own LiveDesk strategies on a day. Read-only. Details: Per-order trade detail for a strategy on a day. Available for strategies you fully own (a subscribed strategy's trade detail belongs to its creator). Returns per-leg fills + orders. Args: name (required — strategy name or deployment id), date (YYYY-MM-DD, optional, default today).

minute_market_data

ChatGPT
Returns historical 1-minute spot, futures or option data for an instrument and past date. Read-only. Details: Returns OHLCV + open interest rows for an instrument over a date range. Optional filters: strike (e.g. 24000) and optionType (CE or PE). Caps at maxRows (default 5000) to prevent runaway responses; the assistant can paginate by narrowing the date range or strike filter. SPX/SPY rows are New-York time (ET) in USD; type "options_week" returns the 1–5 DTE expiries (see the expiry column).

one_day_minute_data

ChatGPT
Returns one past trading day of 1-minute data for an instrument. Read-only. Details: Returns the FULL options chain (every strike, CE + PE, all timestamps) for one trading day. Use this for chain-level analysis or to pull a single day for chart generation. For long ranges, use minute_market_data with a strike filter. SPX/SPY: New-York time (ET), USD; "options" = 0DTE, "options_week" = 1–5 DTE.

optimize_backtest_parameters

ChatGPT
Runs a small grid of backtests over parameter values (for example the stop-loss percentage) and ranks them. The runs are recorded and count toward the plan's backtest allowance. Historical simulation only. Details: Sweeps one parameter across N values and submits one backtest per value, all queued behind the same worker. Returns the list of job IDs IMMEDIATELY — use backtest_status to poll, metrics to compare, or compare_backtests to diff any two. Required: strategy (by name OR inline settings), fromDate/toDate, paramId (any setting key — e.g. "lots", "sl-val", "entry-start", "adj-move-pts"), and values[] (the list to try — 2 to 30 entries). Optional baseOverrides shallow-merges over each run before paramId is applied. Use this for "sweep lots from 1 to 20", "test SL at 20/25/30/35/40%", "find best entry time" etc.

option_buying_signals_at_time

ChatGPT
Shows which option-buying entry signals were true at a given past date and time. Read-only. Details: Evaluates a directional signal stack at one specific bar — "what were RSI / MACD / Supertrend / VWAP / ORB / CPR / PDH-PDL saying at 10:30 on that day?". Uses the exact engine signal code (same warm-up: 2 prior days prepended). Default stack: rsi, macd, supertrend, vwap, orb15, cpr, pdhl — or pass signals [{id, params?}]. Returns each signal's fired/side/value text plus the combined direction per the combo rule. Edge-triggered signals (crosses, flips) only fire ON the cross bar — a quiet bar with all-null sides is normal.

option_chain_at_time

ChatGPT
Returns the historical option chain (strikes and premiums) of an index at a given past date and minute. Read-only. Details: Returns the full options chain at a single minute, pivoted by strike. Each row has Strike, CE OHLC + OI + Volume, PE OHLC + OI + Volume, and distance-from-ATM. Optional radius (default ±15 strikes) limits the window. Use this instead of the raw minute_market_data tool when you only need a snapshot.

option_chain_data_quality

ChatGPT
Checks whether the historical option chain at a given past date and minute is complete (data quality). Read-only. Details: Data-quality scan at a single minute: reports how many strikes within ±N of ATM (default ±20) have missing OPEN/CLOSE on either side. Same logic as the auto-downloader's DQ scan but for an arbitrary minute. Use to verify chain completeness before trusting a backtest that entered at that minute.

run_preset_backtest

ChatGPT
Runs a historical backtest of one of the user's own presets and returns a job id to poll with backtest_status. The run is recorded and counts toward the plan's backtest allowance. Historical simulation only. Details: Queues a backtest run against historical data. Accepts EITHER strategyName (loads saved settings from your library — same library list_backtest_presets returns) OR a full settings object inline. fromDate + toDate are required (YYYY-MM-DD). Optional overrides object shallow-merges over the loaded/passed settings (handy for sweeping a single parameter, e.g. {lots: 10}). Returns a job_id immediately — use backtest_status to poll and backtest_run_details to fetch results when status=done. Concurrency is 1 — submitting while another job is running puts you in queue.

run_python_backtest

ChatGPT
Runs a historical backtest of Python strategy code on QuantDesk's 1-minute data (NSE / BSE index options, MCX commodity options, US SPX / SPY) and returns a job id to poll with backtest_status. The run is recorded in the user's backtest history and counts toward the plan's backtest allowance. Historical simulation only — never a live trade. Details: (Backtest Lab only · for SELL/short-premium strategies — never creates a LiveDesk strategy; for that use strategy_builder_guide) Submits a Python strategy to the engine for backtesting. Two modes: pass name to load a saved strategy from custom_strategies/, OR pass code + parameters inline for a one-off test. overrides shallow-merges over the loaded params (handy for sweeping a single value). Returns jobId IMMEDIATELY — the actual engine run happens in the background and writes results to the SAME SQLite table the JS backtests use, so backtest_status / backtest_run_details / metrics / trades / mtm / movement_ / point_ / compare_backtests / backtest_monte_carlo all work on the returned jobId without any code path differences. If you are running a strategy you just authored in this session, follow Phase 4 of the workflow in backtest_engine_docs: poll backtest_status({jobId}) every ~30s (typical 30–90s per month of data, 17 months ≈ 5–8 min), then present a compact backtest_metrics({jobId}) summary first — only load backtest_trades if the user explicitly asks for the per-trade log. parameters.dte (0–5, default 0) picks the expiry each day trades: 0 = that day's 0DTE, N = the N-th next expiry. US data starts 2026-10-01 for options (2026-09-02 for spot) — check available_dates first. POSITIONAL / multi-day (India NSE/BSE + MCX): set parameters.positional = true — no daily square-off, legs carry overnight, the strategy closes them itself (portfolio.close_all / close_strangle / close_leg), bar.dte = trading days to the expiry (0 = expiry day), legs still open after their expiry settle at intrinsic value — read backtest_engine_docs({section:"positional"}) first. MCX (Pro): instrument CRUDEOIL / CRUDEOILM / NATURALGAS / NATGASMINI / GOLD / GOLDM / SILVER / SILVERM / COPPER / ZINC — nearest monthly expiry, bar.spot = the front-month future, 09:00–23:30 IST, intraday square-off 23:25 by default (backtest_engine_docs({section:"mcx"})). Positional and MCX runs return the engine notes in backtest_metrics().warnings.

save_backtest_script

ChatGPT
Saves Python strategy code to the user's Backtest Lab library (for backtests only — it never appears in LiveDesk My Strategies and can never be deployed). With overwrite=true it replaces the user's own script of the same name. To create a strategy that runs on LiveDesk use strategy_builder_save. Details: BACKTEST LAB ONLY. This does NOT create a LiveDesk strategy: it never appears in LiveDesk "My Strategies" and can never be deployed. To create a strategy that runs on LiveDesk (paper / Live Offline / Live Auto), use strategy_builder_guide instead. The strategy becomes available cross-device — the MCP, the Python engine, and the browser UI all read from this same folder. BEFORE calling this tool for the first time on a new strategy idea, call backtest_engine_docs to read the mandatory 4-phase workflow (Understand → Ask & Confirm with concrete examples → Develop → Backtest). Do NOT write Python from a user prompt without first summarizing the spec back and getting explicit confirmation. ALWAYS pass the full settings as parameters (confirmed with the user) AND the full Python source as code. The code must define a class named Strategy with at least an on_bar(self, bar, portfolio) method. Unless skipValidation=true, the Python engine /validate is called first to catch syntax errors before save. Set overwrite=true to replace an existing strategy with the same name. The name is whatever the user said to call it — it becomes the handle for all subsequent get/run/delete operations.

screen_stocks_by_trend_stage

ChatGPT
Screens NSE / BSE stocks by trend stage using the previous trading day's data. Read-only; not a recommendation. Details: Scans the ENTIRE NSE/BSE universe (pre-computed nightly) and returns the stocks matching stage/condition filters — e.g. "all stocks currently in Stage 2", or "stocks that turned Stage 2 in the last N days", each with the date + level it entered. Fast, because it reads the nightly snapshot, not live data. Args: preset (same as stock_trend_stage); only_stage2 (default true — all conditions met); stage (1–4); entered_within_days (only those that turned Stage 2 within N days); max_pct_from_hi (e.g. 5 = within 5% of the 52-wk high); min_pct_above_lo; exch ("NSE"/"BSE"); sort ("stage2_since" | "pct_from_hi" | "close"); limit (default 100, max 500).

stock_price_history

ChatGPT
Returns historical daily or weekly prices of one NSE / BSE listed stock. Read-only. Details: Args: symbol (e.g. "BHARATFORG", "RELIANCE"), timeframe ("daily" | "weekly", default daily), start + end (YYYY-MM-DD, optional), exch ("NSE" | "BSE", optional — defaults to NSE). Returns OHLCV candles. Use this to study a stock's trend, levels and moves over time.

stock_trend_stage

ChatGPT
Classifies one NSE / BSE stock's trend stage from its historical weekly prices. Read-only; not a recommendation. Details: Weinstein-style STAGE ANALYSIS for any NSE/BSE stock on weekly bars — and the key answer: if it is currently in a Stage-2 advance, the exact DATE and price LEVEL it entered Stage 2 (not just that it qualifies today). Computes, every week: close vs the slow MA, fast-MA vs slow-MA, slow-MA slope, relative strength vs NIFTY + its MA, and 52-week-high proximity. Returns the current stage (1–4), whether all conditions are met now, each condition's pass/fail, and enteredStage2 {date, level, bars_ago}. The condition set is configurable. Args: symbol (required); preset ("weinstein_stage2" default | "trend_up" | "high_breakout"); params (object to tune the rules: ma_fast, ma_slow, rs_ma, hi_window, near_high_pct, timeframe "weekly"/"daily", and toggles require_rs_above_ma / require_near_high / require_slow_rising / require_fast_above_slow / require_close_above_slow / require_close_above_fast).

stop_backtest

ChatGPT
Cancels one of the user's running backtest jobs (the partial run is discarded). Details: Cancels a backtest job by id. If the job is queued, it is removed from the queue. If running, the worker page is reloaded to abort the in-flight engine loop. No-op for jobs already in a terminal state (done / failed / cancelled).

straddle_premium_at_time

ChatGPT
Returns the at-the-money (ATM) straddle premium — the call plus the put at the strike nearest the index — at a given past date and minute. Read-only. Details: Returns the ATM straddle premium (CE + PE at the strike closest to spot) at a single minute. A quick IV proxy: ATM straddle ≈ market's implied expected move. Returns each leg, the combined premium, and a rough implied-move-percent estimate (combined / spot × 100).

strategy_builder_discretion

ChatGPT
Builds a Discretion (leg-by-leg) strategy book step by step inside a temporary scratch DRAFT that belongs to this build only (kept on the QuantDesk server and removed automatically after 7 days without use). Every operation, including remove_leg and remove_pair, changes only that draft: it never changes, overwrites or deletes anything the user already has (saved strategies, deployments, positions, orders or money), and anything removed from the draft can be added back with the next call. Use it only when the user asks for a Discretion book or names a template; build other index and commodity strategies with strategy_builder_keywords. Inputs: market (IN or US), op (the operation), draft_id (needed after the first call) and input (the arguments of that operation). Start with op=start (input: instrument, kind intraday or positional), op=from_template (input: template_id, instrument, mode) or op=from_strategy (input: name — copies one of the user's own Discretion books into a new draft; the saved book itself is not changed). Change the draft with add_leg, add_legs (several legs in one call), update_leg, remove_leg, upsert_pair, remove_pair, set_book_settings and set_instrument_mode; get_strategy, validate_strategy and explain_rule read it back (strategy_builder_schema with family disc or pdisc lists the fields of each operation). Leg values: side sell | buy · type CE | PE | FUT · strikeMode atm | atmstep | depth | premium | delta | pctotm | rel | explicit · sl / tgt off | pct | pts | level · trail off | be | step | keep · reentry off | price | atm | wait. A stock F&O FUT leg trades the month in futExpiry (cur or next): set it to the month the user named. A template brings its own defaults: change or switch off every value the user did not choose, and ask the user before every value that changes money at risk (lots, exact times, stop basis). A book without a run mode runs only once after it is deployed, so ask the user. Each call returns the whole draft, a summary and the validation result. It saves nothing, deploys nothing and places no order: when the draft is ready, check it with strategy_builder_preview and save it with strategy_builder_save (which always adds a NEW strategy and never overwrites one) only when the user asks.

strategy_builder_guide

ChatGPT
Start here to build a strategy that runs on LiveDesk (QuantDesk's strategy engine): returns the strategy families, templates, common parameters, rules and the step-by-step build protocol. Read-only. Details: START HERE whenever the user wants to build, create, design, convert or change a LiveDesk strategy with you (a strategy that runs on QuantDesk LiveDesk — paper, Live Offline or Live Auto; not a backtest) — including "create / develop / build / save it on QuantDesk", "put it in my strategies", "deploy it", "paper trade it", "no backtest" (any language). DEFAULT: build every index / commodity strategy (intraday — and positional, held overnight, on NSE / BSE index options and futures, MCX options and futures (CRUDEOIL, CRUDEOILM, NATURALGAS, NATGASMINI, GOLD, GOLDM, SILVER, SILVERM, COPPER, ZINC) and NSE F&O stocks) as a Keyword Strategy (family kw) with livedesk_keyword_catalogue + strategy_builder_keywords — straddles, strangles, spreads, ladders, re-entries, adjustments and indicator / candle / time / position rules alike. Never ask the user "keyword or Discretion?". Discretion (disc / pdisc) only when the user asks for it or names a template, edits their own Discretion book, trades an NSE F&O stock the keyword tools refuse, or the keyword engine cannot express the logic (e.g. Family choice: a generic family only when the user names it — otherwise kw. The generic families (straddle, strangle, iron_condor, iron_fly, short_butterfly, jade_lizard, call_spread, put_spread, single, call_buy, put_buy, buy_strangle) take ONLY their own parameters (ATM ± offsets, one stop style, a fixed shape) — chosen wing distances, a points stop per leg, different lots per leg, calendars, two independent signals or any condition = a keyword strategy (kw). A generic family enters at the first chance inside its entry window (entry-end defaults to 14:30): for "sell at 09:20:00" set the window end a little later and ask how late a missed entry may go; a hidden feature group you switch on (e.g. the survivor rules after one leg stops) comes with defaults the user never chose — set or ask every key of it. topic "families" returns the short answer (no template list). call_spread / put_spread have NO width setting (and their description does not show the bought leg): a spread with a chosen width = kw. Open-interest / PCR keywords become available with the open-interest release (listed as not_available until then) — never fake them: build the rest, say in one kind line that the open-interest rule works once open-interest data is live, and offer to save. You must ask the user every open question before saving (2–3 at a time, each with a suggested answer) — never decide a money choice on the user's behalf. The US desk also runs US stocks / ETFs in shares (keyword strategies, intraday, long or short, one stock per strategy) and US single-stock options (keyword strategies on one US stock's listed CE / PE contracts, intraday, one stock per strategy); US stock backtests are coming next.

strategy_builder_keywords

ChatGPT
Builds a LiveDesk keyword strategy step by step inside a temporary scratch DRAFT that belongs to this build only (kept on the QuantDesk server and removed automatically after 7 days without use). Every operation, including the remove and replace ones, changes only that draft: it never changes, overwrites or deletes anything the user already has (saved strategies, deployments, positions, orders or money), and anything removed from the draft can be added back with the next call. The draft is one JSON document with legs, entry and exit conditions, adjustments, re-entry runs and risk limits, written with the keywords that livedesk_keyword_catalogue lists. Inputs: market (IN or US), op (the operation), draft_id (needed after the first call) and input (the arguments of that operation). Start a draft with op=start (input: instrument, optional doc), op=from_example (input: example, instrument) or op=from_strategy (input: name — copies one of the user's own keyword strategies into a new draft; the saved strategy itself is not changed). Change the draft with the add / replace / remove operations for legs, conditions, repairs, actions, parameters and variables, or with set_entry, set_runs, set_risk, set_exec, set_exit_time, set_settings and set_doc; get, validate and describe read it back. Each call returns the draft id, the full draft document and its settings, the validation result (errors and warnings with the exact document path), a plain-English definition of the rules and a short summary. It saves nothing, deploys nothing and places no order: once the draft has no errors, check it with strategy_builder_preview and save it with strategy_builder_save (which always adds a NEW strategy and never overwrites one) only when the user asks.

strategy_builder_my_builds

ChatGPT
Lists the user's AI-built LiveDesk strategies, or loads one by name (settings and plain-English description) so it can be changed and saved under a new name. Read-only.

strategy_builder_preview

ChatGPT
Checks a candidate strategy before saving and returns its errors, the questions still open for the user and the plain-English description LiveDesk will show. Read-only preview. Details: Check a candidate strategy BEFORE saving. Returns errors (fix them), warnings, open_questions (ask the user — saving is refused while any remain), assumed_defaults (NOT asked — list them to the user once with the description, "change any?"), defaults_used, and the plain-English description that LiveDesk's Describe button will show. Errors are yours to fix — never show them to the user. Answers must carry the user's own words. Previews are limited per account (40 in 10 minutes by default) — send all answers in one call. The FIRST preview returns the open questions for the strategy as built: only money semantics (size, entry / exit times, stop basis and value, reset-vs-carry, broker-fill vs desk price, run mode, …) that the user's own messages did not already settle — those are answered from the user's words (answered_from_user_words). Ask the user only the open ones (one the user's message really does answer may be answered by quoting that message verbatim — never with your own wording or a guess). Warnings are information, not orders: never add a cap, a stop or a hedge because of a warning.

strategy_builder_save

ChatGPT
Saves a previewed strategy as a NEW strategy in the user's LiveDesk My Strategies, only after the user confirmed the summary. It never overwrites an existing strategy, never deploys it and never places an order; deploying (paper or live) is done by the user on LiveDesk. Details: Save a previewed strategy to the user's LiveDesk My Strategies. After saving, show the returned disclaimer to the user word for word and recommend running it on Live Offline first.

strategy_builder_schema

ChatGPT
Lists the parameters of one strategy family on one instrument and the questions to ask the user before saving. Read-only. Details: The parameters of ONE family on ONE instrument, grouped exactly like LiveDesk's Edit Parameters (the Common group first): key, label, type (num | sel with options | chk true/false | time HH:MM:SS | dow weekday list 1–5), default, help text and when a row applies. Also returns the QUESTIONS (with ids) you must ask the user — only the money semantics (size, entry / exit times, stop basis and value, reset-vs-carry, price source, run mode …) the user's own words have not settled yet — and assumed_defaults: everything else runs on the family default and is only listed to the user once ("change any"). Ask the questions in plain language, quoting the defaults. Discretion (disc / pdisc) also returns the book-building operations; Custom Multi-Leg returns its JSON format; Keyword Strategy (kw) returns the document grammar and the strategy_builder_keywords operations.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

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/quantdesk"><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/quantdesk)