MCP server — use Creopus tools from Claude, Cursor and other AI clients

Creopus ships a Model Context Protocol (MCP) server, so an AI client — Claude Desktop, Claude Code, Cursor, or anything else that speaks MCP — can read and create Creopus artifacts directly. Your assistant can pull the requirements for a subsystem, draft a DFMEA against them, and write the result back into your hierarchy, without you leaving the conversation.

The tool list is generated from the platform's own capability manifest, so it never drifts from what the product actually does.

Which plan

Transport	Who it's for	Plan	Status
Streamable HTTP (https://mcp.creopus.ai/mcp)	Shared or remote access, multiple clients, nothing to install	Professional, Team and Enterprise	Available
stdio (npx -y @creopus/mcp-server)	One person, running locally alongside a desktop AI client	Any plan	Available — needs Node.js 22 or later

Which one to use

Streamable HTTP needs nothing installed, so start there if your plan includes it.

Use stdio on any other plan, or if you want the server to run on your own machine. It is the npm package @creopus/mcp-server, which your client starts with npx, and it needs Node.js 22 or later. Both offer the same tools.

Before you start: get an API key

Create one in the app under Account Settings → API Keys (your account page). Two things to decide at creation time, because they are much easier to set now than to retrofit:

• Scopes — read, write, or both. If your assistant only needs to look things up, issue a read-only key. This is the single most effective control available to you.
• Allowed tools — an optional per-key whitelist. An empty list means every tool; naming tools restricts the key to exactly those. A key scoped to get_requirements, list_requirements can do nothing else, even if a prompt tries to make it.

Also set an expiry. A key with no expiry is a credential you will still be carrying in two years.

Keys look like creo_live_…. You see the full value once, at creation. We store only a hash, so we cannot recover it for you — if you lose it, revoke and reissue.

Setting up: never paste the key into a config file

This is the part worth getting right.

In 2026, researchers found 24,008 secrets exposed in MCP configuration files on public GitHub, roughly 2,100 of them still valid. Almost none of that was a protocol weakness. It happened because about half of all MCP setup guides tell you to paste your API key straight into mcp.json — and configuration files end up in project directories, and project directories end up committed.

So: put the key in your environment, and reference it from the config.

Step 1: put the key in an environment variable

# macOS — read from Keychain rather than a dotfile
export CREOPUS_API_KEY="$(security find-generic-password -a creopus -s api-key -w)"

# Linux / WSL — a file outside any repo, mode 600
export CREOPUS_API_KEY="$(cat ~/.config/creopus/api-key)"

On Windows, store it as a user environment variable. Type the key at the prompt rather than on the command line, so it never lands in PowerShell's history. Run the three lines in the same PowerShell window:

$k = Read-Host "Creopus API key"
[Environment]::SetEnvironmentVariable('CREOPUS_API_KEY', $k, 'User')
Remove-Variable k

Then close the terminal app completely and reopen it, and do the same for VS Code if you use its extension. Windows only hands a new variable to programs started after it was set; a new tab in an already-open window does not get it.

Step 2: connect your client

Claude Code (macOS, Linux, Windows)

One command adds the server for all your projects. Keep the single quotes: they stop your shell from expanding the variable, so only its name is stored and Claude Code reads the value each time it connects.

claude mcp add --transport http --scope user creopus https://mcp.creopus.ai/mcp --header 'Authorization: Bearer ${CREOPUS_API_KEY}'

Check it with claude mcp list: you should see creopus: https://mcp.creopus.ai/mcp (HTTP) - ✓ Connected. Inside a session, /mcp lists the creopus_* tools.

To share the setup with a project team instead, commit a .mcp.json at the project root. It contains no secret, only the variable's name:

{
  "mcpServers": {
    "creopus": {
      "type": "http",
      "url": "https://mcp.creopus.ai/mcp",
      "headers": { "Authorization": "Bearer ${CREOPUS_API_KEY}" }
    }
  }
}

Two details matter in that file. "type": "http" is required: an entry with a url and no type is skipped with a warning. And Claude Code's syntax is ${CREOPUS_API_KEY}; the ${env:…} form below is Cursor's and is not expanded by Claude Code.

New to Claude Code on Windows?

Install it from PowerShell with irm https://claude.ai/install.ps1 | iex (no administrator rights needed), then open a new terminal window and run claude --version. If the window says claude is not recognised, the install folder is not on your PATH yet. Add it once, then restart the terminal app:

$bin = "$env:USERPROFILE\.local\bin"
$p = [Environment]::GetEnvironmentVariable('Path', 'User')
if (($p -split ';') -notcontains $bin) { [Environment]::SetEnvironmentVariable('Path', "$p;$bin", 'User') }

Claude Code itself needs a paid Claude plan (Pro, Max, Team, Enterprise) or a Console account. The Creopus connection above needs nothing else installed: no Node.js, no npm.

Cursor

// Cursor — Streamable HTTP. Nothing to install.
{
  "mcpServers": {
    "creopus": {
      "url": "https://mcp.creopus.ai/mcp",
      "headers": {
        // Reference the variable. Do NOT paste the key here.
        "Authorization": "Bearer ${env:CREOPUS_API_KEY}"
      }
    }
  }
}

Local stdio, on any plan

The stdio server is the npm package @creopus/mcp-server. Your client starts it with npx, and it runs on your own machine.

It needs Node.js 22 or later. Check with node --version, and if yours is older, install a current LTS release from nodejs.org. On an older Node.js the server stops with a message that says so.

In Claude Code, for all your projects:

claude mcp add --env 'CREOPUS_API_KEY=${CREOPUS_API_KEY}' --transport stdio --scope user creopus -- npx -y @creopus/mcp-server

Keep the single quotes here too, so only the variable's name is stored. Keep --transport stdio between --env and the name creopus as well: written straight after --env, the name would be read as another variable and rejected.

Or, in a project's .mcp.json:

{
  "mcpServers": {
    "creopus": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@creopus/mcp-server"],
      "env": { "CREOPUS_API_KEY": "${CREOPUS_API_KEY}" }
    }
  }
}

