Robotics MCP Server

System management portmanteau for Robotics MCP.

PORTMANTEAU PATTERN RATIONALE: Instead of creating 3 separate tools (help, status, list_robots), this tool consolidates related system operations into a single interface. This design:

• Prevents tool explosion (3 tools → 1 tool) while maintaining full functionality

• Improves discoverability by grouping related operations together

• Reduces cognitive load when working with system management tasks

• Enables consistent system interface across all operations

• Follows FastMCP 2.13+ best practices for feature-rich MCP servers

SUPPORTED OPERATIONS:

• help: Get comprehensive help information about the server and its tools

• status: Get server status with connectivity tests and robot counts

• list_robots: List all registered robots with optional filtering

Args: operation: The system operation to perform. MUST be one of: - "help": Get help information (no additional parameters) - "status": Get server status (no additional parameters) - "list_robots": List robots (optional: robot_type, is_virtual filters)

robot_type: Optional filter for list_robots operation.
    Valid values: "scout", "go2", "g1", or any custom robot type.
    If None, returns all robot types.

is_virtual: Optional filter for list_robots operation.
    - True: Only virtual robots (vbots)
    - False: Only physical robots (bots)
    - None: Both virtual and physical robots

Returns: Dictionary containing operation-specific results: - help: Server info, tool list, features, mounted servers - status: Server health, robot counts, connectivity tests, HTTP status - list_robots: Robot list with filtering applied

Examples: Get help information: result = await robotics_system(operation="help")

Get server status:
    result = await robotics_system(operation="status")

List all robots:
    result = await robotics_system(operation="list_robots")

List only Scout robots:
    result = await robotics_system(operation="list_robots", robot_type="scout")

List only virtual robots:
    result = await robotics_system(operation="list_robots", is_virtual=True)

Unified robot control (works for both physical bot and virtual bot).

This portmanteau tool provides a unified interface for controlling both physical robots (via ROS) and virtual robots (via Unity/VRChat). The tool automatically routes commands to the appropriate handler based on robot type.

Args: robot_id: Robot identifier (e.g., "scout_01", "vbot_scout_01"). action: Operation to perform: - "get_status": Get robot status (battery, position, state) - "move": Control movement (linear/angular velocity) - "stop": Emergency stop - "return_to_dock": Return to charging dock (physical bot only) - "stand": Stand up (Unitree G1, physical bot only) - "sit": Sit down (Unitree G1, physical bot only) - "walk": Walking gait (Unitree, physical bot only) - "sync_vbot": Sync virtual bot with physical bot state linear: Linear velocity (m/s) for move action. angular: Angular velocity (rad/s) for move action. duration: Movement duration (seconds). **kwargs: Additional action-specific parameters.

Returns: Dictionary containing operation result.

Examples: Get robot status: result = await robot_control(robot_id="scout_01", action="get_status")

Move robot forward:
    result = await robot_control(
        robot_id="scout_01",
        action="move",
        linear=0.2,
        angular=0.0
    )

Stop robot:
    result = await robot_control(robot_id="scout_01", action="stop")

Robot behavior control portmanteau - Animation, camera, navigation, and manipulation.

PORTMANTEAU PATTERN: Consolidates animation, camera, navigation, and manipulation operations into a single unified tool. This reduces tool explosion while maintaining full functionality across all behavior categories.

CATEGORIES:

• animation: Animation and pose control

• camera: Camera feed and visual control

• navigation: Path planning and navigation

• manipulation: Arm and gripper control

ANIMATION ACTIONS:

• animate_wheels: Rotate wheels during movement (Scout mecanum wheels)

• animate_movement: Play movement animations (walk, turn, etc.)

• set_pose: Set robot pose (sitting, standing, etc. for Unitree)

• play_animation: Play custom animations

• stop_animation: Stop current animation

• get_animation_state: Get current animation state

CAMERA ACTIONS:

• get_camera_feed: Get live camera feed (physical Scout camera)

• get_virtual_camera: Get Unity camera view from robot perspective

• set_camera_angle: Adjust camera angle

• capture_image: Capture still image

• start_streaming: Start video stream

• stop_streaming: Stop video stream

• get_camera_status: Get camera status and settings

NAVIGATION ACTIONS:

• plan_path: Plan path from A to B (A* or RRT)

• follow_path: Execute planned path

• set_waypoint: Set navigation waypoint

• clear_waypoints: Clear waypoint list

• get_path_status: Check path execution status

• avoid_obstacle: Dynamic obstacle avoidance

• get_current_path: Get current path being followed

