io.github.nimbusbci/nimbus-mcp · v0.13.2 · data-and-databases
Nimbus BCI is healthy: it completed an MCP handshake in 5811 ms and exposes 49 tools.
AI agents build, train, and analyze BCI/EEG pipelines: data, models, experiments, live sessions.
Endpoint: https://nimbus-mcp.fly.dev/mcp (streamable-http)
Repository · JSON · Add to my inventory
| Users (last 30 days) | 0 |
| Handshake | Healthy |
| Auth needed | None |
| Tool count | 49 |
| Latency | 5811 ms |
| Last checked (UTC) | 2026-10-15T06:10:49.913Z |
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-10-15T06:10:49.913Z | Healthy | 5811 |
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 ``owner`` name). Wit |
leaderboard.submit | Submit a BYO python_model to a leaderboard track for server-side scoring. Nimbus scores it server-side under the track's fixed protocol — you submit code, never results. Poll ``leaderboard.status`` with the returned ``submissionId``; scoring takes minutes (classical) to tens of minutes (deep). Requ |
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 nodes and custom-data |
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 handoff requires a Postgr |
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() for per-run status an |
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) export as BIDS-derivati |
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 and the device disco |
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 inspect uses: MOABB packs, |
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. On the pretrained_few_trial track the figure also includes the classical LOSO baseline as a muted side panel fo |
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) report live signal q |
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 otherwise, which mis-times |
data.inspect_dataset | 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 cha |
data.inspect_file | 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 |
project.create | Create a project (container for one pipeline document). Returns projectId. |
project.list | List projects owned by the current principal (agent work included). |
project.save | Save a pipeline graph into a project (visible on the studio canvas). Handles revision conflicts automatically (one retry). |
project.load | Load a project's saved pipeline (train graph + meta) for editing/re-running. |
python.validate | Statically check a python_model script (BYO model class) without running it. Compiles the source and verifies the contract — a class with fit(X, y, info) and predict(X); optional predict_proba(X) unlocks confidence panels. Never executes the code, so it is safe against the hosted backend. Use it be |
stats.grouped | Cluster-aware group statistics across executions: pools the per-subject (per-group) accuracies each run's evaluation plan stored, then reports the between-group summary — mean accuracy with a t-interval and a one-sample t-test vs chance. Use this instead of eyeballing pooled accuracy: trials within |
foundation.compare | Run every available pretrained backbone on YOUR data and see which wins — a ranked bar chart with CI whiskers, params, and wall time per backbone. Backbones that can't process your data (window size, channel count) are noted, not silently skipped. Each backbone embeds your trials frozen (the exact f |