Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| robotics_system | 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:
SUPPORTED OPERATIONS:
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) |
| robot_control | 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") |
| virtual_robotics | Virtual robot control (Unity/VRChat) using existing MCP servers. This portmanteau tool provides comprehensive virtual robot operations, leveraging unity3d-mcp, vrchat-mcp, and avatar-mcp for scene control, movement, and environment management. Args: robot_type: Robot model (e.g., "scout", "go2", "g1"). action: Operation to perform: - "spawn_robot": Spawn robot in Unity/VRChat scene - "move": Control virtual robot movement - "get_status": Get virtual robot state - "get_lidar": Get virtual LiDAR scan (Unity physics raycast) - "set_scale": Scale robot size (for size testing) - "load_environment": Load Marble/Chisel environment - "test_navigation": Test pathfinding - "sync_with_physical": Sync vbot state with physical bot robot_id: Robot identifier (auto-generated if not provided). position: Spawn position (x, y, z). scale: Size multiplier (for size testing). environment: Environment name (Marble-generated). platform: Target platform ("unity" or "vrchat"). **kwargs: Additional action-specific parameters. Returns: Dictionary containing operation result. Examples: Spawn Scout in Unity: result = await virtual_robotics( robot_type="scout", action="spawn_robot", platform="unity", position={"x": 0, "y": 0, "z": 0} ) Load Marble environment:
result = await virtual_robotics(
action="load_environment",
environment="stroheckgasse_apartment",
platform="unity"
)
Move virtual robot:
result = await virtual_robotics(
robot_id="vbot_scout_01",
action="move",
linear=0.2,
angular=0.0
) |
| vbot_crud | CRUD operations for virtual robots (vbots). This tool provides complete lifecycle management for virtual robots:
Supported robot types:
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"
) |
| robot_model | 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:
SUPPORTED OPERATIONS:
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"
) |
| robot_animation | Robot animation and behavior control portmanteau. PORTMANTEAU PATTERN: Consolidates animation operations into a single tool. SUPPORTED OPERATIONS:
Args: robot_id: Robot identifier (e.g., "scout_01", "vbot_scout_01"). action: Animation operation to perform. wheel_speeds: Wheel speeds for animate_wheels (front_left, front_right, back_left, back_right). animation_name: Animation name for play_animation (e.g., "walk", "turn", "idle"). pose: Pose name for set_pose (e.g., "sit", "stand", "crouch"). speed: Animation speed multiplier (1.0 = normal speed). loop: Whether to loop animation (for play_animation). Returns: Dictionary containing operation result. Examples: Animate Scout wheels: result = await robot_animation( robot_id="scout_01", action="animate_wheels", wheel_speeds={"front_left": 1.0, "front_right": 1.0, "back_left": 1.0, "back_right": 1.0} ) Play walk animation:
result = await robot_animation(
robot_id="scout_01",
action="play_animation",
animation_name="walk",
speed=1.0,
loop=True
)
Set Unitree pose:
result = await robot_animation(
robot_id="g1_01",
action="set_pose",
pose="sit"
) |
| robot_camera | Robot camera and visual feed control portmanteau. PORTMANTEAU PATTERN: Consolidates camera operations into a single tool. SUPPORTED OPERATIONS:
Args: robot_id: Robot identifier (e.g., "scout_01", "vbot_scout_01"). action: Camera operation to perform. angle_x: Camera angle X (pitch) in degrees for set_camera_angle. angle_y: Camera angle Y (yaw) in degrees for set_camera_angle. output_path: Output file path for capture_image. stream_url: Stream URL for start_streaming. Returns: Dictionary containing operation result with image data or stream info. Examples: Get camera feed: result = await robot_camera(robot_id="scout_01", action="get_camera_feed") Capture image:
result = await robot_camera(
robot_id="scout_01",
action="capture_image",
output_path="C:/Images/scout_capture.jpg"
)
Set camera angle:
result = await robot_camera(
robot_id="scout_01",
action="set_camera_angle",
angle_x=10.0,
angle_y=0.0
) |
| robot_navigation | Robot navigation and path planning portmanteau. PORTMANTEAU PATTERN: Consolidates navigation operations into a single tool. SUPPORTED OPERATIONS:
Args: robot_id: Robot identifier (e.g., "scout_01", "vbot_scout_01"). action: Navigation operation to perform. 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. Returns: Dictionary containing operation result with path data or status. Examples: Plan path: result = await robot_navigation( robot_id="scout_01", action="plan_path", start_position={"x": 0, "y": 0, "z": 0}, goal_position={"x": 5, "y": 0, "z": 0} ) Follow path:
result = await robot_navigation(
robot_id="scout_01",
action="follow_path",
path_id="path_123"
)
Set waypoint:
result = await robot_navigation(
robot_id="scout_01",
action="set_waypoint",
waypoint={"x": 2, "y": 0, "z": 0}
) |
| spz_converter | SPZ file converter and Unity package installer. PORTMANTEAU PATTERN: Consolidates .spz handling operations. SUPPORTED OPERATIONS:
NOTE: .spz is Adobe's compressed format. There is NO official Unity plugin. This tool provides conversion options and workarounds. Args: operation: Operation to perform: - "check_spz_support": Check available conversion tools - "convert_spz": Convert .spz to .ply/.splat - "install_unity_spz_plugin": Attempt to install Unity support (may not exist) - "extract_spz_info": Get metadata from .spz file spz_path: Path to .spz file (required for convert/extract operations). output_path: Output file path (optional, auto-generated if not provided). output_format: Output format - "ply" (default) or "splat". unity_project_path: Unity project path for plugin installation. Returns: Dictionary containing operation result. Examples: Check support: result = await spz_converter(operation="check_spz_support") Convert .spz to .ply:
result = await spz_converter(
operation="convert_spz",
spz_path="C:/Downloads/file.spz",
output_path="C:/Output/file.ply",
output_format="ply"
)
Install Unity plugin (if available):
result = await spz_converter(
operation="install_unity_spz_plugin",
unity_project_path="C:/Users/sandr/My project"
) |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |