MCP connector

Every tool, and what it does

All 31 Spera MCP tools grouped by what you would ask for, with the permission each one needs and whether it writes anything.

Updated 2026-08-26·Rev. 2026.06

Your assistant has 31 tools, 15 of which only read. You never call these yourself — you ask for an outcome and the assistant picks. This page exists so you can see exactly what it is able to do, and what each capability costs you in permissions.

Nothing here trades

There is no tool for deploying a bot, reading an exchange key, or moving money. That is not a setting — those tools do not exist on this server, so no phrasing reaches them.

Orientation and discovery

What your assistant calls first: who you are, what you already have, and what the node and SDK vocabulary is. Every one of these is read-only.

Tool	What it does	Permission	Writes
Get Spera context `spera_context_get`	Returns who you are, which projects you can reach, the contract version, and the limits in force. This is the first call in almost every workflow.	`spera:context:read`	No
Search artifacts `spera_artifacts_search`	Finds your strategies, modules, and custom nodes by name or content, paged.	`spera:artifact:read`	No
Get one artifact `spera_artifact_get`	Reads a single artifact at an exact revision, including its graph and dependencies.	`spera:artifact:read`	No
Resume a workflow `spera_workflow_resume`	Picks a durable workflow back up where it stopped — the reason a long build survives a client restart or a new chat.	`spera:context:read`	No
Get the node catalog `spera_node_catalog_get`	A compact list of every node type available to build with — the assistant's vocabulary before it writes a graph.	`spera:artifact:read`	No
Get exact node schemas `spera_node_details_get`	The full schema for specific nodes: inputs, outputs, parameters, and defaults. Prevents invented config keys.	`spera:artifact:read`	No
List experiment branches `spera_strategy_branches_list`	Lists the experiment branches on a strategy, so a variant can be compared instead of overwriting the original.	`spera:artifact:read`	No
Search the custom-node SDK `spera_sdk_symbols_search`	Finds SDK symbols by name when writing a custom node, rather than guessing at an API.	`spera:artifact:read`	No
Get exact SDK symbols `spera_sdk_symbol_get`	Reads the exact signature and semantics of named SDK symbols.	`spera:artifact:read`	No

Strategies

Create, edit, and branch strategy graphs. Every write compiles, so a tool call that succeeds means the graph is valid — not merely saved.

Tool	What it does	Permission	Writes
Create a strategy `spera_strategy_create`	Creates a strategy graph and compiles it. Needs no existing project — one is created for you if you have none.	`spera:artifact:write`	Yes
Edit a strategy `spera_strategy_patch`	Applies a revision-checked edit and recompiles. If the strategy moved since it was read, the write is rejected rather than clobbering your change.	`spera:artifact:write`	Yes
Branch a strategy `spera_strategy_branch_create`	Forks an experiment branch so a variant can be tried without touching the original.	`spera:artifact:write`	Yes

Modules

Reusable sub-graphs. Ports are set only after a clean compile, so a module's input/output contract can never describe a graph that does not build.

Tool	What it does	Permission	Writes
Create a module `spera_module_create`	Creates a reusable sub-graph and compiles it.	`spera:artifact:write`	Yes
Edit a module `spera_module_patch`	Applies a revision-checked edit to a module and recompiles.	`spera:artifact:write`	Yes
Set module ports `spera_module_ports_set`	Declares the module's input/output contract. Only accepted after a clean compile.	`spera:artifact:write`	Yes

Custom nodes

Structured custom nodes, edited through canonical plans and hashes rather than free-text patches, then compiled explicitly.

Tool	What it does	Permission	Writes
Create a custom node `spera_custom_node_create`	Creates a structured custom node from a canonical source.	`spera:artifact:write`	Yes
Get an edit plan `spera_custom_node_plan_get`	Returns the canonical plan and field hashes for an edit, so a patch targets exactly what was read.	`spera:artifact:write`	No
Edit a custom node `spera_custom_node_patch`	Applies a hash-checked edit to a custom node.	`spera:artifact:write`	Yes
Compile a custom node `spera_custom_node_compile`	Compiles explicitly and returns diagnostics. Compilation is never implied by a save.	`spera:artifact:write`	Yes

Backtests

Quick runs return inline; deep runs are durable jobs you poll, read in pages, and can cancel. Both bind to an exact revision, so a result always names the code that produced it.

Tool	What it does	Permission	Writes
Run a quick backtest `spera_backtest_quick_run`	Runs a bounded backtest against an exact revision and returns the result inline.	`spera:backtest:run`	Yes
Start a deep backtest `spera_backtest_deep_start`	Starts a durable job for a longer run. Returns a job id to poll rather than blocking.	`spera:backtest:run`	Yes
Check a backtest job `spera_backtest_get`	Reads a durable job's status and progress.	`spera:backtest:read`	No
Read backtest results `spera_backtest_results_get`	Reads trades, equity, and metrics in pages — the evidence behind any claim about performance.	`spera:backtest:read`	No
Cancel a backtest `spera_backtest_cancel`	Stops a running deep backtest.	`spera:backtest:cancel`	Yes

Project knowledge

Project-scoped Markdown your assistant can cite. STRATEGY.md is protected: it takes a proposal and an explicit acceptance, never a direct write.

Tool	What it does	Permission	Writes
List project knowledge `spera_project_manifest_get`	Lists or searches the Markdown documents in a project.	`spera:knowledge:read`	No
Read a project document `spera_project_document_get`	Reads one document at an exact revision, so a quotation can be cited rather than paraphrased.	`spera:knowledge:read`	No
Write a project document `spera_project_document_apply`	Creates or revises an ordinary project document. Does not apply to `STRATEGY.md`.	`spera:knowledge:write`	Yes
Propose a STRATEGY.md change `spera_strategy_document_propose`	Opens a proposal against the protected `STRATEGY.md`. Nothing is written yet.	`spera:knowledge:write`	Yes
Accept a STRATEGY.md proposal `spera_strategy_document_accept`	Applies a proposal after you explicitly accept it. This is the only path that writes `STRATEGY.md`.	`spera:knowledge:write`	Yes

Artifact documentation

The docs attached to one strategy, module, or custom node — written against an exact revision and grounded in real compile or backtest receipts.

Tool	What it does	Permission	Writes
Read artifact documentation `spera_documentation_get`	Reads the documentation attached to an artifact at an exact revision.	`spera:documentation:read`	No
Write artifact documentation `spera_documentation_apply`	Writes documentation for an artifact, revision-checked and grounded in real receipts.	`spera:documentation:write`	Yes

How to read the permission column

Each tool names the single permission it needs. A read-only connection holds only spera:context:read and spera:artifact:read, so every tool needing anything else is simply absent from that session — not present and refusing. What you're approving walks through the full list.

If a tool you expected is missing, that is a permissions answer, not a bug: When it doesn't connect.