MCP App Store
by KeenEthics
Spera icon

Spera MCP Server for ChatGPT

By SPERO SPERA PRIVATE LIMITED

Overview

Spera helps users create, inspect, revise, and compile private trading strategies, reusable modules, and custom nodes; run exact-revision backtests; and maintain project knowledge and artifact documentation. It does not deploy live trading bots, place trades, or access exchange credentials.

How to connect

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

Tools

spera_artifact_get

ChatGPT
Read one exact authorized artifact. Owned writable strategies/modules include their bounded graph; modules also include a ready-to-copy moduleReference and exact input/output port handles for strategy embedding. Pass version to read a specific strategy revision instead of the default branch: version.branchId alone reads that branch HEAD and reports the concrete commitId back in artifact.version, and version.branchId + version.commitId reads that exact immutable commit. Branch ids come from spera_strategy_branches_list. version is strategy-only — modules are addressed by moduleVersion and custom nodes by their compiled revision, so sending it for those kinds is rejected rather than ignored.

spera_backtest_cancel

ChatGPT
Idempotently request cancellation of one caller-owned queued or running deep-backtest job. Pass kind:'compare' to cancel a branch sweep started with spera_backtest_compare_start, kind:'portfolio' for a portfolio run, kind:'universe' for a universe preview or picker check, or kind:'universe_backtest' for a universe backtest; none of them is reachable at the plain deep-backtest path.

spera_backtest_compare_start

ChatGPT
Run the strategy at version.branchId/version.commitId PLUS every branch in revisionBranchIds over the same market window, as ONE job with one ranked result. Use this instead of calling spera_backtest_deep_start once per branch: the per-user concurrent-job limit rejects that (1 job on free, 4 on pro), and it is charged one deep-backtest allowance per strategy run (the subject plus each branch, template and peer), reserved whole before the job starts. Branches are taken as they are NOW — each branch HEAD is pinned when the job is created and the resolved commit comes back on the report, so a later commit cannot rewrite what a finished sweep says it ran. A branch that no longer compiles reports its own error and the rest of the sweep still completes. Optionally add templateIds, peerStrategyIds and includeBuyAndHold as extra comparison targets. Poll with spera_backtest_get using kind:'compare' — a compare job is NOT reachable at the plain deep-backtest path. The report carries metrics and equity curves per branch; it has no per-branch trade log.

spera_backtest_deep_start

ChatGPT
Create or reuse one durable deep-backtest job bound to an exact strategy commit, market range, engine inputs, and normalized settings. Pass the strategy as top-level artifactId plus version.branchId/version.commitId; projectId and strategyId are not inputs. from, to and warmupFrom are Unix epoch MILLISECONDS (13 digits): 2024-01-01T00:00:00Z is 1704067200000.

spera_backtest_get

