mcpField
R
Regennexus Uap

Regennexus Uap

Local
github.com/ReGenNowOther9Updated 41w ago

About Regennexus Uap

RegenNexus UAP is a universal protocol library for connecting devices, robots, apps, and AI agents, with support for multiple hardware types, transports, and mesh networking. It also provides an MCP server and a bridge from local LLMs to hardware.

Key features

  1. 01Support Raspberry Pi, Arduino, and NVIDIA Jetson
  2. 02Connect IoT devices over MQTT, HTTP, and CoAP
  3. 03Provide Amber B1 and Lucid One robotic-arm plugins
  4. 04Support IPC, UDP Multicast, WebSocket, and message queues
  5. 05Provide encryption, key exchange, authentication, and rate limiting
  6. 06Enable mesh discovery and local LLM bridging

Use cases

  1. 01Control a robotic arm through an AI agent
  2. 02Read sensors and operate GPIO
  3. 03Discover devices and relay commands across a LAN
  4. 04Connect Ollama or LM Studio to hardware

MCP support

It can run as an MCP server, providing hardware control and status access to compatible clients, such as moving a robotic arm, operating GPIO, and reading sensors. The README does not enumerate specific MCP tools.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

No install method listed yet

We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.

Repository

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

RegenNexus UAP

Universal Adapter Protocol - Connect devices, robots, apps, and AI agents with minimal latency and maximum security. MCP-compatible for seamless AI integration.

ReGenNexus Logo

Installation

pip install regennexus

Or with all features:

pip install regennexus[full]

Quick Start

import asyncio
from regennexus import RegenNexusProtocol

async def main():
    protocol = RegenNexusProtocol()
    await protocol.initialize()

    # Register entities
    await protocol.registry.register_entity(
        entity_id="sensor_01",
        entity_type="device",
        capabilities=["temperature", "humidity"]
    )

    # Send messages
    await protocol.send_message(
        sender="controller",
        recipient="sensor_01",
        intent="read",
        payload={"sensors": ["temperature"]}
    )

    await protocol.shutdown()

asyncio.run(main())

Features

Device Support
  • Raspberry Pi - GPIO, PWM, camera, sensors
  • Arduino - Digital/analog I/O, serial commands
  • NVIDIA Jetson - GPU, CUDA, camera, inference
  • IoT Devices - MQTT, HTTP, CoAP protocols
Robotic Arms
  • Amber B1 - 7-DOF control, gripper, trajectory
  • Lucid One - Cartesian control, force sensing, teach mode
from regennexus.plugins import get_amber_b1_plugin

AmberB1 = get_amber_b1_plugin()
arm = AmberB1(entity_id="arm_001", mock_mode=True)
await arm.initialize()

# Move joints
await arm.move_to([0, 45, -30, 0, 90, 0, 0], duration=2.0)

# Gripper control
await arm.open_gripper()
await arm.close_gripper(force=15.0)
Transport Layers
TransportLatencyUse Case
IPC< 0.1msLocal processes
UDP Multicast1-5msLAN discovery
WebSocket10-50msRemote/internet
Message QueueVariableReliable delivery
Security
  • Encryption: AES-128/256-GCM
  • Key Exchange: ECDH-384
  • Authentication: Tokens, API keys
  • Rate Limiting: Adaptive throttling
AI Integration (MCP)

Control hardware directly from Claude Desktop or any MCP-compatible AI:

# Start MCP server for Claude Desktop
python -m regennexus.mcp_server

Configure in claude_desktop_config.json:

{
    "mcpServers": {
        "regennexus": {
            "command": "python",
            "args": ["-m", "regennexus.mcp_server"]
        }
    }
}

Now ask Claude:

  • "Move the robot arm to pick position"
  • "Turn on GPIO pin 17"
  • "What's the temperature sensor reading?"
LLM Bridge (Ollama, LM Studio)

Connect local LLMs to hardware:

from regennexus.bridges import LLMBridge, LLMConfig

llm = LLMBridge(LLMConfig(provider="ollama", model="llama3"))
response = await llm.chat("Turn on the lights")
Mesh Networking

Auto-discovery across devices on the network:

from regennexus.core import MeshNetwork, MeshConfig

mesh = MeshNetwork(MeshConfig(
    node_id="controller",
    capabilities=["command"]
))
await mesh.start()

# Devices auto-discovered
for peer in mesh.get_peers():
    print(f"Found: {peer.node_id} ({peer.capabilities})")

Interactive Demos

Try RegenNexus in Google Colab:

CLI Usage

# Start server
regen server --host 0.0.0.0 --port 8080

# Run example
regen run examples/robotic_arms/arm_demo.py

# Version info
regen version

Optional Dependencies

pip install regennexus[api]        # FastAPI server
pip install regennexus[mqtt]       # MQTT support
pip install regennexus[robotics]   # Robotic arms
pip install regennexus[arduino]    # Arduino support
pip install regennexus[dev]        # Development tools

Documentation

Examples

examples/
├── simple_connection/    # Basic protocol usage
├── mcp_integration/      # Claude Desktop & LLM demos
├── mesh_network/         # Device auto-discovery
├── llm_integration/      # Ollama/LM Studio demos
├── robotic_arms/         # Amber B1 & Lucid One demos
├── ros_integration/      # ROS 2 bridge examples
├── security/             # Encryption & auth
└── binder/               # Jupyter notebooks

Docker

docker-compose up

See Docker Deployment for details.

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE for details.


RegenNexus UAP - Connect Everything, Securely.

Copyright (c) 2024-2025 ReGen Designs LLC

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.