Nimbus BCI

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

• Connection: Computer or cloud
• Transport: stdio, Streamable HTTP
• Category: Databases & datasets
• You need to fill in: NIMBUS_TOKEN, NIMBUS_MCP_KEY

Install

Pick the AI app you use, then copy the settings.

You need

• Runs in the cloudNothing to install; it connects over the internet
• PyPIPython’s uv installed (for the uvx command)

Which app do you use?

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

{
  "mcpServers": {
    "nimbus": {
      "command": "uvx",
      "args": [
        "nimbus-mcp"
      ],
      "env": {
        "NIMBUS_API_URL": "your-value",
        "NIMBUS_TOKEN": "your-value",
        "NIMBUS_TOKEN_FILE": "your-value",
        "NIMBUS_MCP_KEY": "your-value",
        "NIMBUS_MCP_KEY_FILE": "your-value"
      }
    }
  }
}

claude mcp add --transport http nimbus https://nimbus-mcp.fly.dev/mcp

claude mcp add nimbus --env NIMBUS_API_URL=your-value --env NIMBUS_TOKEN=your-value --env NIMBUS_TOKEN_FILE=your-value --env NIMBUS_MCP_KEY=your-value --env NIMBUS_MCP_KEY_FILE=your-value -- uvx nimbus-mcp

{
  "mcpServers": {
    "nimbus": {
      "url": "https://nimbus-mcp.fly.dev/mcp"
    }
  }
}

{
  "mcpServers": {
    "nimbus": {
      "command": "uvx",
      "args": [
        "nimbus-mcp"
      ],
      "env": {
        "NIMBUS_API_URL": "your-value",
        "NIMBUS_TOKEN": "your-value",
        "NIMBUS_TOKEN_FILE": "your-value",
        "NIMBUS_MCP_KEY": "your-value",
        "NIMBUS_MCP_KEY_FILE": "your-value"
      }
    }
  }
}

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

{
  "servers": {
    "nimbus": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "nimbus-mcp"
      ],
      "env": {
        "NIMBUS_API_URL": "your-value",
        "NIMBUS_TOKEN": "your-value",
        "NIMBUS_TOKEN_FILE": "your-value",
        "NIMBUS_MCP_KEY": "your-value",
        "NIMBUS_MCP_KEY_FILE": "your-value"
      }
    }
  }
}

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

Your choice stays on this device in a cookie; no account needed.

Values you fill in

• NIMBUS_API_URL env
  Nimbus backend URL. Defaults to the local backend (http://127.0.0.1:8080) — the desktop app and local key flow expect this; use https://nimbus-studio.fly.dev to run against the hosted API.
• NIMBUS_TOKEN secret env
  Hosted API token (nimb_…) minted in Nimbus Studio → Account → API tokens. Not needed if you already ran `nimbus-mcp login`.
• NIMBUS_TOKEN_FILE env
  Path to a 0600 JSON file {"token": "…"} holding a hosted API token (keeps secrets out of MCP configs).
• NIMBUS_MCP_KEY secret env
  Local-backend key; must match MCP_LOCAL_KEY on your Nimbus backend (dev server) or the desktop app's key.
• NIMBUS_MCP_KEY_FILE env
  Path to a local-backend key file. The desktop app's mcp-key.json is auto-discovered without this.

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

Which apps can use it

Based on how this server connects and on each app’s own docs, checked Nov 10, 2026.

Connect over the internet in

ClaudeChatGPTGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatOpen WebUIRaycast

Run on your computer in

ClaudeGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatRaycast

All apps, with pros and cons →

What it can do

Tool names and descriptions exactly as the server reported them on Nov 10, 2026. The maker wrote them, not us; we show them as plain text.

• 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. In anonymous Local Free

• 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. Each row carries ``datasetId`` (catalog id, e.g. "BNCI2014_001" — the id catalog.leaderboard and catalog.datasets use) and ``paradigm`` when the template loads a public dataset.

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

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

• execution.run

  Start 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 a ``warning`` + ``duplicateOf`` ids (ca

• execution.cancel

  Cancel a running execution.

• execution.delete

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

• execution.get

  Execution 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.inspect_dataset, public_data.dataset). ``ti

• execution.list

  Recent 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 (data.inspect_dataset, public_data.datas

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

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

• experiment.get

  Experiment 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 ``pooledExecutionIds`` / ``pooledRunNames`` / ``kin

• execution.artifacts

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

• execution.download_artifact

  Download one artifact file. Local/stdio: saved to NIMBUS_EXPORT_DIR/executions/ / 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 on the gateway.

• pipeline.export

  Export 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). UI-only nodes (interactive_application) a

• bids.export_dataset

  Export 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; recordings converted HDF5→EDF with event

• 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). Local: saved to NIMBUS_EXPORT_DIR/bids/. Hosted gateway: inline ``contentBase64

