Last updated: July 16, 2026
- We open-sourced
seosiri-bioroboticsv1.0.0, a stateless, 6-tool MCP server that converts biological sequence data and human biosignals into deterministic G-code. - Two tools were added since launch:
calculate_dna_melting_temp(thermal deck configuration from GC-content) andtranslate_emg_to_actuation(EMG muscle signals to safe prosthetic joint angles). - The
translate_emg_to_actuationtool includes a real-time safety envelope check — live-tested at 350μV input, returning a NOMINAL safety status alongside the calculated joint angle. - The server runs fully local-first, with a documented local caching layer to reduce dependence on continuous UniProt API access.
- Listed as an Official server on Glama.ai's MCP directory with A-grade license, quality, and maintenance scores.
What Does the Bio-Robotics Core Engine Actually Do?
It acts as a stateless, multi-disciplinary translation layer: it ingests biological data (from the UniProt API) or physiological signals (surface electromyography, or EMG) and translates them into explicit, deterministic Cartesian coordinates. These coordinates are formatted as standardized G-code commands (e.g., G1 X[Value] F1500) that any CNC, 3D printer, liquid handler, or bionic joint servo can execute directly over USB serial.
Biotechnology, robotics, and human bionics are converging rapidly, but integrating these systems remains highly fragmented. Biological datasets and human nervous system outputs are unstructured and variable, while physical hardware controllers require strict, low-latency, deterministic coordinates. Historically, bridging this gap required fragile integration scripts that broke during database changes or hardware upgrades. seosiri-biorobotics provides a unified, open-source translation layer to resolve this, built on the Model Context Protocol (MCP).
The Integration Gap in Modern Lab Automation & Prosthetics
In standard laboratory automation, development is siloed. Biologists reference genomic databases like UniProt's REST API, while mechanical engineers program robotics using proprietary, vendor-locked scripting languages. Swapping a robotic pipette or migrating a database currently requires rewriting a custom software "bridge."
A similar gap exists in assistive bionics. Mapping human electromyography (EMG) signals to prosthetic joint servos usually relies on custom-coded, hardware-specific loops. If a user moves to a different servo motor or microchip, the control logic must be redesigned from scratch. Web-dependent integrations also fail under network latency or regional API restrictions — a delay that's a minor inconvenience in a lab, and a safety hazard in a live prosthetic movement.
Architectural Design: A Decoupled, Local-First Model
The core engine resolves these issues by keeping scientific and physiological intent completely separate from physical execution:
[Bio-Data / EMG Signal] → [Stateless MCP Server] → [Deterministic Math Core] → [G-code Serial Stream]
- Stateless context broker (MCP): exposes six tools over a local-first Python runtime, avoiding IDE proxy lag and regional API restrictions.
- Local caching layer: the server's own tool description states that
fetch_genomic_datagracefully falls back to a local cache when the live UniProt API is offline or restricted, reducing repeat-lookup latency and rate-limit exposure. - Deterministic kinematics: the math core (
core_math.py) converts biological and physiological variables into physical displacements in SI units (meters). - Hardware-agnostic actuation: the physical gateway (
hardware_gateway.py) translates coordinates into standard G-code, per NIST's RS274/NGC specification, compatible with any standard microcontroller running GRBL (e.g., Arduino/ESP32).
Why This Needs to Be Local-First and Decoupled
Reproducibility. Because the math core is stateless and idempotent, identical biological or physiological inputs always produce identical physical coordinates — eliminating hidden state drift between runs.
No vendor lock-in. The engine outputs standard G-code rather than a proprietary format, so it works with stepper motor controllers, custom gantries, and bionic joint servos alike.
Offline autonomy. A local-first design — including compatibility with local models via tools like Ollama — means the system can run without a continuous internet connection or external API keys, which matters for both lab reliability and prosthetic safety.
Who This Engine Is Built For
The global lab automation market is projected to reach $8.62 billion by 2031, with system integration — proprietary hardware and software silos — named as the primary barrier. That's the exact gap this engine targets, and the addition of EMG-to-actuation tooling extends that same problem into assistive prosthetics.
Biotech & Pharma Companies, and CROs
If your organization runs high-throughput screening or manages liquid-handling hardware from more than one vendor, the integration tax is a recurring cost, not a one-time project. This engine reduces a hardware swap or database migration to a configuration change. Its stateless, idempotent design also gives procurement and compliance teams an audit trail where identical inputs guarantee identical physical outputs — directly relevant to GLP/GMP-adjacent reproducibility requirements.
Developers & Open-Source Contributors
This is a small, modular, readable Python codebase with clear separation of concerns — a reasonable reference implementation if you're building your own MCP server for a physical-hardware use case. Issues and pull requests are welcome on the GitHub repository, and the project is listed as an Official server on Glama.ai's MCP directory.
Research Organizations, Universities & Nonprofit Labs, and Assistive-Tech Developers
Research citing Nature found that over 70% of scientists have been unable to replicate a previously published experiment. A deterministic, open-source translation layer directly mitigates that, without licensing fees or vendor dependencies — and the same reasoning now extends to prosthetics research, where the translate_emg_to_actuation tool's built-in safety envelope offers a transparent, auditable starting point rather than a closed-source control loop.
Technical Specifications and Standards
- Communication protocol: Model Context Protocol JSON-RPC over stdio.
- Actuation protocol: Cartesian G-code, per the Milling/Additive Manufacturing standard.
- Coordinate space: SI units (meters), with millimeter-scale conversions for plate-level operations.
- Verification: automated unit testing via pytest, packaged per Python Packaging Authority (PyPA) conventions.
- Containerization: a Dockerfile is included for teams that want an isolated runtime environment.
- Directory sync: a
glama.jsonfile in the repository root drives the automatic Glama.ai listing sync. - Release: tagged
v1.0.0, "Initial Production Release," July 14, 2026. - License: MIT, confirmed on the project's Glama.ai listing.
The Live-Tested 6-Tool Suite
The server currently exposes six MCP tools:
fetch_genomic_data— queries live sequence parameters from the UniProt REST API, with a documented local fallback for offline or rate-limited conditions.resolve_biotech_spatial_intent— translates assay parameters (concentration, plate scale) into immutable spatial metrics in SI base units.map_plate_coordinate— translates standard alphanumeric well IDs into exact millimeter offsets, based on SLAS/SBS plate standards.calculate_pipetting_speed— calibrates G-code feedrate and pressure delay from reagent viscosity and target volume.calculate_dna_melting_temp— calculates GC-content and melting temperature (Tm) of a DNA sequence to recommend thermal deck heating configuration.translate_emg_to_actuation— translates EMG muscle signals (in microvolts) into safe joint angles and G-code velocity profiles for prosthetic actuation, with a built-in safety envelope check.
That test is the clearest demonstration of why this tool exists: the input is a raw physiological signal, and the output is both a physical motion command and an explicit safety classification, computed in the same deterministic pass.
Quickstart
Two ways to try it, no install required to start:
# Option 1: install locally in editable development mode pip install -e . python src/run_experiment.py P42212 # Option 2: test instantly in the browser via Glama's MCP Inspector, # no local install needed — click "Try in Browser" on the listing above
Listed on the Glama.ai MCP Directory
The listing shown at the top of this post carries Official status under the Bioinformatics and Biology & Medicine categories, an MIT License, and A-grade scores across license, quality, and maintenance — and it's directly installable or testable from the listing itself via "Install Server" or "Try in Browser," so evaluating it doesn't require cloning the repository first. We've verified the "Try in Browser" path ourselves directly against the live listing, alongside the tool-level tests above.
Scope and Future Milestones
The core engine is the foundation, not the finished platform. Multi-plate deck mapping, viscosity calibration, DNA thermodynamics, and EMG-to-actuation translation have all shipped ahead of the original roadmap. The remaining development phases include:
- Closed-loop telemetry: parsing real-time coordinate position queries from serial ports to verify physical arrival, rather than trusting the command was executed correctly.
- Capacitive liquid-level detection (LLD): halting probe movement immediately on contact with a liquid surface, to prevent pipette tip damage.
Query Answers
What is the SEOSiri Bio-Robotics Core Engine?
An open-source, stateless MCP server that converts biological data and EMG biosignals into deterministic G-code, so robotic hardware and prosthetic actuators can execute them without custom integration code.
Does it require an internet connection to run?
No. It has a documented local fallback for the genomic data lookup and can run entirely offline, including with local AI models, once initial setup is complete.
What robotic hardware does it work with?
Anything that accepts standard G-code, including Cartesian gantries, stepper motor controllers, bionic joint servos, and open-source microfluidic setups.
Is the project open source?
Yes, fully, under the MIT License, and open to outside contributions via its public GitHub repository.
What does "stateless" mean in this context?
Each request is processed independently with no retained memory between runs, so identical inputs always produce identical physical coordinates — important for scientific reproducibility.
How many tools does the MCP server currently expose?
Six: fetch_genomic_data, resolve_biotech_spatial_intent, map_plate_coordinate, calculate_pipetting_speed, calculate_dna_melting_temp, and translate_emg_to_actuation — all live-tested against the running server.
Can this engine control a prosthetic limb?
It can translate EMG signals into safe joint angles and G-code motion commands with a built-in safety envelope check, which is the translation layer a prosthetic control system needs — it isn't a complete, certified prosthetic control system on its own.
Explore or Contribute to the Project
The project is fully open-source. Explore the codebase, file an issue, or get involved in development directly on GitHub.
View on GitHub ➔ Sponsor the Project
