MCP integration

Connect AI tools to local Canvas, Blueprint, and Mermaid workflows with explicit approval for every write.

What MCP can do

Continuum includes a local Model Context Protocol server for documents, Canvas, Blueprint, and Mermaid work. A compatible AI tool can inspect saved work, validate a declarative document recipe, retrieve built-in examples, and prepare a proposed change.

The important split is read now, stage writes. Listing, reading, schemas, guides, and validation return immediately. Creating or changing a Canvas never does: the MCP server stages a temporary proposal and the running Continuum app asks you to review it.

Connect an MCP host

The integration is available in the packaged macOS and Windows apps. Keep Continuum open so its local bridge is available, then add this server to your MCP host configuration. This example assumes Continuum is installed in /Applications:

{
  "mcpServers": {
    "continuum": {
      "command": "/Applications/Continuum.app/Contents/MacOS/Continuum",
      "args": [
        "/Applications/Continuum.app/Contents/Resources/app.asar/dist-mcp/mcp/server.js"
      ],
      "env": {
        "ELECTRON_RUN_AS_NODE": "1"
      }
    }
  }
}

Adjust both paths if the app lives elsewhere. Restart or reconnect your MCP host after changing its configuration. The server finds the short-lived local capability created by the running Continuum app; you do not copy an API key or create an account.

For the default per-user Windows installation, replace YOUR_NAME in this equivalent configuration:

{
  "mcpServers": {
    "continuum": {
      "command": "C:\\Users\\YOUR_NAME\\AppData\\Local\\Programs\\Continuum\\Continuum.exe",
      "args": [
        "C:\\Users\\YOUR_NAME\\AppData\\Local\\Programs\\Continuum\\resources\\app.asar\\dist-mcp\\mcp\\server.js"
      ],
      "env": {
        "ELECTRON_RUN_AS_NODE": "1"
      }
    }
  }
}

For a source checkout, run npm run mcp:build and configure your host to execute node /absolute/path/to/Continuum/dist-mcp/mcp/server.js.

Tool reference

Blueprint contract

get_blueprint_schema — the normalized Blueprint schema and a YAML example.
validate_blueprint — local Blueprint YAML or JSON validation.
stage_blueprint — a reviewed new, merge, or replace proposal.
stage_canvas_layout — a reviewed Canvas proposal that moves existing items in place and can add structural lines, labels, frames, or local image assets.
stage_canvas_image — stages a single local PNG, JPEG, WebP, or GIF image from a data URL for in-app review.
get_blueprint_proposal_status — pending, approved, rejected, or expired status.

Document Composer

get_document_recipe_schema — the versioned Document Recipe schema and example.
validate_document_recipe — calculations, block limits, bindings, interpolation tokens, and rendered-preview validation without mutation.
list_documents — local document identifiers, titles, revisions, and custom-composition ownership.
get_document_recipe — canonical source plus the current editable recipe, when present.
stage_document_recipe — a reviewed new, append, or replace proposal. Append preserves existing calculations and replaces the complete custom composition; replace rewrites both with a stronger warning.
get_document_proposal_status — pending, approved, rejected, expired, or stale status.

Recipes use the same metric, comparison, timeline, resilience, readiness, summary, and conclusion components as built-in templates. Values are literals or bindings to named Continuum calculation symbols. Narrative text supports bounded tokens such as {{runway_months|number}}; it does not execute JavaScript or another expression language. A document may own one custom composition and cannot combine it with template: or scenario preview ownership.

Canvas workspace

list_canvases — titles and identifiers for local canvases.
get_canvas_blueprint — one Canvas as canonical Blueprint YAML.

Mermaid graphs

get_mermaid_guide — logical-model templates and Continuum’s architecture sample.
validate_mermaid — local Mermaid parsing without a workspace change.
list_mermaid_graphs — persistent Mermaid graph nodes across canvases.
get_mermaid_graph — one graph’s canonical Mermaid source.
stage_mermaid_graph — a proposed Mermaid node for a new or existing Canvas.

Safe staging and approval

stage_blueprint, stage_mermaid_graph, stage_canvas_layout, stage_canvas_image, and stage_document_recipe create memory-only proposals. A proposal identifies its MCP client, requested mode, source diff, validation result, and live result inside Continuum. Document proposals record a target revision and refuse approval if the source changed after staging; approval is one editor-history update. Layout proposals preserve the IDs, content, and relationships of existing items; they only move them and can add structure or a local image. Image inputs are base64 data URLs for PNG, JPEG, WebP, or GIF files up to 10 MiB; Continuum does not fetch remote URLs and stores the image locally only after approval. Every proposal expires after 30 minutes and changes the workspace only after an explicit Approve action. Rejecting it or closing the app leaves documents untouched.

The local capability descriptor and Unix socket or Windows named pipe stay inside the current user's application context and use a short-lived capability token. This protects the handoff between the MCP process and the running app; it is workflow integrity, not a replacement for operating-system account security.

Architecture graph workflow

The built-in Continuum architecture sample demonstrates the full path:

Call get_mermaid_guide to retrieve the canonical architecture source.
Use validate_mermaid while refining the logical model.
Call stage_mermaid_graph with applyMode: "new" or applyMode: "merge".
Review the rendered graph and requested destination in Continuum.
Approve it to add a persistent Mermaid node, or reject it without changing the Canvas.

The same diagram is included in the source repository as examples/continuum-architecture.mmd. It maps the browser and desktop surfaces, local workspace, Graph Explorer, Blueprint provider boundary, MCP bridge, and approval step.

Boundaries

There is no remote MCP endpoint, hosted relay, OAuth flow, or Continuum account.
The MCP server does not call an AI provider. Blueprint’s optional provider is configured separately in the app.
Composed documents render in browser and desktop builds. Local workspace MCP access belongs only to a running Continuum desktop app.
Continuum’s MCP server is provider-free. The connected MCP client authors a recipe; Continuum validates, previews, and stages it.
Read tools can expose the Canvas or Mermaid source you explicitly ask the MCP client to retrieve. Review your host and model provider’s privacy behavior before sharing sensitive models.
Approval protects workspace mutations. It does not authenticate every process already running as your operating-system user.