MCP MeasureMCP Measure

index observed

Nimbus BCI

AI agents build, train, and analyze BCI/EEG pipelines: data, models, experiments, live sessions.

Should I use this

Quality & Safety

B
Description quality
95%
Schema completeness
85%
Naming quality
52%
Poisoning risk
100%
Permission match
100%
Protocol compliance
100%

Findings (38)

  • LOWTool 'catalog.node_schema' description lacks action verbin catalog.node_schema
  • LOWTool 'account.whoami' doesn't follow camelCase/snake_casein account.whoami
  • LOWTool 'catalog.nodes' doesn't follow camelCase/snake_casein catalog.nodes
  • LOWTool 'catalog.node_schema' doesn't follow camelCase/snake_casein catalog.node_schema
  • LOWTool 'catalog.templates' doesn't follow camelCase/snake_casein catalog.templates
  • LOWTool 'catalog.template' doesn't follow camelCase/snake_casein catalog.template
  • LOWTool 'catalog.datasets' doesn't follow camelCase/snake_casein catalog.datasets
  • LOWTool 'catalog.leaderboard' doesn't follow camelCase/snake_casein catalog.leaderboard
  • LOWTool 'pipeline.validate' doesn't follow camelCase/snake_casein pipeline.validate
  • LOWTool 'pipeline.validate_node' doesn't follow camelCase/snake_casein pipeline.validate_node

Based on automated analysis of tool definitions and protocol compliance.

Context Cost

~7,151Tokens (tool definitions)
~1.3 KBTypical response size
Significant attention impact (5.59% of 128k context)

This is the approximate number of tokens consumed each time the server's tools are loaded into a model's context. Higher counts reduce the attention available for other tasks.

Install

One-Click Install

Add this to your `claude_desktop_config.json` file:

{
  "mcpServers": {
    "nimbus-mcp": {
      "command": "uvx",
      "args": [
        "nimbus-mcp"
      ]
    }
  }
}

Runnable packages

pypinimbus-mcp0.8.1stdio

Remote endpoints

https://nimbus-mcp.fly.dev/mcpstreamable-http

What it can do

Tool inventory

Tools (37)

🟢 Read-only🟡 Write🔴 Delete⚪ Unknown
🟢account.whoami

Who you are authenticated as: account email, plan (isPro / pioneer), this month's free-run quota, and — with a hosted token — the token name and days until it expires. Call this first when setup guidance appears or to check which credential a session uses.

Input Schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.nodes(category)

List Nimbus pipeline node types (data, preprocessing, features, models...). Use catalog.node_schema(node_type) for one node's full config schema and ports.

Input Schema

{
  "type": "object",
  "properties": {
    "category": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional filter — e.g. \"data\", \"preprocessing\", \"features\",\n\"models\" (exact category ids from the unfiltered list)."
    }
  },
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.node_schema(node_type)

Full config JSON schema + input/output ports for one node type.

Input Schema