MANIPULATION ACTIONS:

• move_arm: Move arm to target joint positions or end-effector pose

• set_joint_positions: Set individual joint positions (dict of joint_name: angle)

• set_end_effector_pose: Move end-effector to target pose (position + orientation)

• get_arm_state: Get current arm joint positions and end-effector pose

• open_gripper: Open gripper fully

• close_gripper: Close gripper fully

• set_gripper_position: Set gripper position (0.0 = open, 1.0 = closed)

• get_gripper_state: Get current gripper position and force feedback

• move_to_pose: Move arm to target pose with IK (inverse kinematics)

• home_arm: Return arm to home/rest position

Args: robot_id: Robot identifier (e.g., "scout_01", "vbot_scout_01"). category: Behavior category: "animation", "camera", or "navigation". action: Action to perform (see category-specific actions above). # Animation parameters (used when category="animation") wheel_speeds: Wheel speeds for animate_wheels. animation_name: Animation name for play_animation. pose: Pose name for set_pose. animation_speed: Animation speed multiplier. loop: Whether to loop animation. # Camera parameters (used when category="camera") angle_x: Camera angle X (pitch) in degrees. angle_y: Camera angle Y (yaw) in degrees. output_path: Output file path for capture_image. stream_url: Stream URL for start_streaming. # Navigation parameters (used when category="navigation") start_position: Start position (x, y, z) for plan_path. goal_position: Goal position (x, y, z) for plan_path. waypoint: Waypoint position (x, y, z) for set_waypoint. obstacle_position: Obstacle position (x, y, z) for avoid_obstacle. path_id: Path identifier for follow_path or get_path_status. # Manipulation parameters (used when category="manipulation") joint_positions: Joint positions dict (e.g., {"shoulder": 45.0, "elbow": 90.0}). end_effector_pose: End-effector pose dict with position and orientation. gripper_position: Gripper position (0.0 = open, 1.0 = closed). arm_id: Arm identifier for multi-arm robots (e.g., "left", "right"). force_limit: Maximum force/torque limit for movement. manipulation_speed: Movement speed (0.0-1.0) for arm/gripper motion.

Returns: Dictionary containing operation result.

Examples: # Animation result = await robot_behavior( robot_id="scout_01", category="animation", action="play_animation", animation_name="walk", animation_speed=1.0, loop=True )

# Camera
result = await robot_behavior(
    robot_id="scout_01",
    category="camera",
    action="capture_image",
    output_path="C:/Images/capture.jpg"
)

# Navigation
result = await robot_behavior(
    robot_id="scout_01",
    category="navigation",
    action="plan_path",
    start_position={"x": 0, "y": 0, "z": 0},
    goal_position={"x": 5, "y": 0, "z": 0}
)

# Manipulation - Move arm
result = await robot_behavior(
    robot_id="g1_01",
    category="manipulation",
    action="move_arm",
    joint_positions={"shoulder": 45.0, "elbow": 90.0, "wrist": 0.0}
)

# Manipulation - Open gripper
result = await robot_behavior(
    robot_id="g1_01",
    category="manipulation",
    action="open_gripper"
)

Control and monitor manufacturing equipment (3D printers, CNC, etc.).

This tool provides unified control over manufacturing devices including:

• 3D printers (via OctoPrint, Moonraker, Repetier Server)

• CNC machines

• Laser cutters

Args: device_id: Unique identifier for the manufacturing device device_type: Type of manufacturing equipment category: Operation category (control, monitor, maintenance) action: Specific action to perform file_path: Path to file for printing/cutting temperature: Temperature settings (hotend, bed, chamber) speed: Speed/feed rate settings position: Position coordinates (X, Y, Z) gcode: Raw G-code commands to send monitor_type: What to monitor (status, temperature, progress, webcam) maintenance_action: Maintenance operation to perform

Returns: Operation result with status and data

Virtual robot lifecycle and operations portmanteau.

PORTMANTEAU PATTERN: Consolidates virtual robot CRUD operations and virtual robotics operations into a single unified tool. This reduces tool explosion while maintaining full functionality for virtual robot management.

CRUD OPERATIONS:

• create: Create/spawn and register a new virtual robot

• read: Get details of an existing virtual robot

• update: Modify virtual robot properties (scale, position, metadata, etc.)

• delete: Remove and unregister a virtual robot

• list: List all virtual robots with optional filtering

VIRTUAL ROBOT OPERATIONS:

• spawn: Spawn robot in Unity/VRChat scene (alias for create)

• load_environment: Load Marble/Chisel environment into scene

• get_status: Get virtual robot status

