Nimbus BCI

Last 30 days

Uptime

100%

Response time

271 ms typical, 271 ms slowest 5%

Last check

5 h ago

Next check

in 26 min

How to call it

Add it to any MCP client that supports remote servers.

{
  "mcpServers": {
    "nimbus-bci": {
      "type": "http",
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}

48 tools

• 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.

• catalog.nodes

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

• catalog.node_schema

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

• catalog.templates

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

• catalog.template

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

• catalog.datasets

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

• catalog.leaderboard

  Public benchmark leaderboard: pipeline rankings per dataset. Two tracks: the top-level ``within_session`` block (curated suite pipelines) and ``crossSubject`` (leave-one-subject-out — curated pipelines plus BYO ``python_model`` submissions; BYO rows carry ``kind: "byo"`` and an

• leaderboard.submit

  Submit a BYO python_model to the cross-subject (LOSO) leaderboard. Nimbus scores it server-side under the fixed protocol (seed 42, leave-one-subject-out over the dataset's subjects) — you submit code, never results. Poll ``leaderboard.status`` with the returned ``submissionId``;

• leaderboard.status

  Fetch one of your leaderboard submissions (owner-only). Returns status (queued | scoring | done | failed), metrics when done (meanAccuracyPct + CI, same shape as leaderboard rows), or the error that failed it.

• leaderboard.mine

  List your leaderboard submissions (newest first), all datasets.

• pipeline.validate

  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().

• pipeline.validate_node

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

• execution.run

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

• execution.cancel

  Cancel a running execution.

• execution.get

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

• execution.list

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

• execution.results

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

• calibration.start

  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 n

• calibration.status

  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.

• calibration.pause

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

• calibration.resume

  Resume a paused calibration session.

• calibration.train

  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 hando

• experiment.run

  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() f

• experiment.get

  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).

• execution.artifacts

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

• execution.download_artifact

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

• pipeline.export

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

• bids.export_dataset

  Export a Nimbus dataset as a BIDS-layout zip saved to NIMBUS_EXPORT_DIR/bids/. Continuous sources (EDF/BDF uploads, stream recordings) export as BIDS-raw (EDF byte-passthrough; recordings converted HDF5→EDF with events.tsv). Epoched sources (MOABB packs, trial-table uploads) exp

• bids.export_execution

  Export an execution's results as a BIDS-derivative zip (metrics.json, per-subject participants.tsv, protocol.json, full pipeline_snapshot.json, predictions.tsv when stored, provenance/execution.json) saved to NIMBUS_EXPORT_DIR/bids/.

• device.list

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

• device.test

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

• stream.start

  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

• stream.status

  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).

• stream.stop

  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.

• plots.confusion

  Confusion-matrix figure for one execution: heatmap with trial counts + per-class accuracy bars, rendered as a PNG the assistant can see. Use it right after execution.results to eyeball WHICH classes are confused, not just the accuracy number.

• plots.dataset

  Figure over an EEG data source — the visual companion to data.inspect_dataset. kind=psd (Welch, channel mean bold), kind=bandpower (channel × band dB heatmap), kind=topomap (band-power scalp map), kind=spectrogram (time-frequency for one channel). Sources are the same ones inspec

• plots.erp

  ERP butterfly figure from epoched data: one subplot per class, all channel means (thin) + across-channel mean (bold), time-locked to the trial event. Shows whether class-conditioned evoked structure exists BEFORE training anything.

• plots.leaderboard

  Leaderboard bar chart for one dataset: accuracy with 95% CI whiskers, best first; BYO python_model submissions highlighted in a distinct color. The visual companion to catalog.leaderboard.

• stream.telemetry

  Live snapshot of a streaming session: latest prediction + recent window, signal quality (meanChannelQuality, snrDb, artifactProbability), indicators, running stats. Poll this while a session runs. Works with OR without a deployed model: modelless hardware streams (no classifier)

• data.upload

  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 otherwi

Security scan

• No findings. We scan names, descriptions and tool definitions for hidden instructions and other prompt-injection patterns.

Recent checks