{
  "type": "object",
  "properties": {
    "node_type": {
      "type": "string",
      "description": "Node id from catalog.nodes (e.g. \"csp\", \"nimbus_lda\")."
    }
  },
  "required": [
    "node_type"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.templates

List built-in starter pipelines (MI/P300/SSVEP...). catalog.template(id) returns the graph.

Input Schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.template(template_id)

Full template incl. the 'train' execGraph needed by execution.run/pipeline.validate.

Input Schema

{
  "type": "object",
  "properties": {
    "template_id": {
      "type": "string",
      "description": "Template id from catalog.templates (e.g. \"mi_csp_lda\")."
    }
  },
  "required": [
    "template_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.datasets(only_on_disk)

Curated public EEG datasets (MOABB packs) available to pipelines.

Input Schema

{
  "type": "object",
  "properties": {
    "only_on_disk": {
      "default": true,
      "type": "boolean",
      "description": "Only return datasets whose data packs are present on this\nbackend (True by default; False also lists known-but-missing sets)."
    }
  },
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢catalog.leaderboard

Public benchmark leaderboard: pipeline rankings per dataset. Rankings are per-dataset under the canonical ``within_session`` protocol (see ``protocol``). Within each dataset, ``rows`` are sorted desc by ``meanAccuracyPct`` (95% CI in ``ciLoPct``/``ciHiPct``). Use ``pipelineId`` as the template id hint for ``catalog.template`` when building a pipeline. ``updated`` marks each dataset's most recent run; ``packFingerprint`` identifies the exact dataset pack the scores came from.

Input Schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢pipeline.validate(train_graph)

Validate a pipeline graph before running. ExecGraphSnapshot: {nodes: [{id, type, config}], connections: [{from, to}]}. Build it from catalog.template(id).train or from scratch using catalog.nodes().

Input Schema

{
  "type": "object",
  "properties": {
    "train_graph": {
      "additionalProperties": true,
      "type": "object",
      "description": "The graph to validate ({nodes, connections})."
    }
  },
  "required": [
    "train_graph"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢pipeline.validate_node(node_type, config)

Validate one node's config object against its schema (catalog.node_schema).

Input Schema

{
  "type": "object",
  "properties": {
    "node_type": {
      "type": "string",
      "description": "Node type id from catalog.nodes (e.g. \"csp\", \"nimbus_lda\")."
    },
    "config": {
      "additionalProperties": true,
      "type": "object",
      "description": "The node's config object to check."
    }
  },
  "required": [
    "node_type",
    "config"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
⚪execution.run(train_graph, name, description, subject, layout)

Start a pipeline run (NON-BLOCKING). Returns executionId — poll with execution.get() until status is completed/failed, then execution.results().

Input Schema

{
  "type": "object",
  "properties": {
    "train_graph": {
      "additionalProperties": true,
      "type": "object",
      "description": "Pipeline graph {nodes: [{id, type, config}], connections:\n[{from, to}]} as built by catalog.template/pipeline.validate."
    },
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Display name for the run (shown in the Runs list)."
    },
    "description": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional longer description of the experiment."
    },
    "subject": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional dataset subject code (e.g. \"S01\") recorded with the run."
    },
    "layout": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional canvas positions {nodes: {id: {x, y}}}; a deterministic\ngrid is synthesized when omitted."
    }
  },
  "required": [
    "train_graph"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🔴execution.cancel(execution_id)

Cancel a running execution.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The run to terminate (from execution.run/execution.list)."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢execution.get(execution_id)

Execution status summary (status: running/completed/failed/cancelled).

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The run to check (from execution.run/execution.list)."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢execution.list(limit, status)

Recent executions. Optional status filter (running/completed/failed/cancelled).

Input Schema

{
  "type": "object",
  "properties": {
    "limit": {
      "default": 20,
      "type": "integer",
      "description": "Maximum number of runs to return (default 20)."
    },
    "status": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter by run status: running/completed/failed/cancelled."
    }
  },
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢execution.results(execution_id, full)

Metrics for a completed run. Trimmed by default (accuracy, kappa, ITR, confusion matrix, per-class); full=True returns the complete result object.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The completed run to fetch metrics for."
    },
    "full": {
      "default": false,
      "type": "boolean",
      "description": "Return the backend's complete result object (all fields)."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢calibration.start(paradigm, confirm, trials_per_class, classes, name, ...)

Start a guided subject calibration session (NON-BLOCKING; confirm-gated — the device goes on a human's head). The Nimbus Studio app shows the cues on its calibration dashboard automatically; poll calibration.status. Requires a Pro plan (hosted token or Pro session): calibration nodes and custom-data training are gated by the freemium node policy; local X-MCP-Key principals get 403 by policy.

Input Schema

{
  "type": "object",
  "properties": {
    "paradigm": {
      "default": "mi",
      "type": "string",
      "description": "mi | p300 | sart | target_hit."
    },
    "confirm": {
      "default": false,
      "type": "boolean",
      "description": "MUST be true — explicit user go-ahead for a session on their head."
    },
    "trials_per_class": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Override the template's trial count (minimum 5)."
    },
    "classes": {
      "anyOf": [
        {
          "items": {
            "additionalProperties": true,
            "type": "object"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Override class list [{id,label,cue}] (MI default: left/right hand)."
    },
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Display name recorded on the execution."
    },
    "device_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device id from device.list (omit → template default synthetic)."
    },
    "connection_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device selector when several exist (e.g. serial vs wifi)."
    },
    "port": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Serial/COM port for wired devices."
    },
    "ip_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device IP for network/wifi devices."
    },
    "ip_port": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Port for network devices."
    },
    "stream_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL stream name (LSL devices)."
    },
    "source_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL source id."
    },
    "mac_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Bluetooth MAC (BT devices)."
    },
    "serial_number": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device serial (some BLE stacks)."
    }
  },
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢calibration.status(execution_id)

Live snapshot of a calibration session (phase, current trial, progress, paused). Once complete, carries the recorded upload — call calibration.train to turn it into the subject's own classifier.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The calibration run to inspect (from calibration.start)."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
⚪calibration.pause(execution_id)

Pause a running calibration between trials (cues hold; resume anytime).

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The calibration run to pause."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
⚪calibration.resume(execution_id)

Resume a paused calibration session.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The calibration run to resume."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟡calibration.train(execution_id, paradigm, template_id, train_graph, name)

Train the subject's own classifier from a COMPLETED calibration session (NON-BLOCKING). Fetches the recorded upload, wires it into a train pipeline as a custom_data source, and starts the run. Requires a Pro plan (custom_data training is freemium-gated). The calibrate→train handoff requires a Postgres-backed backend (hosted or local dev); a desktop-local session completes and records, but its upload can't be resolved by MCP train today.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "The COMPLETED calibration run (from calibration.start)."
    },
    "paradigm": {
      "default": "mi",
      "type": "string",
      "description": "Paradigm of the recording (mi | p300 | sart | target_hit);\nonly mi has a default train template."
    },
    "template_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Train template to use (e.g. from catalog.templates);\nrequired for non-mi paradigms (mi defaults to mi_headband_csp_lda)."
    },
    "train_graph": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Explicit train graph instead of a template; its first\ndata node (custom_data/public_data) is rewired onto the recording."
    },
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Display name recorded on the training run."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
⚪experiment.run(runs, max_concurrent)