• 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. On the pretrained_few_trial track the figure also includes the classical LOSO baseline as a

• 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 — uploads without it are rejected (no silent 2

• data.delete_upload

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

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

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

• 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). Always pass expected_revision from the last project.load (or a prior save/create response). When it does not match the current server revision, the save fails with a conflict — it does NOT silently overwrite con

• project.load

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

• project.rename

  Rename a project you own (max 200 characters).

• project.delete

  Delete a project (and its saved pipeline document) from the studio workspace. Requires confirm=True: this removes the project from the user's project list. Executions already run from it are not affected. Find ids with project.list.

• protocol.validate

  Validate a neurofeedback protocol document WITHOUT saving it. Returns {valid: true, spec} on success, or {valid: false, errors: [...]} with the per-violation list (loc/msg) when the document is invalid — the verdict is data, never an exception.

• protocol.save

  Validate and persist the NEXT VERSION of a protocol document (confirm-gated: each call appends a version row; accidental calls clutter the version history). Edits create a new version — the assignment pins the version it runs.

• protocol.list

  Every saved protocol id at its latest version.

• protocol.start_assignment

  Enroll a subject and prepare their neurofeedback deploy session (confirm-gated — a session runs on a human). Creates the assignment (yoked sham arms REQUIRE yoked_donor_upload_id: a recorded simulated session's upload — mint one by running an active-arm session and data.upload-in

• protocol.session_status

  Live snapshot of a protocol deploy session: the scheduler block / session progress + threshold state (under ``protocol``) beside the telemetry window (recent indicators, quality, stats).

• protocol.pause

  Pause a running protocol session (blocks freeze; the session and device stay alive — resume with protocol.resume). Simulated and playback sessions only while paused: no data is recorded.

• protocol.resume

  Resume a paused protocol session (restarts the server-driven device loop). Live-hardware resume requires a Pro plan; simulated sessions are free. Pass the session's channel count (start_assignment reports it).

• protocol.stop

  Stop a protocol session (always safe to call): stops streaming, saves the block-annotated recording, advances the assignment when the scheduler reached its natural end, and disconnects the device (best-effort — a failed disconnect is reported, never raised).

• protocol.export_stats

  Paired pre/post analysis for one assignment's recorded sessions: per-block aggregates (descriptive + CSV), paired t / Wilcoxon / dz (per-statistic minimums: paired t and Cohen's dz need ≥ 3 completed sessions, Wilcoxon needs ≥ 5), specificity notes, the adaptive-threshold traject

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 11, 2026

• ✓ Pass

  Maker matches the repo

  The registry name was verified with the GitHub account nimbusbci, which owns the repo

• ✓ Pass

  Still maintained

  Code last changed 6 days ago

• … Not checked yet

  Has a licence

  We have not read this repo from GitHub yet

• ✓ Pass

  Endpoint responds

  Responded in 111 ms (HTTP 200)

• – Not applicable

  Sign-in with OAuth

  No sign-in needed

• ✓ Pass

  No hidden instructions in tool descriptions

  Read 60 tool descriptions and found no hidden instructions to the AI

Compared with others in Databases & datasetsi

• More stars than 84% of the other 1161 servers in this category
• Published to the registry more recently than 84% of the other 1161 servers in this category
• Basic checks equal to or better than 100% of the other 1161 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:↓ Downloads per weeki★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

README from the maker

{

claude mcp add --transport http nimbus https://nimbus-mcp.fly.dev/mcp

{

{

claude mcp add --transport http nimbus https://nimbus-mcp.fly.dev/mcp \

uvx nimbus-mcp login     # or: pip install nimbus-mcp && nimbus-mcp login

{

   nimbus-mcp login     # options: --api-url URL, --ttl-days 7..90, --name NAME

   {

account.whoami() → {userId, email, plan: {isPro, pioneerAccess},

- name: Nimbus smoke run