In Cursor:

// Cursor — stdio. Needs Node.js 22 or later.
{
  "mcpServers": {
    "creopus": {
      "command": "npx",
      "args": ["-y", "@creopus/mcp-server"],
      "env": {
        // Reference the variable. Do NOT paste the key here.
        "CREOPUS_API_KEY": "${env:CREOPUS_API_KEY}"
      }
    }
  }
}

The first start downloads the package and its dependencies, which takes a few seconds. The package ships a lockfile, so you get exactly the dependency versions it was tested with.

Do not commit your key

Add mcp.json, .mcp.json and .env to .gitignore before you create them. If a key does reach a commit, revoke it in the app first and rewrite history second — revocation is what actually stops the bleeding; history rewriting only removes the evidence.

Do not paste your key into a bug report

The advice above is about config files. The other way keys escape is while you are asking for help: echo $CREOPUS_API_KEY in a terminal transcript, a screenshot of your environment, or a support thread pasted “exactly as it ran”. It looks harmless because you are describing a problem rather than publishing anything — and it puts the full credential in a place that keeps edit history, so deleting it afterwards does not take it back.

When you report something, redact the value: creo_live_<redacted>. If you need to show that the variable is set, show its length or its first few characters, never the whole string — echo ${#CREOPUS_API_KEY} answers the same question.

If one has already gone out, revoke it in the app first. Editing the report is tidying, not remediation.

Remote (Streamable HTTP)

For the hosted endpoint, authenticate with a bearer token instead of a local process:

POST https://mcp.creopus.ai/mcp
Authorization: Bearer creo_live_…

The endpoint is stateless and multi-tenant: your key identifies you, and every request is authorised against your own permissions. It grants exactly what your account can already reach — never more. The same scopes and allowedTools whitelist apply, so a read-only key stays read-only over HTTP.

What you can do with it

Read, create and update the shared artifact tools — requirements, DFMEA and PFMEA, DVP, Pugh, RCCA, BOM, block diagrams, flowcharts, ConOps, ICD, Risk Register, SEMP, CAPA, Control Plan and more — plus navigate the system hierarchy and pull traceability views such as the VCRM and validation matrix. Beyond the artifacts themselves:

Area	What your assistant can do
System hierarchy	Add, move and delete nodes; put an existing artifact on a node; rename a node or set which product variants it belongs to
Engineering calculators	List the calculators, run one on trial inputs, save a calculation on a node and link it to the requirement it checks, recompute it; draft a new calculator with AI, edit your own draft's inputs, formulas and checks (every formula and check must compute on the example inputs, or nothing is saved), and submit it for curation
Parts Finder	Search DigiKey for voltage-divider resistor pairs ranked as the Parts Finder page ranks them, and save a Parts Choice from that search, or one part by its exact part number; the parts saved are always DigiKey's own data
Version history	List an artifact's revisions, see what changed between two, restore an earlier one
Follow-ons and working copies	Ask for an AI change as a follow-on, or make a working copy and add, change or delete items in it without AI; see what a follow-on would change and whether it conflicts with the main document, then merge it when you say so
Reviews	Read a review and its comments, comment, answer comments, assign reviewers, submit for review, on every artifact but a CAPA (its own lifecycle is its workflow)
Document Info	Rename any artifact and set its controlled-document header (document number, version, issuer, recipient), which its exports print
Checklists	Create one from a stage-gate template, answer items, comment, re-run the automated checks
Procurement	Create a workspace, search distributors, add and discuss candidates, compare them, record the decision
Program	Technical performance measures and their measurements, gate reviews and their action items, configuration baselines and drift, the PPAP package
Team and standards	List a node's team, change a role, remove someone; read and set your design standard (IPC class, layout floors); track external blockers
Files and export	Upload a datasheet or spec, attach it to a node or use it to ground a generation; download an artifact as JSON or CSV, or its stamped PDF (the controlled copy its page prints, with approvals and revision history) through a link that works for 15 minutes
Starting points	Clone a system, start from a product template, search and fork public systems on Discover, propose a fork's changes back
Reference data	Search the standards library and the resistor and X7R capacitor libraries

Mutating tools require a write-scoped key and pass the same usage limits and permission checks as the app. There is no back door: an API key cannot do anything your account cannot.

Some actions are deliberately not available to an assistant, because they are a person's decision or signature: approving or rejecting a review, signing off a checklist or a gate, the PPAP warrant (PSW), accepting someone else's proposal, and emailing a supplier. Do those in the app.

Replies are compact: tools return what the assistant needs to act (ids, titles, counts, the items that changed), never whole documents with their version history. To read an artifact's full content, ask for it with the matching get_ tool.

If something does not work

• 403 on the remote endpoint — your plan does not include remote MCP (Professional, Team and Enterprise), or the key's allowedTools list excludes the tool being called. The local stdio package works on every plan.
• creopus-mcp needs Node.js 22 or later (stdio) — update Node.js from nodejs.org, then restart your client.
• CREOPUS_API_KEY environment variable is not set (stdio) — your client started the server without the variable. Set it as in Step 1, then close the client completely and reopen it.
• 401 — the key is revoked, expired, or malformed. Check Account Settings → API Keys; each key shows when it was last used.
• Tool missing from the list — the manifest is filtered by your key's scopes. A read-only key will not be offered create/update tools at all. A client also reads the list when it connects, so tools added to Creopus since then appear after you restart it.
• Claude Code: has a "url" but no "type" — add "type": "http" to the entry in .mcp.json.
• 401 right after setting the variable — the terminal (or VS Code) was already open. Close the app completely and reopen it, then check with claude mcp list.
• Windows: claude is not recognised — see the PATH fix under New to Claude Code on Windows? above.