Run 1-25 pipelines as ONE paced experiment (NON-BLOCKING). Returns an experimentId immediately; a background thread submits at most 2 runs at a time (min(max_concurrent, 2)), retries queue-full up to 3 times per run, and polls each execution to completion. Poll experiment.get() for per-run status and, once finished, aggregated metrics.

Input Schema

{
  "type": "object",
  "properties": {
    "runs": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "type": "array",
      "description": "1-25 entries, each {name: str, train_graph: {nodes, connections}}\n(same graph shape as execution.run's train_graph)."
    },
    "max_concurrent": {
      "default": 2,
      "type": "integer",
      "description": "Parallel submissions cap, clamped to 1-2 (default 2)."
    }
  },
  "required": [
    "runs"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢experiment.get(experiment_id)

Experiment snapshot: status (running/completed/failed), per-run rows ({name, executionId, status, error?, metrics?}) and, once finished, aggregates {metric: {mean, std, best: {name, value}}} over completed runs only (std = population; None below 2 values).

Input Schema

{
  "type": "object",
  "properties": {
    "experiment_id": {
      "type": "string",
      "description": "The experiment to inspect (from experiment.run)."
    }
  },
  "required": [
    "experiment_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢execution.artifacts(execution_id)

Trained artifacts (models/filters, e.g. *.pkl) saved by an execution.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "Run whose artifacts to list."
    }
  },
  "required": [
    "execution_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢execution.download_artifact(execution_id, artifact_name)

Download one artifact file to NIMBUS_EXPORT_DIR/executions/<id>/ and return its path.

Input Schema

{
  "type": "object",
  "properties": {
    "execution_id": {
      "type": "string",
      "description": "Run that produced the artifact."
    },
    "artifact_name": {
      "type": "string",
      "description": "File name from execution.artifacts (e.g. \"nimbus_lda.pkl\")."
    }
  },
  "required": [
    "execution_id",
    "artifact_name"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢pipeline.export(train_graph, name)

Export the pipeline as a standalone runnable Python bundle (zip saved locally).

Input Schema

{
  "type": "object",
  "properties": {
    "train_graph": {
      "additionalProperties": true,
      "type": "object",
      "description": "Pipeline graph {nodes, connections} to export."
    },
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional name recorded inside the bundle."
    }
  },
  "required": [
    "train_graph"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢device.list

EEG devices supported by this backend (OpenBCI, Muse, BrainBit, LSL, PiEEG...).

Input Schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢device.test(device_type, connection_type, port, ip_address, ip_port, ...)

Test a device connection WITHOUT starting a stream (safe, no confirm needed).

Input Schema

{
  "type": "object",
  "properties": {
    "device_type": {
      "type": "string",
      "description": "Device id from device.list (e.g. \"brainbit\", \"muse\")."
    },
    "connection_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device-specific selector when several exist (e.g. serial vs wifi)."
    },
    "port": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Serial/COM port for wired devices."
    },
    "ip_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device IP for network/wifi devices."
    },
    "ip_port": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Port for network devices."
    },
    "stream_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL stream name (LSL devices)."
    },
    "source_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL source id."
    },
    "mac_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Bluetooth MAC (BT devices)."
    },
    "serial_number": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device serial (some BLE stacks)."
    }
  },
  "required": [
    "device_type"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
⚪stream.start(device_type, confirm, session_id, chunk_size, n_channels, ...)

Connect an EEG device and START a live streaming session on the user's head. Requires confirm=True; call device.test first. Track with stream.status(). Idle watchdog: if no stream.status()/stream.telemetry() poll happens for idle_timeout_sec (default 900), the session is stopped and the device disconnected automatically — an abandoned stream never keeps running on the user's head. Any poll resets the timer; idle_timeout_sec=0 disables the watchdog.

Input Schema

{
  "type": "object",
  "properties": {
    "device_type": {
      "type": "string",
      "description": "Device id from device.list (e.g. \"brainbit\")."
    },
    "confirm": {
      "default": false,
      "type": "boolean",
      "description": "MUST be true to start — the explicit user go-ahead for a live\nsession on their head; anything else is refused with zero requests."
    },
    "session_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional existing session to resume/reuse."
    },
    "chunk_size": {
      "default": 125,
      "type": "integer",
      "description": "Samples per streamed chunk (default 125)."
    },
    "n_channels": {
      "default": 8,
      "type": "integer",
      "description": "Channel count to open (default 8)."
    },
    "connection_type": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device-specific selector (e.g. serial vs wifi)."
    },
    "port": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Serial/COM port for wired devices."
    },
    "ip_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device IP for network/wifi devices."
    },
    "ip_port": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Port for network devices."
    },
    "stream_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL stream name (LSL devices)."
    },
    "source_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "LSL source id."
    },
    "mac_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Bluetooth MAC (BT devices)."
    },
    "serial_number": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Device serial (some BLE stacks)."
    },
    "idle_timeout_sec": {
      "default": 900,
      "type": "integer",
      "description": "Watchdog: stop+disconnect after this many seconds\nwithout a status poll (default 900; 0 disables)."
    }
  },
  "required": [
    "device_type"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢stream.status(session_id)

Live snapshot of a streaming session (running, deviceConnected). Polling this also feeds the idle watchdog: each call resets the session's idle timer (see stream.start's idle_timeout_sec).

Input Schema

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string",
      "description": "The streaming session to inspect."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🔴stream.stop(session_id)

Stop a streaming session and disconnect the device (always safe to call). Also removes the session from the idle watchdog so it cannot fire after an explicit stop.

Input Schema

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string",
      "description": "The streaming session to stop."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢stream.telemetry(session_id, window)

Live snapshot of a streaming session: latest prediction + recent window, signal quality (meanChannelQuality, snrDb, artifactProbability), indicators, running stats. Poll this while a session runs. Live telemetry requires a DEPLOYED model session (hub deploy / playback with a classifier); modelless hardware streams have no telemetry — use stream.status for those. Expect low confidence during filter/ASR warm-up (first seconds); quality < 0.5 or high artifactProbability means the signal is poor. 404 => session not active in this backend. Each poll also feeds the idle watchdog (see stream.start's idle_timeout_sec), keeping an actively watched session alive.

Input Schema

{
  "type": "object",
  "properties": {
    "session_id": {
      "type": "string",
      "description": "The streaming session to read telemetry for."
    },
    "window": {
      "default": 50,
      "type": "integer",
      "description": "How many recent predictions/chunks to include (default 50)."
    }
  },
  "required": [
    "session_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟡data.upload(file_path, dataset_name, sampling_rate, format)

Upload an EEG file (.edf/.bdf/.mat/.csv/.txt/.tsv/.h5/.hdf5, <=500MB) to the backend and get the registered path for a custom_data node. sampling_rate (Hz, e.g. 250.0) is REQUIRED for plain CSV/TSV/TXT files without embedded metadata — the backend silently assumes 250 Hz otherwise, which mis-times epochs, filters and spectral features. format overrides extension-based detection (auto, mat, csv, tsv, txt, edf, bdf, h5, hdf5).

Input Schema

{
  "type": "object",
  "properties": {
    "file_path": {
      "type": "string",
      "description": "Local file to upload (.edf/.bdf/.mat/.csv/.txt/.tsv/.h5/.hdf5, <=500MB)."
    },
    "dataset_name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional label for the uploaded dataset."
    },
    "sampling_rate": {
      "anyOf": [
        {
          "type": "number"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Hz for headerless CSV/TSV/TXT (REQUIRED there, e.g. 250.0)."
    },
    "format": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Override extension-based detection (auto|mat|csv|tsv|txt|edf|bdf|h5|hdf5)."
    }
  },
  "required": [
    "file_path"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢data.inspect_dataset(dataset, subject, mode)

Exploratory summary of a public EEG dataset (MOABB pack): channels, sampling rate, trial/class balance, per-channel µV stats, band powers and a PSD overview. Look at the data BEFORE building pipelines: class balance drives stratification choices (imbalanced classes skew accuracy), and flatlined channels mean a montage/reference problem worth fixing first. subject is REQUIRED (the backend 400s without it) — get the subject list via catalog.datasets, e.g. "S01"; a comma-list like "S01,S03" loads a cohort. mode: training | evaluation | all. Units note: values are ASSUMED volts by the loader — a µV-native file reads 1e6x too large; set unitsScale in a pipeline's custom_data config when needed.

Input Schema

{
  "type": "object",
  "properties": {
    "dataset": {
      "type": "string",
      "description": "Dataset id from catalog.datasets (e.g. \"BNCI2014_001\")."
    },
    "subject": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "REQUIRED subject code (\"S01\") or comma-list cohort (\"S01,S03\")."
    },
    "mode": {
      "default": "all",
      "type": "string",
      "description": "Which split to summarize — training | evaluation | all."
    }
  },
  "required": [
    "dataset"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢data.inspect_file(path)

Exploratory summary of an EEG file (.edf/.bdf/.mat/.csv/.tsv/.txt/.h5): channels, sampling rate, trial/class balance, per-channel µV stats, band powers and a PSD overview. The path shape picks the source: ABSOLUTE path → read the file from disk (only on a LOCAL backend: desktop app / MCP local mode — no upload needed); RELATIVE path (the one data.upload returns) → describe the uploaded file, which works on ANY backend (hosted or local). Look at the data BEFORE building pipelines: class balance drives stratification choices, and flatlined channels mean a montage/reference problem worth fixing first. Units note: values are ASSUMED volts by the loader — a µV-native CSV reads 1e6x too large; set unitsScale in a pipeline's custom_data config when needed. On a hosted backend absolute paths are refused and this returns guidance (upload the file first or switch to a local backend).

Input Schema

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "ABSOLUTE filesystem path (local backends only) or the RELATIVE\nupload path returned by data.upload (works on any backend)."
    }
  },
  "required": [
    "path"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟡project.create(name, description)

Create a project (container for one pipeline document). Returns projectId.

Input Schema

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Project display name (e.g. \"MI CSP-LDA sweep\")."
    },
    "description": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional longer description shown in the studio."
    }
  },
  "required": [
    "name"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢project.list

List projects owned by the current principal (agent work included).

Input Schema

{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟡project.save(project_id, train_graph, name, subject)

Save a pipeline graph into a project (visible on the studio canvas). Handles revision conflicts automatically (one retry).

Input Schema

{
  "type": "object",
  "properties": {
    "project_id": {
      "type": "string",
      "description": "Target project (from project.create/project.list)."
    },
    "train_graph": {
      "additionalProperties": true,
      "type": "object",
      "description": "Pipeline graph {nodes, connections} to persist."
    },
    "name": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional pipeline name stored on the document."
    },
    "subject": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional dataset subject code (e.g. \"S01\") for this pipeline."
    }
  },
  "required": [
    "project_id",
    "train_graph"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}
🟢project.load(project_id)

Load a project's saved pipeline (train graph + meta) for editing/re-running.

Input Schema

{
  "type": "object",
  "properties": {
    "project_id": {
      "type": "string",
      "description": "Project whose pipeline document to load."
    }
  },
  "required": [
    "project_id"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "additionalProperties": true
}

Community

Rate this Server

Evidence

Recent observations

verifiedversion not recorded37 tools