• get_lidar: Get virtual LiDAR scan (Unity physics raycast)

• set_scale: Scale robot size (for size testing)

• test_navigation: Test pathfinding in environment

• sync_with_physical: Sync vbot state with physical bot

Args: operation: Operation to perform (see CRUD and Virtual Robot Operations above). robot_type: Type of robot (required for create/spawn). Examples: "scout", "go2", "g1", "robbie", "custom" robot_id: Virtual robot identifier (required for read, update, delete, get_status, etc.). Auto-generated for create/spawn if not provided. platform: Target platform ("unity" or "vrchat"). Default: "unity". position: Spawn/update position (x, y, z) for create/spawn/update. scale: Size multiplier for create/spawn/update/set_scale. metadata: Additional metadata dictionary for create/update. model_path: Path to 3D model file (.glb, .fbx, .vrm) for custom robot_type. environment: Environment name (Marble-generated) for load_environment. environment_path: Path to environment file for load_environment. project_path: Unity project path (optional, auto-detected if not provided). include_colliders: Whether to import collider meshes (default: True).

Returns: Dictionary containing operation result with robot details.

Examples: # Create a Scout vbot result = await robot_virtual( operation="create", robot_type="scout", platform="unity", position={"x": 0.0, "y": 0.0, "z": 0.0}, scale=1.0 )

# Spawn robot (alias for create)
result = await robot_virtual(
    operation="spawn",
    robot_type="scout",
    platform="unity"
)

# Read vbot details
result = await robot_virtual(
    operation="read",
    robot_id="vbot_scout_01"
)

# Update vbot
result = await robot_virtual(
    operation="update",
    robot_id="vbot_scout_01",
    scale=1.5,
    position={"x": 2.0, "y": 0.0, "z": 2.0}
)

# Load environment
result = await robot_virtual(
    operation="load_environment",
    environment="stroheckgasse_apartment",
    platform="unity"
)

# Get LiDAR scan
result = await robot_virtual(
    operation="get_lidar",
    robot_id="vbot_scout_01"
)

# List all vbots
result = await robot_virtual(operation="list")

Robot model management portmanteau for Robotics MCP.

PORTMANTEAU PATTERN RATIONALE: Instead of creating 4 separate tools (create, import, export, convert), this tool consolidates related model operations into a single interface. This design:

• Prevents tool explosion (4 tools → 1 tool) while maintaining full functionality

• Improves discoverability by grouping related operations together

• Reduces cognitive load when working with robot models

• Enables consistent model interface across all operations

• Follows FastMCP 2.13+ best practices for feature-rich MCP servers

SUPPORTED OPERATIONS:

• create: Create robot 3D model from scratch using Blender MCP

• import: Import robot 3D model into Unity/VRChat/Resonite project

• export: Export robot model from Unity to file format

• convert: Convert robot model between formats

• spz_check: Check .spz conversion tool availability

• spz_convert: Convert .spz file to .ply or other format

• spz_extract: Extract metadata from .spz file

• spz_install: Install Unity Gaussian Splatting plugin (alternative to .spz)

Args: operation: The model operation to perform. MUST be one of: - "create": Create model (requires: robot_type, output_path) - "import": Import model (requires: robot_type, model_path) - "export": Export model (requires: robot_id) - "convert": Convert model (requires: source_path, source_format, target_format)

robot_type: Type of robot (required for create/import).
    Examples: "scout", "go2", "g1", "robbie", "custom"

model_path: Path to model file (required for import).
output_path: Path for output file (required for create, optional for export/convert).
format: Model format (used by create/import/export).
    - "fbx": Industry standard (recommended for robots)
    - "glb": Modern glTF 2.0 format
    - "obj": Simple mesh format
    - "vrm": VRM format (ONLY for humanoid robots)
platform: Target platform for import (unity/vrchat/resonite).
dimensions: Custom dimensions for create (length, width, height in meters).
create_textures: Create textures using gimp-mcp (for create).
texture_style: Texture style for create (realistic/stylized/simple).
robot_id: Virtual robot identifier (required for export).
include_animations: Include animations in export.
project_path: Unity project path (for import).
create_prefab: Create Unity prefab after import.
source_path: Source file path (required for convert).
source_format: Source file format (required for convert).
target_format: Target file format (required for convert).
target_path: Output file path (optional for convert).

Returns: Dictionary containing operation-specific results.

Examples: Create Scout model: result = await robot_model( operation="create", robot_type="scout", output_path="D:/Models/scout_model.fbx", format="fbx" )