ChatGPT
Read one caller-owned job with compact progress or summary, its exact reproducibility binding, recommended poll interval, expiry, and remaining poll budget. Set kind to reach a job off the plain deep-backtest path: 'compare' (branch sweep, report inline), 'portfolio' (artifactId = portfolioId), 'universe' (a universe preview or picker check, artifactId = universeId; its report, the coin table or the ranking read, arrives inline once completed), or 'universe_backtest' (a universe's own backtest from spera_universe_backtest_start, artifactId = universeId; its summary arrives inline).

spera_backtest_quick_run

ChatGPT
Synchronously simulate one exact strategy commit over a bounded caller-supplied candle set. Returns a compact summary and never deploys.

spera_backtest_results_get

ChatGPT
After completion, read the compact summary or one bounded page of trades, equity points, or diagnostics on demand. A comparison job's report returns inline from spera_backtest_get with kind:'compare', and has no paginated trade or equity artifacts. A universe job (kind:'universe') has no trades, equity or edge sections: read its report inline with spera_backtest_get and page its plan series here with section:'plans'. A universe backtest (kind:'universe_backtest') pages its combined equity (positionId:'benchmark' for its buy-and-hold twin), its combined trades, section:'plans' (every pick with the account around it; symbol filters to one coin) and section:'book_events' (why each coin joined, left, was resized or stopped).

spera_context_get

ChatGPT
Return the authorized user, project context, explicit project-selection rules, contract version, capabilities, and limits. Call it only to start or refresh Spera strategy, module, custom-node, backtest, or project-knowledge work; never to check whether Spera can trade, quote prices, hold exchange credentials, or give investment advice (it cannot). For the initial call pass no arguments ({}). Empty project pages are valid and do not block strategy creation. For an edit, use an explicit or unique authorized Project; if multiple Projects are plausible, ask the user to select one by returned name and ID. To continue the project list, pass only nextCursor as cursor plus pageSize; pagination is output, not input.

spera_custom_node_compile

ChatGPT
Explicitly compile the exact custom-node revision. Only real Rust compiler failures consume the five-attempt budget.

spera_custom_node_create

ChatGPT
Assemble and persist one private custom-node draft from a structured plan. Compilation is an explicit later call.

spera_custom_node_patch

ChatGPT
Apply one revision-safe body or shape edit. Body edits require the exact current field hash and never compile implicitly.

spera_custom_node_plan_get

ChatGPT
Return the current structured plan, source revision, source map, and per-field hashes required for safe edits.

spera_documentation_apply

ChatGPT
Revision-safely persist Markdown documentation for one exact artifact. Compile or backtest claims must cite verified receipts embedded in the content.

spera_documentation_get

ChatGPT
Read Markdown documentation for one exact authorized strategy, module, or custom node and return its optimistic-concurrency revision.

spera_edge_check_run

ChatGPT
Release the three deferred robustness reads on a COMPLETED deep-backtest job: whether the strategy beat randomly timed trades that copied its own trade count, side mix and holding periods; whether it still profits on the same candles dealt in a shuffled order; and whether neighbouring values of its numeric settings work too. Deep runs already carry the other five reads (out-of-sample, walk-forward, track record, trade-order, market conditions) — these three are deferred because each re-runs the money model many times over, so they are requested rather than automatic, and a run reports edgeCheck.status 'not_run' until you ask. Spends NO deep-backtest quota: nothing is re-simulated. Returns immediately by default and the verdicts land on the ordinary spera_backtest_get poll — a sweep can outlast any tool timeout, so pass waitSeconds only as a shortcut, never as the mechanism. Read the reports with spera_backtest_results_get(section:'edge'). If it is refused, report what happened: retrying starves other tenants' backtests.

spera_forward_check_get

ChatGPT
Read one forward run by runId (from spera_forward_check_start or spera_forward_check_list): the saved revision it replays (run.freeze), its state, and the newest graded report. Reading never starts a run; a run in flight is settled first. run.state 'running' means the replay has not finished — read it again later; 'failed' means it failed and run.lastError says why. report.verdict 'collecting_evidence' is NOT a grade (report.graded is false): say how many forward days and trades exist against report.gate and when a confident read becomes possible (gate.daysToConfidentRead). Quote report.posterior.estimate with its 80% interval (low80–high80) and probPositive — the evidence-adjusted Sharpe, which shrinks a short forward run toward a deflated backtest prior — never the raw forward Sharpe alone. 'market_not_comparable' means the forward market looked unlike most of the backtest's (report.regime), not that the strategy failed. Each reason carries its text: quote them. report.band compares the forward return and drawdown with what the backtest expected for a window this long (percentile); report.market compares it with simply holding the market and with random entries. Series are sampled (curveSample, band.pointsSample, evidence.pointsTail) to keep the response bounded. Every figure is simulated: carry the disclaimer, use hypothetical phrasing, and never present it as live performance or as a reason to deploy.

spera_forward_check_list

ChatGPT
List the caller's forward runs, most recently used first, optionally filtered by kind and artifactId. One entry per saved version that was run forward; each summary carries the verdict, forward days, trades and return, the benchmark return, when it last ran (ranAtIso), whether that result includes the last daily close (fresh) and whether a run is in flight (running). Listing never starts a run. returnedCapped is how many the service returned (capped), not a full count. Read one in full with spera_forward_check_get. Figures are simulated; carry the disclaimer.

spera_forward_check_start

ChatGPT
Run ONE saved revision of a strategy, portfolio or universe forward NOW: Spera replays that version from the moment it was saved to the last daily close in one continuous run and grades only the market after the save line — data nobody could have tuned on — against the version's own backtest. Use it when a strategy or book has existed for a while and the user asks whether it is still working; it is a SIMULATED replay of the saved version, never deployment monitoring and never the live bot's fills. Nothing is scheduled: each call is one run on demand. It spends one of the plan's forward runs per rolling 24 hours and charges NO deep-backtest quota (costsBacktestQuota: false). Asking again for the same version on the same UTC day returns the cached result and spends nothing, so a retry is safe. Pin the revision with version {branchId, commitId} (omit for the default branch head); a portfolio runs its current snapshot and takes no version. The run's settings and market come from the version itself (its reference backtest or saved settings): there is nothing else to choose. The response is the run: read run.state. 'running' — the replay is in flight; read it back with spera_forward_check_get using run.id. 'ready' — report holds the result (fresh says whether it includes the last daily close). 'opens' — the version was saved less than a day ago; the first result can run at run.opensAtIso. 'limited' — the plan's forward runs for the last 24 hours are spent; report (if any) is older and run.retryAtIso says when a new run can start; do not retry before it. 'failed' — run.lastError says why and run.retryAtIso when it can run again. 'unavailable' — this plan has no forward runs (a guest account); tell the user to sign up. None of these is a refusal. Refusals arrive as a diagnostic code and message: FORWARD_CHECK_REVISION_NOT_FOUND, FORWARD_CHECK_NO_MARKET (the strategy has no market to replay on: backtest it once first), FORWARD_CHECK_FROZEN_TOO_EARLY, FORWARD_CHECK_PORTFOLIO_VERIFIED_UNAVAILABLE. Report the code and stop.

spera_module_create

ChatGPT
Create one stable-ID private module and compile its graph. A clean graph must be followed by one module-port configuration call.

spera_module_patch

ChatGPT
Patch one exact module revision and compile atomically. A clean graph must be followed by module-port configuration.

spera_module_ports_set

ChatGPT
Set the input/output ports of a compile-clean module. The write is checked against expectedRevision and saved as a NEW module revision; earlier revisions, with their ports, stay in the module history and can be read and restored. Outputs must reference existing internal nodes and handles. Success returns the ready-to-copy moduleReference and complete port contract.

spera_node_catalog_get

ChatGPT
List compact node summaries. Fetch exact schemas only for node types selected for an authoring patch.

spera_node_details_get

ChatGPT
Return exact config, input, and output schemas for up to 20 selected node types.

spera_portfolio_backtest_start

ChatGPT
Run every leg of a saved portfolio over one window and aggregate them into ONE result: a combined equity curve, with drawdown, Sharpe, Sortino and Calmar recomputed on that combined curve rather than averaged across legs, plus each leg's own metrics. Symbols, timeframes and per-leg settings come from the portfolio, so this carries only the window, as Unix epoch MILLISECONDS (2024-01-01T00:00:00Z is 1704067200000). Costs one deep-backtest allowance per leg, reserved whole before the run starts (a book larger than the remaining allowance is refused, not partly run), but runs as ONE job — firing spera_backtest_deep_start per leg would instead be rejected by the per-user concurrent-job limit (1 on free, 4 on pro). Poll with spera_backtest_get using kind:'portfolio' and artifactId set to the portfolioId; a portfolio job is NOT reachable at the plain deep-backtest path. Read results with spera_backtest_results_get, also kind:'portfolio' — section 'equity' without positionId gives the COMBINED curve, and section 'trades' REQUIRES a positionId because the legs have no combined trade log.

spera_portfolio_book_fit

ChatGPT
Answer "would adding this make my book better?" from two FINISHED runs: this portfolio's backtest (its last completed run unless bookJobId names another) and a candidate's — a strategy's deep backtest (candidateKind strategy_backtest) or another portfolio's or universe's backtest (portfolio_backtest). Both are joined on the UTC daily closes they share and combined as two sleeves rebalanced to target weights (monthly unless rebalanceFrequency says otherwise). Returns bookFit.report: verdict (improves / mixed / does_not_improve / insufficient_overlap), confidence from a paired Sharpe-difference test, book vs combined Sharpe / annual return / max drawdown / volatility, correlation, the held-out final stretch (weight chosen without it), the book's worst days, a weight sweep, and caveat flags. candidateWeight defaults to the minimum-variance weight, which reads volatility and correlation only, never returns. Starts no job and spends no quota. Run the candidate over the book's window first, or the overlap is too short to judge. A projection, not a joint engine run: to measure it for real, add the leg with spera_portfolio_patch and run spera_portfolio_backtest_start.

spera_portfolio_create

ChatGPT
Save a portfolio: many (strategy x pair) legs that backtest TOGETHER as one book, with one combined equity curve whose drawdown and Sharpe are recomputed on the combined curve rather than averaged. Each leg may trade its own symbol and timeframe. The SAME strategyId may appear on several legs with different strategyVersion.branchId — that is how you hold one strategy's variants as a single book. Give branchId alone and the branch HEAD is pinned to an immutable commit at write time, echoed back on the response. capitalModel.mode 'fixed_weight' splits the pool into per-leg slices (weights must cover the pool unless exactly one leg is left bare to absorb the remainder); 'shared_pool' makes every leg contend for ONE cash balance. A fixed_weight book may also set capitalModel.rebalanceFrequency (weekly|monthly|quarterly|annual) and rebalanceBandPercent: on each date capital really moves between legs back to their weights, so later trades are sized from the new allocation. Each leg copies its strategy's backtest settings when created and owns them from then on (editing the strategy later never changes the book); send a leg's settings to set its costs, margin and sizing yourself. account holds what the wallet owns — currency and position mode, one value for every leg (default USDT, one-way) — and the book's risk rails (account.riskPolicy); a leg's own rails go on the position's riskPolicy, never inside its settings. A portfolio has no backtestSettings field: sending one is refused. NOT the same as spera_backtest_compare_start, which ranks branches against each OTHER over one shared symbol and returns N separate series. Premium: a plan without the portfolios capability is refused.

spera_portfolio_get

ChatGPT
Read a portfolio in full: every leg with its strategy, pinned branch and commit, symbol, timeframe, capital slice, its OWN settings copy (costs, margin, sizing; settingsCopiedFrom says when it was copied, strategySettingsChanged is true when the strategy has moved on since) and its own riskPolicy, plus the account (currency, position mode, and riskPolicy for the whole book), the capital model and the last run summary. Returns revision — pass it straight back as expectedRevision on spera_portfolio_patch, which refuses a stale value instead of overwriting whoever wrote in between.

spera_portfolio_list

ChatGPT
List this account's portfolios. A portfolio holds many (strategy x pair) legs that backtest TOGETHER as one book: one combined equity curve and one set of metrics, while each leg keeps its own. Returns summaries only (name, leg count, capital mode, last run); read one with spera_portfolio_get to get its legs and its revision.

spera_portfolio_patch

ChatGPT
Change a portfolio's name, description, legs, capital model or account. Every field is optional; positions and capitalModel REPLACE what is stored rather than merging, so send the full list you want — a capitalModel without rebalanceFrequency / rebalanceBandPercent clears the rebalancing policy, so copy them from the portfolio you read. A leg sent with its existing positionId and no settings keeps its settings copy; send settings to edit it, or syncSettingsFromStrategy: true to re-copy the strategy's current settings. account and each leg's riskPolicy are also replaced whole: a leg sent without riskPolicy loses its rails, and an account sent without riskPolicy turns the book's rails off, so resend what you read. expectedRevision is REQUIRED: read the portfolio first and pass the revision it returned. A portfolio has two writers — this tool and the owner's builder open in a browser — so a stale revision is refused with a conflict naming the current one, and the right response is to re-read and rebase, never to retry the same body.

spera_project_document_apply

ChatGPT
Create or revision-safely update one exact ordinary Markdown virtual path. STRATEGY.md is rejected and must use the proposal flow.

spera_project_document_get

ChatGPT
Read one exact virtual path or document ID, optionally by bounded line range, and return a revision-pinned citation.

spera_project_manifest_get

ChatGPT
Read the bounded metadata-only manifest first, or search it by query and virtual path prefix without loading Markdown bodies.

spera_sdk_symbol_get

ChatGPT
Return exact signatures, constraints, and examples for up to ten selected custom-node SDK symbols.

spera_strategy_branch_create

ChatGPT
Create one experiment branch only on a caller-owned private strategy returned by create/get, from its exact immutable commit. Never call this on a public/read-only strategy. The operation is project/workflow-bound and idempotent.

spera_strategy_branches_list

ChatGPT
List bounded branch heads for one exact authorized strategy so callers can bind edits and backtests to immutable versions.

spera_strategy_create

ChatGPT
Create one stable-ID private strategy without requiring an existing project, apply a bounded graph patch, compile it, then create its owner-visible Project and return projectId. Retries are idempotent.

spera_strategy_document_accept

ChatGPT
Apply one exact pending proposal only at its expected current revision and persist the accepted history state.

spera_strategy_document_propose

ChatGPT
Create one revision-pinned STRATEGY.md proposal for explicit user review; this does not apply the proposal.

spera_strategy_patch

ChatGPT
Patch one exact strategy revision and compile atomically. Compile repairs stay on the same draft; read-only artifacts fork when explicitly allowed.

spera_strategy_settings_set

ChatGPT
Change the backtest settings (the money model a strategy's runs use: starting balance, fees, slippage, margin/leverage, order sizing, position mode, and the strategy's own risk rails) on one caller-owned strategy. PATCH SEMANTICS: send ONLY the fields you are changing under backtestSettings; every omitted field keeps its current value, and nested groups merge field-by-field — except riskPolicy, which is replaced whole (a policy is judged as a unit; send {} to turn the rails off). Read the current values from spera_artifact_get first. Leverage applies only when marginMode is "leverage" and the margin percents only when it is "margin_percent" — sending just a leverage switches the mode for you and reports it as a derived change, while sending a conflicting mode in the same call is rejected. Set resetToDefaults to restore the shipped defaults. Settings are stored out of band from the versioned graph, so this takes no expectedRevision, creates no commit, and keeps no history: the values it replaces are gone unless set again (the response's changed list shows each field's from and to; a risk policy only as a summary). Once set, spera_backtest_quick_run / spera_backtest_deep_start can omit backtestSettings and inherit them.

spera_study_evaluate

ChatGPT
Run the ONE sealed test of an open research study: re-run the finalist — the study's completed DEEP-backtest trial named by inSampleJobId (quick-run and branch-sweep trials cannot be finalists), with its exact revision, symbol, timeframe and settings — over the sealed window nobody explored, and judge it against its exploration run. SINGLE USE: the seal is spent atomically when this call is accepted, the study stops accepting runs, and the Deflated Sharpe is snapshotted. Call it once, after exploration is finished and you have read the finalist's Deflated Sharpe with spera_study_get(jobId). Costs ONE deep backtest, reserved before it starts and refunded if refused. If it is refused, report the code and stop — never retry: STUDY_SEAL_SPENT (already evaluated), STUDY_SEAL_NOT_MATURED (a forward seal whose window has not passed), STUDY_FINALIST_NOT_A_TRIAL (run the finalist as a deep backtest under the study first), STUDY_FINALIST_NOT_DEEP (the named trial is a quick or sweep run — run it as a deep backtest under the study first), STUDY_FINALIST_NOT_COMPLETED, STUDY_FINALIST_NO_EVIDENCE, STUDY_FINALIST_STALE_ENGINE (a futures finalist measured before funding and bracket maintenance — re-run it as a deep backtest under the study and name that run; the seal is not spent), STUDY_SEAL_VIOLATION (the finalist's own run reached the seal), STUDY_NOT_EXPLORING. Poll the returned job with spera_backtest_get (artifactId and jobId from binding), then read report.sealedEvaluation. Its verdict: 'confirmed' — the sealed window alone shows a Sharpe above zero with ≥95% confidence; 'consistent' — not confirmed, but not significantly worse than exploration; 'did_not_hold' — sealed Sharpe ≤ 0, not significantly worse; 'contradicted' — significantly worse than exploration at 95%; 'insufficient_evidence' — under 30 daily observations or 20 trades. Always report powerAtInSampleSharpe with the verdict: a LOW power means this window was too short to confirm even a real edge of the exploration Sharpe, so it can falsify but mostly cannot confirm — 'consistent' then is not a pass. Report every run listed in integrity.sealTouchingJobs: a run that already saw the sealed window weakens the test.

spera_study_get

ChatGPT
Read research studies. Pass exactly ONE of: studyId (one study), projectId (that project's studies, open and closed), or jobId (the study a backtest belongs to, the run's role there — 'trial' or 'evaluation' — and its Deflated Sharpe; a quick-run or branch-sweep trial is addressed by its sample id from study.observedTrials). Read it with jobId on your finalist BEFORE spera_study_evaluate. selection.deflatedSharpe is the probability the run's Sharpe is real once the whole search is priced in (≥0.95 'survives_search', ≥0.50 'inconclusive', below 'likely_luck'); selection.probabilityBeforeSearch is the same statistic with no search priced in, so the gap between the two is what the search cost. selection.expectedMaxAnnualizedSharpe is the luck bar: the Sharpe the best of trials.effective zero-edge strategies would be expected to show by chance — the finalist must clear THAT, not zero. trials.effective is the number of independent trials the bar used: highly correlated runs collapse toward one, while runs Spera holds no daily sample for count whole. 'not_measurable' carries a reason and no statistics. While the study explores the read is live and moves as trials are added; after evaluation it is the snapshot frozen when the seal was spent. seal.explorationEnd is the latest 'to' any exploration run may use.

spera_study_open

ChatGPT
Open a research study for ONE research question BEFORE you start exploring ideas for it. A study prices the search: every backtest that competes for the question counts as a trial, the finalist's Sharpe is deflated by that count (the Deflated Sharpe), and a sealed window of recent history (or a future one) is held back for a single final test. A study can only count runs it sees: those made through spera_backtest_quick_run, spera_backtest_deep_start, or spera_backtest_compare_start (for variants) after it opens. A run made anywhere else, or before the study opened, is not counted, and the Deflated Sharpe then understates the search — say so when reporting a result. While the study explores, every quick, deep and compare run on the project's strategy is attached automatically, counted, and refused if it reaches past seal.explorationEnd (also explorationEndIso), the LATEST 'to' any exploration run may use. sealMode 'retrospective' (default) seals the most recent sealDays (default 180) of history; 'forward' seals a window that has not happened yet — provably unseen, but it can only be evaluated once the window has passed. One study per project may be open; STUDY_ALREADY_OPEN names it — read it with spera_study_get instead of opening another.

spera_workflow_resume

ChatGPT
Reconstruct authoritative read-only workflow context after a client restart. No MCP session state is required.

Capabilities

InteractiveWrites

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