Skip to main content
Glama
SEToolBox MCP Server

SEToolBox MCP Server

setoolbox-mcp-server

An MCP server for SEToolBox, the systems engineering calculator for macOS and iPadOS. It lets an AI agent run the app's Link Budget, Radar Range, and EO/IR calculators, read the user's projects, and export EO/IR parameter sweep workbooks with their target coverage figures, through the folder the app watches. The app does every calculation and writes every file; this server only writes request files and returns the app's result files unchanged.

Requirements

  • SEToolBox running, with an agent runs folder chosen in Settings and "Allow agent runs" on. On iPad the app must be in the foreground.

  • Node 20 or newer.

  • The folder must be on local disk, not iCloud Drive or another sync folder. The exchange relies on an atomic rename.

Related MCP server: Polymath MegaBlaster MCP

Install and register

No clone, no build: npx fetches and builds the server on first use. Pin a release tag so every machine gets the same code; the default branch is not pinned and npx caches what it fetched.

Warm the cache first, and confirm the version it prints:

npx -y github:slaughters85j/setoolbox-mcp-server#v0.4.0 --version

Claude Code:

claude mcp add --scope user setoolbox -e "SETOOLBOX_AGENT_FOLDER=/path/to/your/agent/folder" -- npx -y github:slaughters85j/setoolbox-mcp-server#v0.4.0

Codex CLI:

codex mcp add setoolbox --env SETOOLBOX_AGENT_FOLDER=/path/to/your/agent/folder -- npx -y github:slaughters85j/setoolbox-mcp-server#v0.4.0

Claude desktop app, in ~/Library/Application Support/Claude/claude_desktop_config.json. Use the absolute path of npx (which npx); the desktop app does not load your shell PATH. Quit the app before editing when you can, since it rewrites the file on quit; if the agent doing this is running inside the desktop app, write the entry anyway and check it after the restart:

"setoolbox": {
  "command": "/opt/homebrew/bin/npx",
  "args": ["-y", "github:slaughters85j/setoolbox-mcp-server#v0.4.0"],
  "env": { "SETOOLBOX_AGENT_FOLDER": "/path/to/your/agent/folder" }
}

Then quit and relaunch the tool. To confirm which build is live, call setoolbox_status and read serverVersion; tool descriptions can be stale in a client's cache, the status payload cannot.

Setting

Source

Default

Folder

SETOOLBOX_AGENT_FOLDER or --folder <path>

required

Result timeout

SETOOLBOX_AGENT_TIMEOUT_S

60

Poll interval

SETOOLBOX_AGENT_POLL_MS

1000

Tools

Tool

Does

setoolbox_list_tools

The three calculation tools and their schema versions

setoolbox_get_schema

schema/<tool>.json verbatim: the blank input form

setoolbox_run

Write a request, wait for the result, return it verbatim

setoolbox_get_result

Fetch a result by runId, after a timeout or from another session

setoolbox_list_runs

Recent results, newest first

setoolbox_status

Folder present, schema versions, queue depth, last result age

setoolbox_list_projects

Every project with per-family record counts (read only)

setoolbox_read_project

One project: summary rows, or the full export JSON (read only)

setoolbox_export

EO/IR parameter sweep workbooks for a project's analyses, and optionally target coverage figures (SVG, PNG) from the same snapshot, written by the app under out/exports/<runId>/ (store unchanged)

The folder protocol

