Nimbus BCI Engine

• 🐍 Python SDK (nimbus-bci): sklearn-compatible classifiers with MNE-Python integration
• ⚡ Julia SDK (NimbusSDK.jl): Built on RxInfer.jl for maximum performance

​

Why Nimbus BCI

• High Latency: Standard processing takes 200ms+ for trial classification
• No Uncertainty Quantification: Deterministic outputs without confidence measures
• Limited Adaptability: Cannot handle changing brain states or signal quality
• Black Box Models: Deep learning lacks explainability for FDA approval

• ✅ Fast Inference: 10-20ms per trial with Bayesian models
• ✅ Uncertainty Quantification: Full posterior distributions, not just point estimates
• ✅ Training & Calibration: Subject-specific personalization in minutes
• ✅ Explainable: White-box probabilistic models for medical compliance
• ✅ Production-Ready: Batch and streaming modes, quality assessment, performance tracking

​

Core Features

​

Implemented Models

​

BCI Paradigms Supported

​

Quick Example

from nimbus_bci import NimbusLDA
import numpy as np

# 1. Create and fit classifier
clf = NimbusLDA()
clf.fit(X_train, y_train)

# 2. Predict with uncertainty
predictions = clf.predict(X_test)
probabilities = clf.predict_proba(X_test)

# 3. Works with sklearn pipelines
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

pipe = make_pipeline(StandardScaler(), NimbusLDA())
pipe.fit(X_train, y_train)

# 4. Online learning
clf.partial_fit(X_new, y_new)

using NimbusSDK

# 1. One-time setup: Install core with your API key
NimbusSDK.install_core("nbci_live_your_key")

# 2. Load pre-trained model
model = load_model(RxLDAModel, "motor_imagery_4class_v1")

# 3. Prepare preprocessed features (CSP, bandpower, etc.)
data = BCIData(csp_features, metadata, labels)

# 4. Run inference
results = predict_batch(model, data)

# 5. Analyze
println("Accuracy: $(sum(results.predictions .== labels) / length(labels))")
println("Mean confidence: $(mean(results.confidences))")
println("ITR: $(calculate_ITR(accuracy, 4, 4.0)) bits/minute")

​

Use Cases

​

SDK Architecture

EEG Hardware → Preprocessing → Nimbus SDK → Application
   (LSL/BrainFlow)  (MNE/EEGLAB)  (Python/Julia)  (Your Code)

• Local Inference: All processing on your machine (Python SDK is fully local)
• Privacy: Your EEG data never leaves your computer
• Speed: No network latency, consistent <20ms performance
• Offline Capable: Python SDK works completely offline

• Authentication and licensing
• Pre-trained model distribution
• Optional analytics logging

​

Getting Started

pip install nimbus-bci

using Pkg
Pkg.add("NimbusSDK")

# One-time setup: Install core with your API key
using NimbusSDK
NimbusSDK.install_core("your-api-key")

​

Documentation

​

Performance

​

Technology Stack

• Core: Python 3.10+, NumPy, JAX, NumPyro
• Integration: scikit-learn pipelines, MNE-Python
• Models: NimbusLDA, NimbusGMM, NimbusSoftmax (Polya-Gamma VI)

• Core: Julia 1.9+
• Inference Engine: RxInfer.jl - Reactive message passing
• Models: RxLDAModel, RxGMMModel, RxPolyaModel

• Preprocessing: MNE-Python, EEGLAB, BrainFlow
• API: TypeScript/Vercel serverless (Julia SDK authentication)

​

What’s Included

• ✅ sklearn-compatible classifiers: NimbusLDA, NimbusGMM, NimbusSoftmax
• ✅ MNE-Python integration for EEG preprocessing
• ✅ Streaming inference for real-time BCI
• ✅ Online learning with partial_fit()
• ✅ Comprehensive metrics and diagnostics

• ✅ RxInfer.jl-based models: RxLDAModel, RxGMMModel, RxPolyaModel
• ✅ Pre-trained model distribution
• ✅ Batch and streaming inference
• ✅ Training and calibration
• ✅ Quality assessment and ITR calculation

​

Support

​

License

• Free: 10K monthly inferences, basic models
• Research: 50K monthly inferences, all features
• Commercial: 500K monthly inferences, priority support
• Enterprise: Unlimited, custom models, on-premise deployment