Index / MCP servers / Nimbus BCI

Nimbus BCI MCP server

Nimbus BCI is an MCP server with 63 tools an agent can call, among them account.whoami, bids.export_dataset, bids.export_execution. It answers at https://nimbus-mcp.fly.dev/mcp over streamable HTTP, and it listed its tools to an anonymous client, so no sign-in was needed for that. Our probes reached it 4 of 4 times since 5 October 2026; the last check, on 21 November 2026, succeeded.

Status
Answering
Tools
63
Reliability
4 of 4 checks
Response time
4332 ms
Transport
streamable HTTP
Last checked
21 November 2026

BCI/EEG toolkit: public MOABB/BNCI datasets, pipeline build/validate, hosted training, BIDS export.

Description as the publisher wrote it.

The 63 tools Nimbus BCI offers

ToolWhat it does
account.whoamiWho 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
bids.export_datasetExport a Nimbus dataset as a BIDS-layout zip (local: saved to NIMBUS_EXPORT_DIR/bids/; hosted gateway: inline ``contentBase64``, up to 1 MB). Continuous sources (EDF/BDF uploads, stream recordings) export as BIDS-raw (EDF byte-passthrough;
Inputs: dataset, subjects, kind
bids.export_executionExport 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). Local: saved to NIMBUS_EXPORT_DIR/bids/
Inputs: execution_id
calibration.pausePause a running calibration between trials (cues hold; resume anytime).
Inputs: execution_id
calibration.resumeResume a paused calibration session.
Inputs: execution_id
calibration.startStart 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 (hos
Inputs: paradigm, confirm, trials_per_class, classes, name, device_type
calibration.statusLive 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.
Inputs: execution_id
calibration.trainTrain 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 fr
Inputs: execution_id, paradigm, template_id, train_graph, name
catalog.datasetsCurated public EEG datasets (MOABB packs) available to pipelines.
Inputs: only_on_disk
catalog.leaderboardPublic 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;
Inputs: dataset_id
catalog.node_schemaFull config JSON schema + input/output ports for one node type.
Inputs: node_type
catalog.nodesList Nimbus pipeline node types (data, preprocessing, features, models...). Use catalog.node_schema(node_type) for one node's full config schema and ports.
Inputs: category
catalog.templateFull template incl. the 'train' execGraph needed by execution.run/pipeline.validate.
Inputs: template_id
catalog.templatesList built-in starter pipelines (MI/P300/SSVEP...). catalog.template(id) returns the graph. Each row carries ``datasetId`` (catalog id, e.g. "BNCI2014_001" — the id catalog.leaderboard and catalog.datasets use) and ``paradigm`` when the tem
Inputs: dataset, paradigm
data.delete_uploadDelete an uploaded file from your account (disk + registry). Requires confirm=True. Pass the path returned by data.upload (file.path). Only your own uploads can be deleted; missing paths return not-found.
Inputs: path, confirm
data.inspect_datasetExploratory 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 ch
Inputs: dataset, subject, mode
data.inspect_fileExploratory 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
Inputs: path, sampling_rate
data.uploadUpload 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 — uplo
Inputs: file_path, dataset_name, sampling_rate, format
device.listEEG devices supported by this backend (OpenBCI, Muse, BrainBit, LSL, PiEEG...).
device.testTest a device connection WITHOUT starting a stream (safe, no confirm needed).
Inputs: device_type, connection_type, port, ip_address, ip_port, stream_name
execution.artifactsTrained artifacts (models/filters, e.g. *.pkl) saved by an execution.
Inputs: execution_id
execution.cancelCancel a running execution.
Inputs: execution_id
execution.deletePermanently delete one of your finished runs (completed/failed/cancelled) with its results. Running runs must be cancelled first (409 nimbus.execution.delete_not_terminal). Owner only.
Inputs: execution_id, confirm
execution.download_artifactDownload one artifact file. Local/stdio: saved to NIMBUS_EXPORT_DIR/executions/<id>/ and its path returned. Hosted gateway: returned inline as ``contentBase64`` (up to 1 MB of base64); larger files point to Nimbus Studio. Nothing is written
Inputs: execution_id, artifact_name
execution.getExecution status summary (status: running/completed/failed/cancelled). Summary fields: ``dataset`` is the human-readable display label (e.g. "BCIIV2a"); ``datasetId`` is the catalog id (e.g. "BNCI2014_001") accepted by other tools (data.ins
Inputs: execution_id
execution.listRecent executions. Optional status filter (running/completed/failed/cancelled). Per-run fields: ``dataset`` is the human-readable display label (e.g. "BCIIV2a"); ``datasetId`` is the catalog id (e.g. "BNCI2014_001") accepted by other tools
Inputs: limit, status
execution.resultsMetrics for a completed run. Trimmed by default (accuracy, kappa, ITR, confusion matrix, per-class); full=True returns the complete result object.
Inputs: execution_id, full
execution.runStart a pipeline run (NON-BLOCKING). Returns executionId — poll with execution.get() until status is completed/failed, then execution.results(). If an identical graph is already running for you, the run still starts but the response carries
Inputs: train_graph, name, description, subject, layout
experiment.deleteDelete one of your experiment records (server + this machine's local cache). Its individual runs are kept — delete them with execution.delete. A still-running experiment cannot be deleted.
Inputs: experiment_id, confirm
experiment.getExperiment snapshot: status (running/completed/failed), per-run rows ({name, executionId, status, error?, metrics?, evaluationKind?}) and, once finished, aggregates over completed runs only: per-metric {mean, std, best, n}, plus ``pooledExe
Inputs: experiment_id
experiment.runRun 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 executio
Inputs: runs, max_concurrent
foundation.compareRun 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 s
Inputs: source, dataset, subject, mode, path
leaderboard.mineList your leaderboard submissions (newest first), all datasets.
leaderboard.statusFetch 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.
Inputs: submission_id
leaderboard.submitSubmit 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``; scorin
Inputs: dataset_id, name, code, class_name, requirements, track
pipeline.exportExport the pipeline as a standalone runnable Python bundle (zip). Local/stdio: the zip is saved under NIMBUS_EXPORT_DIR/exports and its path returned. Hosted gateway: the zip is returned inline as ``contentBase64`` (up to 1 MB of base64). U
Inputs: train_graph, name
pipeline.validateValidate 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().
Inputs: train_graph
pipeline.validate_nodeValidate one node's config (schema + semantic checks). Catches the same value errors as pipeline.validate for a single node (inverted bandpass, CSP components vs channel count when dataset is set).
Inputs: node_type, config, dataset
plots.confusionConfusion-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 numbe
Inputs: execution_id, matrix, save
plots.datasetFigure 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 ch
Inputs: kind, source, dataset, subject, mode, path
23 more tools

plots.erp, plots.leaderboard, project.create, project.delete, project.list, project.load, project.rename, project.save, protocol.export_stats, protocol.list, protocol.pause, protocol.resume, protocol.save, protocol.session_status, protocol.start_assignment, protocol.stop, protocol.validate, python.validate, stats.grouped, stream.start, stream.status, stream.stop, stream.telemetry

Add Nimbus BCI to your AI client

Every block below points at https://nimbus-mcp.fly.dev/mcp. Pick your client and copy.

Claude Code: one command in your terminal
claude mcp add --transport http nimbus-bci https://nimbus-mcp.fly.dev/mcp
Claude Desktop: claude_desktop_config.json
{
  "mcpServers": {
    "nimbus-bci": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://nimbus-mcp.fly.dev/mcp"]
    }
  }
}
Cursor: ~/.cursor/mcp.json, or .cursor/mcp.json in a project
{
  "mcpServers": {
    "nimbus-bci": {
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
VS Code and GitHub Copilot: .vscode/mcp.json
{
  "servers": {
    "nimbus-bci": {
      "type": "http",
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Zed: Zed settings.json
{
  "context_servers": {
    "nimbus-bci": {
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Windsurf: ~/.codeium/mcp_config.json
{
  "mcpServers": {
    "nimbus-bci": {
      "serverUrl": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
JetBrains AI Assistant: Settings, Tools, AI Assistant, MCP, New MCP Server, as JSON
{
  "mcpServers": {
    "nimbus-bci": {
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Continue: .continue/mcpServers/neuronto.yaml
name: Nimbus BCI
version: 0.0.1
schema: v1
mcpServers:
  - name: Nimbus BCI
    type: streamable-http
    url: https://nimbus-mcp.fly.dev/mcp
Gemini CLI: ~/.gemini/settings.json
{
  "mcpServers": {
    "nimbus-bci": {
      "httpUrl": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Codex CLI: MCP server config
{
  "mcpServers": {
    "nimbus-bci": {
      "type": "http",
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Warp: MCP servers, + Add, paste JSON
{
  "mcpServers": {
    "nimbus-bci": {
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}
Goose: a one-click extension link
goose://extension?url=https%3A%2F%2Fnimbus-mcp.fly.dev%2Fmcp&type=streamable_http&id=nimbus-bci&name=Nimbus%20BCI

Is Nimbus BCI up right now?

It answered our last check on 21 November 2026 in 4332 ms. Over 4 checks since 5 October 2026 it answered 4. Status here comes from Neuronto's own probes, not from the publisher.

MCP servers similar to Nimbus BCI

Questions about Nimbus BCI

How many tools does Nimbus BCI have?

63, as returned by the server's own tools/list on 21 November 2026: account.whoami, bids.export_dataset, bids.export_execution, calibration.pause, calibration.resume, calibration.start, calibration.status, calibration.train, and 55 more.

Is Nimbus BCI down?

It answered our last check on 21 November 2026 in 4332 ms. Over 4 checks since 5 October 2026 it answered 4.

How do I add Nimbus BCI to Cursor?

Put the server under mcpServers in ~/.cursor/mcp.json with the URL https://nimbus-mcp.fly.dev/mcp. The exact JSON is above, with the same setup for Claude Code, Claude Desktop, VS Code, Windsurf, Zed, Gemini CLI and the rest.

Does Nimbus BCI need an API key?

It listed its tools to an anonymous client, so reading the tool list needs no key. Individual tools can still ask for credentials in their own inputs.

Where this comes from

Publisher: io.github.nimbusbci. Endpoint host: nimbus-mcp.fly.dev. ARD identifier: urn:air:io.github.nimbusbci:mcp:nimbus-mcp. First indexed 4 October 2026. The tools are exactly what the server returned; nothing on this page is inferred from its name. Ranking in Neuronto search is never for sale.

Is this your server? Get a message the day it stops answering or its tools change: monitoring, 14 days free. Or claim the domain to manage how it is listed.