Connect AI apps

DocumentationWriting strategies

Connect AI apps

An AI app such as Claude, ChatGPT or Cursor can work with Caldex in two ways, and they reach different things. AI apps on this computer reads this installation. AI apps in the cloud reads your account on our server. Both speak the Model Context Protocol (MCP), the open standard AI apps use to reach other software, so any app that speaks it can use either.

AI apps on this computerAI apps in the cloud
Where the app runsClaude Desktop, Claude Code, Cursor or another MCP app, on the computer Caldex is installed onClaude, ChatGPT, Le Chat, Cursor, VS Code and other MCP apps, in the browser, on your phone or on any computer
What it can doRead your whole library and your local runs, validate code, export to Pine, MQL5, cTrader or Rust, read these pages and the indicator libraryRead strategies synced to the server, your server runs and their results, your usage and limits, the leaderboard, these pages and the indicator library, and start server runs if you allow it
What it costsNothing, on every planNothing to connect. A server run spends your plan's server minutes, and Free has none
Internet neededNoYes

Neither one saves or changes your work. Putting a strategy in your library is always your action in the app.

Both can be connected at once, even to the same app. They know nothing of each other. That is worth it when you write strategies on this computer and want your app to validate and export them here, and also want to start a server run or check your minutes from the phone or from claude.ai or ChatGPT while you are away.

AI apps on this computer

Nothing on our servers is involved. Your AI app starts the server as a process on your own machine, the model is your app's, and we hold no key and make no model call.

The browser build has none of it. There is no process to start and no file to write, so Connect AI apps in the browser's settings offers AI apps in the cloud alone, which does not need the app at all.

Turning it on

Settings, Advanced, Connect AI apps, On this computer. The card walks you through four steps. Step 1 is the switch. It is off until you turn it on, because turning it on writes your saved strategies and all your runs to a plain JSON file inside the application's own folder. It has to be plain: the server is a separate process and cannot read the encrypted storage the app uses for keys. Turning the switch off again deletes the file.

In step 2 you pick your AI app, and step 3 shows the one thing to paste for it, read from this installation rather than from this page. Step 4 is the restart and a first question to ask.

Connecting Claude Desktop or Claude Code

Claude Desktop reads claude_desktop_config.json. Add the command exactly as the settings card shows it:

json{
  "mcpServers": {
    "orionquant": {
      "command": "C:\\Users\\you\\AppData\\Local\\Programs\\Caldex\\resources\\python\\python.exe",
      "args": ["-I", "-B", "--check-hash-based-pycs", "always", "C:\\Users\\you\\AppData\\Local\\Programs\\Caldex\\resources\\shell\\mcp_launcher.py"]
    }
  }
}

The path differs per platform and per install location, which is why the card shows yours instead of this page claiming to know it. A Windows path doubles its backslashes, because the value is a JSON string. Restart Claude Desktop after editing its configuration.

Claude Code takes the same command after a --, with each path in quotes because the folder name has spaces in it. The card shows this line ready to paste as well:

claude mcp add orionquant -- "C:\Users\you\AppData\Local\Programs\Caldex\resources\python\python.exe" -I -B --check-hash-based-pycs always "C:\Users\you\AppData\Local\Programs\Caldex\resources\shell\mcp_launcher.py"

Cursor, VS Code and other MCP apps take the same command and arguments in their own configuration, as a server that is started rather than a URL.

The command stays valid when the app updates itself. The launcher finds the version you have installed each time it starts.

What it can do