<folder>/
  in/      requests, written as <runId>.json.tmp then renamed to <runId>.json
  out/     results, <runId>.json; or <request file name>.error.json when the runId could not be trusted
           exports/<runId>/ holds the workbooks a sweep export wrote, and its figures in a subfolder per analysis; it is pruned with its result
  done/    archived requests
  schema/  link_budget.json, radar_range.json, eoir.json
  • runId: 1 to 64 characters of [A-Za-z0-9._-], no leading dot, equal to the file name without .json, never reused. The app never overwrites a result.

  • A calculation request carries tool, inputSchemaVersion (1), inputs (every physical quantity as {"value": n, "unit": "..."}), optional save (projectName, analysisName), and optional displayUnits.

  • A read request carries operation (project.list or project.read) instead of tool and inputs.

  • A sweep export carries operation eoir.sweepExport, one of projectId or projectName, optional analysisIds, heights and ranges (each {"unit", "values": [...]} or {"unit", "start", "stop", "step"}), metrics, target when a target metric is listed or figures are requested, and optional figures (points as [{"height", "range"}] on the request's axes and in their units, formats svg/png, display targetFit/detectorDetail, and asset, the target illustration). The axes are required; the app never substitutes remembered sweep settings or figure choices. Figures are drawn from the same snapshot as the workbook, so their numbers equal its cells. The result's data lists written workbooks, each with its figures and figuresSkipped when figures were asked for, and skipped analyses with reasons; assurance.level is exported.

  • Results carry, in order: status (ok, undetermined, error), answer, assurance, result, warnings, run, then data for reads, agentInstruction for undetermined answers, or the error fields. run holds runId, toolVersion, inputSchemaVersion, timestamp, analysisId, persisted, sessionId, and on calculation results tool.

  • undetermined is a normal outcome. Report the quantity as not determined and ask for answer.missingInputs.

The server writes only in/<runId>.json.tmp and the rename. It never touches out/, done/, or schema/, never deletes, and never resends under a used runId.

Using the folder without this server

Any agent, script, or person with write access to the folder can drive the app with plain files. The server is only a convenience over this exchange, and the app treats both the same. Ask the SEToolBox user for the folder path; it is shown in the app's Settings under Agent Runs, with a copy button.

  1. Read the blank form first. schema/<tool>.json (link_budget, radar_range, eoir) lists every field with its unit and whether it is required. Use only those field names and units.

  2. Write the request as in/<runId>.json.tmp, then rename it to in/<runId>.json. The rename is the handoff; the app ignores .tmp files. Pick a fresh runId every time, for example a timestamp plus a short random suffix.

  3. Poll out/<runId>.json. It appears within a second or two when the app is running and allowed. If it never appears, the app is not running, the folder is not chosen in Settings, or "Allow agent runs" is off. Do not resend under the same runId; write a new request.

  4. Read the result file as is. status says ok, undetermined, or error. undetermined means the app could not determine the quantity from what you sent; answer.missingInputs names what it needs. error carries correction, which says what to fix.

  5. Never do the math yourself. The app is the calculator; the point of the exchange is that every number is the app's, reproducible by runId, saved in the user's project when save is given.

A calculation request:

{
  "runId": "2026-09-13T21-02-11-a7f3",
  "tool": "link_budget",
  "inputSchemaVersion": 1,
  "save": { "projectName": "X-band Study", "analysisName": "Agent run 3" },
  "inputs": {
    "transmitPower": { "value": 25, "unit": "W" },
    "frequency": { "value": 8.4, "unit": "GHz" },
    "distance": { "value": 500, "unit": "km" }
  }
}

A read request; project.read takes exactly one of projectId or projectName, and detail is summary (default) or full:

{ "runId": "2026-09-13T21-03-40-b1c2", "operation": "project.read", "projectName": "X-band Study", "detail": "summary" }

{ "runId": "...", "operation": "project.list" } lists every project with record counts. Reads save nothing and change nothing. The result's data holds the projects or the project; a full read returns the app's own export JSON.

Skill

skill/setoolbox-agent-runs/SKILL.md teaches an agent when and how to use these tools, including a project review procedure. Copy or link it into your agent's skills folder.

Development

npm install
npm test

Eighteen tests run against a temporary folder with a fake responder standing in for the app. Two live tests run only when SETOOLBOX_AGENT_FOLDER is set and the app is running.

Available Tools

8 tools
setoolbox_get_resultGet a result by runIdA
Read-onlyIdempotent

Return the result file for a runId, verbatim, if one exists in out/. Use it after a setoolbox_run timeout, or for a run submitted by another session. Returns { "found": false, "queued": boolean } when no result has appeared; queued true means the request is still waiting in in/ for the app.

Inputs: runId (required).

setoolbox_get_schemaGet a tool's input schemaA
Read-onlyIdempotent

Return schema/.json verbatim: the blank input form for one tool. Read it before every setoolbox_run and use only the field names and units it lists.

Each entry in "fields" has name, label, symbol, kind (quantity | enum | integer | boolean | text | option), allowed (units for a quantity, values for an enum or option), required, requiredWhen, and when sourced min, max, exclusiveMin, exclusiveMax, rangeSource. "echo" lists the derived symbols every result reports. "notes" are the app's own rules for that tool; follow them.

Never cache this across app launches; the app rewrites the file when its schema version changes.

Inputs: tool (required).

setoolbox_list_projectsList SEToolBox projectsA
Read-onlyIdempotent

List every project in the user's SEToolBox store: id, name, dateCreated, lastModified, and counts of records per tool family (tpmDataList, statisticalTools, massBudgetProjects, budgetTools, spacePowerBudgetProjects, nonSpacePowerBudgetProjects, linkBudgetAnalyses, radarRangeAnalyses, eoirAnalyses).

Goes through the same folder exchange as a run, so the app must be running with agent runs allowed. Returns the result file verbatim; the payload is under "data.projects". Nothing in the app changes.

Inputs: timeoutSeconds.

setoolbox_list_runsList recent runsA
Read-onlyIdempotent

List recent results in out/, newest first: runId, file name, tool, status, timestamp, analysisId (when the app saved an analysis), and the error code for error results. Default limit 20, maximum 200. Read-only audit view.

Inputs: limit.

setoolbox_list_toolsList SEToolBox calculation toolsA
Read-onlyIdempotent

List the three SEToolBox calculation tools an agent can run through the folder exchange, with one-line descriptions and the input schema version each one currently publishes.

Returns: { "tools": [{ "name", "description", "inputSchemaVersion" | null }] }. A null version means the app has not written that schema file yet (the app must be running with agent runs allowed).

Inputs: no named parameters.

setoolbox_read_projectRead one SEToolBox projectA
Read-onlyIdempotent

Read one project from the user's SEToolBox store, by projectId or by exact projectName (never both). Use it to review a study, cross-check values between tools, or find an analysis id.

detail "summary" (default): the project header plus "records", one row per record with family, id, name, and for Link Budget, Radar Range, and EO/IR analyses also lastModified and isAgentRun. detail "full": the project's complete export JSON, the same bytes the app's Export command writes, with every stored input and result of every record. Large; ask for it when you need values.

Family names in the summary are the keys of the full form, so a summary row can be found again in the full read. Returns the result file verbatim; the payload is under "data". Nothing in the app changes. A wrong name yields status "error" with project_not_found; a name shared by two projects yields ambiguous_project, so select by projectId from setoolbox_list_projects.

Inputs: detail, projectId, projectName, timeoutSeconds.

setoolbox_runRun a SEToolBox calculationA

Submit one calculation request to SEToolBox and wait for its result. The app does the math; this tool only writes the request file and reads the result file back verbatim.

Args:

  • tool: link_budget | radar_range | eoir

  • inputs: object keyed by schema field name. Every physical quantity is { "value": number, "unit": "<one of the field's allowed units>" }. Enum, option, and text fields are strings; integer and boolean fields are plain. Bare numbers for quantities are rejected by the app. Unknown field names are rejected. Omit what the user did not give you; the app never fills a required field from a default.

  • save (optional): { "projectName", "analysisName" }. Present means the app creates one new marked analysis in that project (created if absent). Absent means compute only.

  • displayUnits (optional): { "": "" } to choose the unit used for "value" in the result; "siValue" is always SI.

  • runId (optional): supplied by you, or generated as -<4 hex>. Must be new; the app never overwrites a result.

  • timeoutSeconds (optional): how long to wait for the result. Default from SETOOLBOX_AGENT_TIMEOUT_S (60).

Returns the result file as JSON, unchanged. Top-level keys in order: status, answer, assurance, result, warnings, run, then agentInstruction or the error fields.

  • status "ok": answer.value/unit in display units, answer.siValue/siUnit in SI; result[] echoes every derived quantity and every supplied input (state entered or pinned). Compare runs on siValue.

  • status "undetermined": answer.value is null, answer.missingInputs names what to supply, and agentInstruction says to report the quantity as not determined. This is a normal outcome, not an error.

  • status "error": error code plus field, received, allowed (when a finite set exists), and nextAction. Fix the request and resubmit with a new runId.

  • assurance is never empty. link_budget and radar_range: level "computed", citations false. eoir: level "traced", with citation and determinacy on each quantity.

A tool error (isError) means the exchange itself failed: folder missing, bad or duplicate runId, or timeout. On timeout the request stays queued; the app processes it when it is running and in front, and setoolbox_get_result returns it later. Never resubmit under the same runId.

Inputs: tool (required), inputs (required), save, runId, +2 more.

setoolbox_statusCheck the exchange folderA
Read-onlyIdempotent

Report whether the agent folder exists and is prepared, the schema version of each tool, how many requests wait in in/ (queueDepth), and the age in seconds of the newest result. Use it to tell the user "SEToolBox is not running" when runs time out: a queueDepth above zero for longer than a few seconds means the app is closed, agent runs are off, or the iPad app is not in the foreground. Never throws for a missing folder; read folderPresent.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: listing calculation tools, fetching a schema, running a calculation, listing/reading projects, retrieving one result, auditing recent runs, and checking exchange status. Overlaps such as get_result vs. list_runs are separated by runId-specific vs. audit/list semantics. No two tools appear to do the same thing.

    Naming Consistency4/5

    All names use the setoolbox_ prefix and snake_case, which is consistent and predictable. The set is mostly verb_noun (list_tools, get_schema, list_projects, read_project, get_result, list_runs), with minor deviations in run and status.

    Tool Count5/5

    Eight tools is well-scoped for a folder-exchange agent interface covering discovery, execution, retrieval, audit, project browsing, and health. Each tool earns its place, and there is no evident bloat or severe under-provisioning.

    Completeness4/5

    The surface covers the core agent workflow: discover tools, read schemas, run calculations, retrieve results, audit runs, browse projects, and check status. Minor gaps exist, such as no explicit project/analysis write, delete, or queued-run cancellation operations, but these are not dead ends for normal agent use.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to perform unit-aware engineering calculations with automatic unit conversion, dependency resolution, and access to 500+ units across 75+ categories through the CalcsLive calculation engine.
      3
      21 npm
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Enables AI agents to perform accurate local computations including arbitrary-precision math, date handling, unit conversion, subnet calculations, encoding, hashing, and text analysis, all without network calls or API keys.
      27
      103 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables language models and users to perform exact arithmetic, symbolic math, unit/date conversions, statistics, and read-only SQL queries over registered files, with every operation logged by a citable ID that humans can re-run.
      11
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables ChatGPT to inspect and manage approved local project folders, read files, propose edits, patches, and deletions, run shell commands subject to approval, and track jobs and tasks through MCP. It provides controlled access to local project files and execution results on macOS.
      MIT