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
- 01Support Raspberry Pi, Arduino, and NVIDIA Jetson
- 02Connect IoT devices over MQTT, HTTP, and CoAP
- 03Provide Amber B1 and Lucid One robotic-arm plugins
- 04Support IPC, UDP Multicast, WebSocket, and message queues
- 05Provide encryption, key exchange, authentication, and rate limiting
- 06Enable mesh discovery and local LLM bridging
Use cases
- 01Control a robotic arm through an AI agent
- 02Read sensors and operate GPIO
- 03Discover devices and relay commands across a LAN
- 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.
We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.
Tools
Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.
Details
From the project READMERegenNexus UAP
Universal Adapter Protocol - Connect devices, robots, apps, and AI agents with minimal latency and maximum security. MCP-compatible for seamless AI integration.

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
| Transport | Latency | Use Case |
|---|---|---|
| IPC | < 0.1ms | Local processes |
| UDP Multicast | 1-5ms | LAN discovery |
| WebSocket | 10-50ms | Remote/internet |
| Message Queue | Variable | Reliable 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:
- Basic Demo - Core communication
- Security Demo - Encryption & auth
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
- Getting Started
- MCP Integration
- Device Integration
- Robotic Arms Guide
- Security Guide
- API Reference
- ROS Integration
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
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.