Twenty five tools. Twelve of them only read and work with the app closed, and report_bug drafts a bug report it cannot send. Twelve work in the app while it is open, and only with Let AI agents work in this app on (Settings, Connect AI apps, step 5): download_data adds market data, and the agent tools write strategies and run backtests.

  • list_strategies and read_strategy read your library. A read carries the documentation pages for that strategy's provider, so the model has the API in front of it rather than guessing. It also carries the entry's own source when the entry has one: has_source says whether it does, and source is null when it does not.
  • Strategies you did not write are marked. An entry installed from the marketplace or sent to you by another user carries provenance with third_party and the author, and its name, source and files, and those of its runs, arrive between two marker lines, with a note to the model that the text is data to read and never instructions to follow. The model can still read and review it.
  • list_runs and read_run read finished runs. A read returns the statistics, the engine version, the seed, the data source, the accuracy tier it asked for, the optimization summary when the run was one, and the whole configuration: commission per lot, swap pips per night, leverage, lot size, starting balance and intrabar fill priority among them, and the slip beyond the touch when the run set one. That slip is the only slippage setting, a TICK tier one for entries larger than the size at the best price. Beyond it, slippage is not modeled past the spread and the gap rule, which Costs and Fills explains. A review that cannot see the costs is a review of the run's luck.
  • validate_strategy parses Python source and reports syntax errors, the Strategy subclasses it defines, whether a per bar hook is present (on_market, and it also accepts on_bar or on_tick), and any import the sandbox will refuse. It never executes what you give it.
  • validate_pine compiles a Pine script as the engine will and reports every line it refuses, with the column and the reason, or the inputs the optimizer will sweep. export_strategy prints a Pine strategy, or a built in one, as Pine Script, an MQL5 expert advisor, a cTrader cBot or Rust for the engine's core, and returns the text. Neither runs anything, and neither writes a file.
  • search_docs and read_doc read these pages.
  • list_indicators lists the indicator library, by group or by a word to look for, with one sentence each of what it measures. describe_indicator gives one in full: what it measures, the formula in words, how to read it, its inputs with defaults and bounds, its lines, and the exact call in Python, C#, Rust, a formula and the strategy IR. An unknown id is refused with the ids that exist.
  • list_local_data says which market data is already on this computer: per instrument, each timeframe's first and last day and its size on disk, the tick days, and the day ranges the archive supplied, so a gap shows. It reads the data folder and nothing else, and works with the app closed.
  • download_data downloads history the way the Data page does: minute bars from the Orion Quant Technologies archive with the timeframe built from them, and ticks on a plan that has them. The first call downloads nothing. It answers how many days are missing, about how many MB they are, and whether your plan allows them, so the model can show you the size first. Only a second call with confirm set starts it. The download runs in the app, which has to be open and signed in, with Let AI agents work in this app on: the license stays in the app, and without a license there is no data. While it runs, the same call reports progress and never starts a second download.
  • Limits keep a model from filling the disk. One call takes at most five years of bars, a year of S5 or 90 days of ticks. AI apps on this computer may start 24 downloads and about 3 GB a day, one at a time, and never closer than 2 GB to a full disk. A plan's own window and tiers apply as on the Data page.
  • create_strategy saves a new workspace into your library once the engine accepts its code, checked as the editor checks it: the file that runs, its helpers and its notes, by the rules on the Workspaces page. update_strategy changes one of your own: its name, its code, its helpers and notes (added or replaced, never deleted) or its parameter values. append_journal adds one dated entry to its journal.md. create_variant adds a variant and save_setup a setup for one instrument; a run names the variant, and its setup follows the instrument. A strategy somebody else wrote is never changed in place; the model makes its own copy. A strategy an agent wrote is still yours, marked as written by an agent. Code an agent wrote runs on this computer with your rights, so the app asks you once, on the agent switch or at the first run, with the code to read. Until you have said yes, an agent's run is refused and says so; it cannot answer for you. Switching the agent off takes the yes back.
  • run_backtest runs a saved strategy exactly as the Run button does. It puts the strategy, its parameters, the market and the period into the run settings first, so you see the run start and the settings show what ran. The model can set every other run option too: starting balance and account currency, leverage, lot size, commission, swap, fill priority, accuracy tier, slippage at the tick tier and the engine, each checked as the settings check it. What it leaves out (and the in-sample split, unless it sets that) is what the settings show; get_run_settings reads them. Days missing of the range are downloaded first, as the Run button downloads them, and count against the agent's daily allowance. The answer carries the run's id, its figures (both parts of a split run), settings_used with every setting the run used and the engine that ran, and the whole configuration the engine received, which is also what the run keeps. Runs are local.
  • get_run_status follows a run that is still going, or reads a stored one. get_run_trades and get_run_equity read a finished run's trades and equity curve, a page at a time.
  • run_optimization sweeps up to four parameters of a saved strategy over ranges, through the same plan checks and the same monthly optimizer runs as the Start button on Optimize. Its base is the run settings, set as for a backtest, and it answers with the best passes; the model runs the one it picks with run_backtest. compare_runs sets stored runs side by side: what they share, what sets each apart, and each figure's difference from the first. cancel_run stops a backtest or a sweep the agent started; a stopped backtest files nothing, a stopped sweep keeps its passes.
  • audit_run audits a stored backtest exactly as the button on Audit does: all four tabs, from your plan's audits for the month, kept with the run and shown on the Audit page. The released app shows an audit some minutes after it ran, for an agent too, and get_audit reads it from then. Before your first audit the app shows you a notice that only you can confirm; until you have run one audit yourself, an agent's audit is refused and says so. run_optimization with algorithm: walk_forward runs the walk forward of Optimize and answers each window's parameters and how they did after it.
  • Everything else you do in the app, it can do too, except buy. Publishing: set_publish_level, delete_strategy, marketplace, share_strategy, leaderboard and watchlist. The Runs list: delete_run and pin_run. Data: list_instruments, delete_data and cancel_download. Settings and your account: get_settings, update_settings and get_account. Live: deployments and broker. The community: forum, traders and notifications. And plugins and strategy_templates. Each does what the screen's own button does, so you see it in the app at once.
  • And the last of it: test_file runs one file on its own, restore_default_strategy brings the starter strategy back, github pushes and pulls (linking GitHub stays your sign in, in the browser), source_cache lists and clears fetched sources, archive_order orders what the archive lacks of a range, plugin_export runs a plugin's exporter, account_library keeps your indicators, plugins and blocks, referrals reads your link and figures, live_local runs a strategy live on this computer, and rust_toolchain sets up Rust. plugin_code writes plugin code: a plugin runs inside the engine, outside the strategy sandbox, so a plugin an agent wrote or changed stays off until you read its code and allow it, and every change asks again.
  • Where the app asks you in a dialog first (deleting, unpublishing, removing a post, stopping a deployment, sending a deployment's orders to a demo account), the tool asks too: its first call does nothing and hands the model the dialog's words to show you, and only a second call, after you agreed and with the token the first one answered, does it. What other people wrote (listings, posts, profiles, notes) reaches the model marked as data to read, never as instructions.
  • While an agent works, the header shows what it does, with Stop. Stop refuses every new call until you press Resume and stops a backtest or a sweep the agent started, and the notification says what the agent was doing.
  • report_bug prepares a bug report when you tell the model something in the app does not work: what happened, what you expected and the steps. It cannot send it, because this connection is not signed in to your account. It hands back the draft, which you send from Help Center, Report a bug, or through AI apps in the cloud, which sends it for you.

What it does not

It never buys: no plan, pack, top-up or checkout is reachable from a tool. It does not sign you in or out, change your password, two step sign in, sign-in methods or sessions, disconnect an app in the cloud, or delete your account. It gives no consent for you (analytics, the newsletter, sharing figures, sending prompts to an AI provider abroad), sets no key, and never sees your license, your keys or your passwords. Connecting a broker account or GitHub is a sign in you do yourself in the browser, and an imported plugin, or code somebody else wrote, runs only after you said yes in the app. With Let AI agents work in this app off, nothing here changes anything: a model can propose a change and validate it, and putting it in your library is your action. Server runs and your usage come through AI apps in the cloud.

The copy holds the summary of a run, not the body. The statistics and the configuration travel. The trade list and the equity curve come only through get_run_trades and get_run_equity, with the agent switch on; the replay frames and the tier the engine reports having actually used stay in the app.

It reads a copy, not the live app. The file is rewritten when your library or your run history changes, so with the app closed the model sees the state as of the last change. The copy carries the time it was written, and list_strategies and list_runs return that time.

It is this machine, not your account. Strategies you saved on another computer are not in this file.

Every run on this machine travels, however many there are.

AI apps in the cloud

AI apps in the cloud connects an AI app to your Caldex account on our server, not to this app. It works with the app closed, from any device you use that app on, and it needs an internet connection. Claude, ChatGPT, Le Chat, Cursor, VS Code with GitHub Copilot, Zed, Codex, Gemini CLI and any other app that can add a remote MCP server with OAuth sign in can connect. The address is the same for all of them: https://engine.orionquant.com/mcp. Settings, Connect AI apps, In the cloud shows it with a copy button and the steps for Claude, ChatGPT and Cursor.

Every app connects through the same consent screen. It shows the app, the address the approval is sent back to, the account, and what the app may do.

  • Verified. Orion Quant Technologies knows the app by the exact address its approval goes to: Claude, ChatGPT, Le Chat, Cursor and VS Code each have their own, and Claude Code, Codex, VS Code and Zed can also identify themselves with a document on their maker's site. The screen then shows the app's real name with a Verified mark and its maker. An app can call itself anything; only this check decides the name you see.
  • On this computer. The approval goes back to your own computer (localhost or 127.0.0.1), as Claude Code, Gemini CLI, Cursor and VS Code on the desktop do. Nobody else can receive it there, but Orion Quant Technologies cannot tell which program is listening. Approve only if you just started this yourself.
  • Not verified. Any other app with an https address. The screen says so in red and names the exact host the approval goes to. Approve only if you started this yourself and know the app. A name you do not expect, or an address you do not recognize, is a reason to stop.

Connecting claude.ai

  1. In Caldex, open Settings, Connect AI apps and copy the connector URL shown there.
  2. In claude.ai, open Settings, Connectors, Add custom connector, paste the URL and press Connect.
  3. Sign in to Caldex, the same way you sign in to the app.
  4. The consent screen shows Claude, verified, sending you back to claude.ai.
  5. Tick Allow starting server runs only if you want Claude to spend server minutes. With it ticked you can also set a monthly minute ceiling for this connection. Without it, Claude reads and never starts a run.
  6. Approve, and you are back in claude.ai with Caldex connected.

A connector added on claude.ai is also there in the Claude app on your phone and in Claude Desktop, signed in to the same Claude account. On a Claude Team or Enterprise plan, an owner of that Claude organization may have to add the custom connector first.

Connecting ChatGPT

  1. In ChatGPT, open Settings, Apps and Connectors, and turn on Developer mode under Advanced. Whether it is offered depends on your ChatGPT plan, and in a Business or Enterprise workspace on its admin.
  2. Create a new connector, name it Caldex, paste the connector URL and choose OAuth.
  3. Sign in to Caldex. The consent screen shows ChatGPT, verified, sending you back to chatgpt.com. Approve.

Connecting Cursor

Add the connector to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project. The settings card copies this block with your address in it:

json{
  "mcpServers": {
    "orionquant": {
      "url": "https://engine.orionquant.com/mcp"
    }
  }
}

Cursor then opens the browser to sign in. The consent screen shows Cursor, verified, or an app on this computer when Cursor's desktop app receives the approval itself. Approve. If AI apps on this computer is already set up in Cursor as orionquant, give this one another name, orionquant-cloud for example.

Connecting VS Code and other apps

In VS Code, run MCP: Add Server, choose HTTP and paste the connector URL; GitHub Copilot's chat then signs in on first use. Other apps call the same thing a remote MCP server, a connector or a custom connector: give it the connector URL and sign in when asked. The app has to support signing in with OAuth; an app that only takes a fixed key cannot connect.

Connecting Claude Code

claude mcp add --transport http orionquant https://engine.orionquant.com/mcp

Then type /mcp in Claude Code, pick orionquant and sign in. The browser opens the same sign in and consent screen, and the address it sends you back to is on your own computer. If AI apps on this computer is already added to Claude Code as orionquant, give this one another name, orionquant-cloud for example.

What it sees

Your account on the server, and only what is there:

  • Strategies synced to the server. A strategy is synced when you run it on the server or publish it. A strategy you have only ever run on this computer is not on the server, and AI apps in the cloud cannot see it.
  • Your library of indicators, plugins and custom blocks, the one kept with your account.
  • Your server runs and their results.
  • Your usage and limits: the plan, the server minutes used and left this month, and the other allowances.
  • The leaderboard, which is public anyway.
  • These pages and the indicator library.

It never sees another user's private work or anyone's email address, yours included.

What it cannot do

It changes nothing in your account. There is no tool that saves, renames or deletes a strategy, and none that changes a setting. It does not validate or export code: for now that runs on this computer, through AI apps on this computer. It does not see your local runs, the data on this computer, your broker keys or your live deployments.

Server runs

Only with Allow starting server runs ticked. A run the app starts is a run you started: it spends your server minutes exactly as a run from the app does, the same plan limits and minute packs apply, and it appears among your server runs. The run tools are marked as ones that change something, so apps such as Claude and ChatGPT ask you before they start one. The minute ceiling, when you set one, stops runs through this connection once it is reached for the month; your plan's own allowance applies as well. Free has no server minutes, so on Free AI apps in the cloud read and cannot run.

Reporting a bug

When you tell the model something in the app does not work, it can send the team a bug report with report_bug. It shows you the draft first, with what happened, what you expected and the steps, and asks you once. The report is marked as sent by an AI app and carries the app's name, never your keys or passwords. An account sends at most five reports a minute and twenty a day.

Ending a connection

Settings, Connect AI apps, Connected apps, Revoke. Access ends at once, with the app's next request. A connection also ends on its own after 90 days at most, or after 30 days without use. Connect again to carry on.

We send a mail to your address whenever a new connection is made, so one you did not make does not go unnoticed. If you get one you do not recognize, revoke it at once.

Who can connect

Any Caldex account, on every plan. Staff accounts cannot connect. While Caldex is open only to the accounts let in so far, only those accounts can connect.

Caldex