Import model to Unity:
    result = await robot_model(
        operation="import",
        robot_type="scout",
        model_path="D:/Models/scout_model.fbx",
        platform="unity"
    )

Export robot from Unity:
    result = await robot_model(
        operation="export",
        robot_id="vbot_scout_01",
        format="fbx"
    )

Convert FBX to GLB:
    result = await robot_model(
        operation="convert",
        source_path="D:/Models/scout.fbx",
        source_format="fbx",
        target_format="glb"
    )

CRUD operations for virtual robots (vbots).

This tool provides complete lifecycle management for virtual robots:

• Create: Spawn and register a new virtual robot

• Read: Get details of an existing virtual robot

• Update: Modify virtual robot properties (scale, position, metadata, etc.)

• Delete: Remove and unregister a virtual robot

• List: List all virtual robots with optional filtering

Supported robot types:

• "scout": Moorebot Scout (mecanum wheels, indoor)

• "scout_e": Moorebot Scout E (tracked, waterproof, outdoor)

• "go2": Unitree Go2 (quadruped)

• "g1": Unitree G1 (humanoid with arms)

• "robbie": Robbie from Forbidden Planet (classic sci-fi robot)

• "custom": Custom robot type (requires model_path)

Args: operation: CRUD operation to perform: - "create": Create/spawn a new virtual robot - "read": Read/get details of an existing virtual robot - "update": Update properties of an existing virtual robot - "delete": Delete/remove a virtual robot - "list": List all virtual robots (optionally filtered) robot_type: Type of robot (required for "create", optional for "list"). Must be one of: "scout", "scout_e", "go2", "g1", "robbie", "custom". robot_id: Virtual robot identifier (required for "read", "update", "delete"). Auto-generated for "create" if not provided. platform: Target platform ("unity" or "vrchat"). Default: "unity". position: Spawn/update position (x, y, z) for "create" or "update". scale: Size multiplier for "create" or "update" (e.g., 1.0 = original size). metadata: Additional metadata dictionary for "create" or "update". model_path: Path to 3D model file (.glb, .fbx, .vrm) for "create" with "custom" robot_type.

Returns: Dictionary containing operation result with robot details.

Examples: Create a Scout vbot: result = await vbot_crud( operation="create", robot_type="scout", platform="unity", position={"x": 0.0, "y": 0.0, "z": 0.0}, scale=1.0 )

Create Robbie from Forbidden Planet:
    result = await vbot_crud(
        operation="create",
        robot_type="robbie",
        platform="unity",
        position={"x": 1.0, "y": 0.0, "z": 1.0},
        scale=1.0
    )

Read vbot details:
    result = await vbot_crud(
        operation="read",
        robot_id="vbot_scout_01"
    )

Update vbot scale and position:
    result = await vbot_crud(
        operation="update",
        robot_id="vbot_scout_01",
        scale=1.5,
        position={"x": 2.0, "y": 0.0, "z": 2.0}
    )

Delete a vbot:
    result = await vbot_crud(
        operation="delete",
        robot_id="vbot_scout_01"
    )

List all vbots:
    result = await vbot_crud(operation="list")

List only Scout vbots:
    result = await vbot_crud(
        operation="list",
        robot_type="scout"
    )

Comprehensive workflow management operations.

OPERATIONS:

• create: Create new workflow (requires workflow_data)

• read: Get workflow details (requires workflow_id)

• update: Update workflow (requires workflow_id, workflow_data)

• delete: Delete workflow (requires workflow_id)

• list: List all workflows (filterable by category, tags, search)

• execute: Execute workflow (requires workflow_id, variables)

• status: Get execution status (requires execution_id)

• templates: List available workflow templates

• import: Import workflow from JSON (requires workflow_data)

• export: Export workflow to JSON (requires workflow_id)

Args: operation: Operation to perform workflow_id: Workflow identifier workflow_data: Workflow definition (for create/update/import) variables: Variables for workflow execution execution_id: Execution identifier (for status operations) category: Filter by category (for list operation) tags: Filter by tags (for list operation) search: Search query (for list operation)

Returns: Operation-specific result with workflow data or execution status

Examples: # Create workflow workflow_management( operation="create", workflow_data={ "name": "VRoid to VRChat", "category": "avatar", "steps": [...] } )

# List workflows
workflow_management(operation="list", category="avatar")

# Execute workflow
workflow_management(
    operation="execute",
    workflow_id="workflow-123",
    variables={"vroid_file_path": "/path/to/vroid.vroid"}
)

# Get execution status
workflow_management(operation="status", execution_id="exec-456")