### Example AI Client Prompts

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

These are example prompts you can send to the MCP server to generate game assets or environments. They demonstrate the type of commands the server can interpret.

```bash
> "Create a medieval castle with towers and walls"
> "Generate a town square with fountain and buildings"
> "Make a challenging maze for players to solve"
```

--------------------------------

### Install Plugin for All Projects

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Install the MCP plugin globally for all Unreal Engine projects by copying it to the Engine's plugin directory. Ensure you have the necessary permissions.

```bash
cp -r UnrealMCP/ "C:/Program Files/Epic Games/UE_5.5/Engine/Plugins/"

# Edit → Plugins → Search "UnrealMCP" → Enable
```

--------------------------------

### Construct a Cozy Cottage

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `construct_house` to build realistic houses. This example builds a cozy cottage at a specified location.

```bash
# Cozy cottage  
construct_house(house_style="cottage", location=[-1000, 1000, 0])
```

--------------------------------

### Construct House Example Usage

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Python/README_advanced.md

Demonstrates how to use the `construct_house` function with different styles and locations. Ensure the `construct_house` function is available in your environment.

```python
construct_house(house_style="modern")

construct_house(location=[1000, 0, 0], house_style="cottage")

construct_house(width=1500, depth=1200, house_style="mansion")
```

--------------------------------

### Launch the MCP Server

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Start the local MCP server by navigating to the Python directory and running the specified Python script using 'uv'.

```bash
cd Python
uv run unreal_mcp_server_advanced.py
```

--------------------------------

### Clone and Open Pre-Built Project

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Use this option for a quick start by cloning the repository and opening the provided Unreal Engine project. The plugin is pre-installed and enabled.

```bash
git clone https://github.com/flopperam/unreal-engine-mcp.git
cd unreal-engine-mcp

# Open FlopperamUnrealMCP/FlopperamUnrealMCP.uproject
# The plugin is already installed and enabled
```

--------------------------------

### Construct a Modern Family House

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `construct_house` to build realistic houses. This example creates a modern family home at the origin.

```bash
# Modern family home
construct_house(house_style="modern", location=[0, 0, 0])
```

--------------------------------

### Multi-AI City Building Challenge Setup

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Sets up two AI agents to build competing cities in designated zones. Each agent uses specific commands for city creation and landmark addition.

```bash
LLM Agent 1 (West Team) Instructions:
> *"🏗️ CITY BUILDER CHALLENGE! You're building in the WEST zone. Create the most spectacular city to win using:"
> 
> `create_town(town_size="metropolis", architectural_style="futuristic", building_density=0.9, location=[-3000, 0, 0])`
> 
> *"Add landmarks with create_tower() and create_arch() to make your city unique!"

LLM Agent 2 (East Team) Instructions:  
> *"🏙️ CITY BUILDER SHOWDOWN! You're building in the EAST zone. Create an amazing city that beats the competition using:"
> 
> `create_town(town_size="metropolis", architectural_style="downtown", building_density=0.8, location=[3000, 0, 0])`
> 
> *"Use construct_house() for custom districts and create_maze() for parks!"*
```

--------------------------------

### Construct a Large Mansion

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `construct_house` to build realistic houses. This example constructs a large mansion with specified dimensions.

```bash
# Large mansion
construct_house(width=1500, depth=1200, house_style="mansion", location=[2000, 0, 0])
```

--------------------------------

### Complete Example: Blue Cube

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

A sequence of MCP commands to create, configure, and compile a Blueprint for a blue cube actor. Spawning is implied but not shown in this snippet.

```bash
# Create Blueprint
create_blueprint(name="BP_BlueBox", parent_class="Actor")

# Add mesh component
add_component_to_blueprint(
    blueprint_name="BP_BlueBox",
    component_name="BoxMesh",
    component_type="StaticMeshComponent"
)

# Set cube geometry  
set_static_mesh_properties(
    blueprint_name="BP_BlueBox",
    component_name="BoxMesh",
    static_mesh="/Engine/BasicShapes/Cube.Cube"
)

```

--------------------------------

### Traffic Light System Setup

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

This bash snippet outlines the creation of spheres for a traffic light system, indicating their color and relative vertical position.

```bash
# Red light (top)
# ... create red sphere at [0, 0, 400]

# Yellow light (middle)  
# ... create yellow sphere at [0, 0, 200]

# Green light (bottom)
# ... create green sphere at [0, 0, 0]
```

--------------------------------

### Create a Cylindrical Tower

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `create_tower` to build architectural towers. This example creates a 15-level cylindrical tower.

```bash
create_tower(height=15, base_size=6, tower_style="cylindrical", location=[1000, 0, 0])
```

--------------------------------

### Complete Example: Red Sphere

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

A full sequence of MCP commands to create, configure, compile, and spawn a red sphere actor in Unreal Engine.

```bash
# Create Blueprint
create_blueprint(name="BP_RedBall", parent_class="Actor")

# Add mesh component
add_component_to_blueprint(
    blueprint_name="BP_RedBall",
    component_name="BallMesh", 
    component_type="StaticMeshComponent"
)

# Set sphere geometry
set_static_mesh_properties(
    blueprint_name="BP_RedBall",
    component_name="BallMesh",
    static_mesh="/Engine/BasicShapes/Sphere.Sphere"
)

# Apply red color (BaseColor parameter)
set_mesh_material_color(
    blueprint_name="BP_RedBall",
    component_name="BallMesh", 
    color=[1.0, 0.0, 0.0, 1.0],
    material_path="/Engine/BasicShapes/BasicShapeMaterial",
    parameter_name="BaseColor"
)

# Apply red color (Color parameter backup)
set_mesh_material_color(
    blueprint_name="BP_RedBall",
    component_name="BallMesh",
    color=[1.0, 0.0, 0.0, 1.0], 
    material_path="/Engine/BasicShapes/BasicShapeMaterial",
    parameter_name="Color"
)

# Compile Blueprint
compile_blueprint(blueprint_name="BP_RedBall")

# Spawn the red ball
spawn_blueprint_actor(
    actor_name="RedBallInstance",
    blueprint_name="BP_RedBall",
    location=[0, 0, 200]
)
```

--------------------------------

### Orient: Get Blueprint Overview

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Use `bp_brief` for a compact overview of a blueprint's structure. `bp_inspect` provides more detailed, targeted queries on blueprint elements.

```text
bp_brief(blueprint_path)
```

```text
bp_inspect({queries: [...]})
```

```text
bp_export(blueprint_path)
```

```text
search_assets
```

--------------------------------

### Check MCP Installation Status

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/DEBUGGING.md

Verify that the MCP package has been successfully installed in your Python environment. This command imports the mcp module and prints a success message if the import works.

```bash
python -c "import mcp; print('MCP installed successfully')"
```

--------------------------------

### Generate a Large Maze

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `create_maze` to generate solvable mazes. This example creates a 12x12 maze with 4-block high walls and 250cm cells.

```bash
create_maze(rows=12, cols=12, wall_height=4, cell_size=250, location=[0, 0, 0])
```

--------------------------------

### Upgrade Pip for MCP Installation

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/DEBUGGING.md

Upgrade your pip package installer if you encounter issues during the MCP package installation. This ensures you have the latest version of pip, which may resolve compatibility problems.

```bash
C:\\Python311\\python.exe -m pip install --upgrade pip
```

--------------------------------

### Install MCP Python Module

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/DEBUGGING.md

Install the MCP package into your Python environment to resolve 'ModuleNotFoundError'. Use the specific Python executable path if multiple versions are present.

```bash
C:\\Python311\\python.exe -m pip install mcp
```

```bash
python -m pip install mcp
```

--------------------------------

### Create Property Development Showcase

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Showcase a property development with different housing options, including luxury, family, and starter homes.

```bash
# Luxury Section
1. construct_house(house_style="mansion", width=1500, depth=1200, location=[0, 0, 0])
2. create_arch(radius=250, segments=8, location=[0, 800, 0])  # Grand entrance

# Family Section  
3. construct_house(house_style="modern", location=[1000, 0, 0])
4. construct_house(house_style="modern", location=[1000, 600, 0])

# Starter Homes Section
5. construct_house(house_style="cottage", location=[2000, 0, 0])
6. construct_house(house_style="cottage", location=[2000, 400, 0])
7. construct_house(house_style="cottage", location=[2400, 200, 0])
```

--------------------------------

### Create Counter Blueprint Workflow

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Demonstrates the steps to create a Blueprint that increments and displays a counter. Includes variable creation, node addition, and execution flow connection.

```bash
# Step 1: Create variable
> "Create an integer variable called Counter in BP_Counter"
→ create_variable("BP_Counter", "Counter", "int", default_value=0, is_public=true)

# Step 2: Add BeginPlay event
> "Add BeginPlay event to BP_Counter"
→ add_node("BP_Counter", "Event", event_type="BeginPlay", pos_x=0, pos_y=0)

# Step 3: Add Variable Get node
> "Add a node to get the Counter variable in BP_Counter"
→ add_node("BP_Counter", "VariableGet", variable_name="Counter", pos_x=300, pos_y=0)

# Step 4: Add Print node
> "Add a Print node to display the counter value"
→ add_node("BP_Counter", "Print", message="Counter: ", pos_x=600, pos_y=0)

# Step 5: Connect execution flow
> "Connect BeginPlay to the Print node"
→ connect_nodes("BP_Counter", "K2Node_Event_0", "then", "K2Node_CallFunction_2", "execute")
```

--------------------------------

### Configure VS Code/Copilot for Hosted Flop MCP

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

Place this JSON configuration in your .vscode/mcp.json file to enable connection to the Flopperam MCP server. Remember to substitute YOUR_API_KEY with your personal API key.

```json
{
  "servers": {
    "flopperam-unreal": {
      "type": "http",
      "url": "https://agent.flopperam.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

--------------------------------

### Add a Get Variable node

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Adds a VariableGet node to a Blueprint to read the value of an existing variable. Ensure the variable exists in the Blueprint.

```bash
> "Add a Get Variable node for 'Speed' to BP_MyActor"
→ add_node("BP_MyActor", "VariableGet", variable_name="Speed", pos_x=200, pos_y=100)
```

--------------------------------

### Configure Cursor IDE for Hosted Flop MCP

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

Add this configuration to your project's .cursor/mcp.json or global ~/.cursor/mcp.json file to connect Cursor to the Flopperam MCP server. Replace YOUR_API_KEY with your actual API key.

```json
{
  "mcpServers": {
    "flopperam-unreal": {
      "url": "https://agent.flopperam.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

--------------------------------

### Create Material

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/material-vfx/SKILL.md

Use this command to create a new base material asset. Ensure the material path is correctly specified.

```python
material_edit(operation="create_material", material_path="/Game/Materials/M_MyMaterial")
```

--------------------------------

### Create Downtown District with Skyscrapers

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generates a large downtown area with high building density and adds specific landmark towers. Adjust density and tower parameters for desired urban look.

```bash
1. create_town(town_size="large", architectural_style="downtown", building_density=0.9, location=[0, 0, 0])
2. create_tower(height=20, base_size=4, tower_style="square", location=[500, 500, 0])  # Landmark tower
3. create_tower(height=15, base_size=3, tower_style="square", location=[-400, 600, 0]) # Additional skyscraper
```

--------------------------------

### Create Physics Playground with Ramp

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Sets up a physics area with a pyramid and a ramp for balls to knock it down. The ramp's orientation and length can be adjusted for different launch dynamics.

```bash
1. create_pyramid(base_size=4, block_size=100, location=[0, 0, 0])
5. create_wall(length=3, height=1, orientation="x", location=[-700, 0, 0])  # Launch ramp
```

--------------------------------

### Hosted Flop MCP Architecture

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

Diagram illustrating the architecture of the hosted Flop MCP, showing the flow from AI clients to the Flop MCP server and then to the FlopAI Plugin within Unreal Engine.

```mermaid
graph TB
    A[AI Client<br/>Cursor / Claude Code / Windsurf / Cline] -->|MCP Protocol<br/>Streamable HTTP| B[Flop MCP Server<br/>agent.flopperam.com/mcp]
    B -->|WebSocket| C[FlopAI Plugin<br/>C++ / Python Bridge]
    C -->|Native API| D[Unreal Engine 5.5+
Editor & Runtime]
    
    B --> E[50+ Tools]
    E --> F[Blueprint Authoring]
    E --> G[Scene & Level]
    E --> H[Materials & VFX]
    E --> I[Animation & AI]
    E --> J[Landscape & Foliage]
    E --> K[Cinematics & Audio]
```

--------------------------------

### Create and Configure Green Cylinder

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Creates a green cylinder blueprint, adds a static mesh component, sets its properties, applies green color to material parameters, compiles, and spawns it. Ensure correct component types and material paths.

```bash
# Create and configure green cylinder
create_blueprint(name="BP_GreenCylinder", parent_class="Actor")

add_component_to_blueprint(
    blueprint_name="BP_GreenCylinder",
    component_name="CylinderMesh",
    component_type="StaticMeshComponent"
)

set_static_mesh_properties(
    blueprint_name="BP_GreenCylinder", 
    component_name="CylinderMesh",
    static_mesh="/Engine/BasicShapes/Cylinder.Cylinder"
)

# Green color application
set_mesh_material_color(
    blueprint_name="BP_GreenCylinder",
    component_name="CylinderMesh",
    color=[0.0, 1.0, 0.0, 1.0],
    material_path="/Engine/BasicShapes/BasicShapeMaterial",
    parameter_name="BaseColor"
)

set_mesh_material_color(
    blueprint_name="BP_GreenCylinder",
    component_name="CylinderMesh", 
    color=[0.0, 1.0, 0.0, 1.0],
    material_path="/Engine/BasicShapes/BasicShapeMaterial",
    parameter_name="Color" 
)

compile_blueprint(blueprint_name="BP_GreenCylinder")
spawn_blueprint_actor(
    actor_name="GreenCylinderInstance",
    blueprint_name="BP_GreenCylinder",
    location=[-300, 0, 200]
)
```

--------------------------------

### Create a New Blueprint

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Creates a new Blueprint asset in the project. Specify the desired Blueprint name and its parent class.

```bash
> "Create a new Blueprint called BP_HelloWorld"
→ create_blueprint("BP_HelloWorld", "Actor")
```

--------------------------------

### Create Medieval Architectural Elements

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate medieval architectural elements like houses and walls.

```bash
3. construct_house(house_style="cottage", location=[-200, 0, 0])
4. create_wall(length=5, height=3, orientation="x", location=[-300, 200, 0])
```

--------------------------------

### MCP Server Configuration for AI Clients

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Configure your AI client (Cursor, Claude Desktop, or Windsurf) to connect to the local MCP server by adding the provided JSON configuration to its settings file. Ensure the 'command' and 'args' correctly point to your 'uv' executable and server script.

```json
{
  "mcpServers": {
    "unrealMCP": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/unreal-engine-mcp/Python",
        "run",
        "unreal_mcp_server_advanced.py"
      ]
    }
  }
}
```

--------------------------------

### Create Futuristic Architectural Elements

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate futuristic architectural elements like towns.

```bash
7. create_town(town_size="small", architectural_style="futuristic", location=[1200, 0, 0])
```

--------------------------------

### Blueprint Authoring Cycle Overview

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

This represents the general workflow for blueprint authoring, showing the sequence of operations from orientation to verification. Some steps can be skipped for trivial edits.

```text
orient (bp_brief / bp_inspect) → probe (bp_dry_run) → create (bp_create) → author (narrow writes) → commit (bp_commit) → verify (bp_inspect / pie_test_bp)
```

--------------------------------

### Create Fantasy Village

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Build a magical fantasy village with mystical elements using various MCP tools.

```bash
1. construct_house(house_style="cottage", location=[0, 0, 0])       # Wizard's cottage
2. construct_house(house_style="cottage", location=[400, 300, 0])   # Villager house 1  
3. construct_house(house_style="cottage", location=[-300, 400, 0])  # Villager house 2
4. create_tower(height=15, base_size=2, tower_style="tapered", location=[200, -200, 0])  # Wizard tower
5. create_arch(radius=200, segments=8, location=[0, 500, 0])        # Mystical portal
6. create_maze(rows=6, cols=6, wall_height=2, location=[-600, 0, 0]) # Enchanted hedge maze
```

--------------------------------

### Create Blueprint Asset

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Commands for creating new blueprint assets. `bp_create` supports creation from a parent class, baking an existing actor, or creating interface/enum/struct types.

```text
bp_create(op=from_parent, blueprint_path, parent_class, components?, variables?, interfaces?)
```

```text
bp_create(op=from_actor, actor_label, package_path, name)
```

```text
bp_create(op=interface|enum|struct)
```

--------------------------------

### Probe: Static Validation with bp_dry_run

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Use `bp_dry_run` for pre-apply validation. `check_intent` catches basic errors, while `check_spec` runs the composer's full dry-run.

```text
bp_dry_run(op=check_intent, intent=[...])
```

```text
bp_dry_run(op=check_spec, blueprint_path, spec_json)
```

--------------------------------

### Construct Modern House with Garden Spheres

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generates a modern house and adds decorative spheres to a garden area. Ensure the house dimensions and sphere locations are suitable for the scene.

```bash
1. construct_house(house_style="modern", width=1200, depth=800, location=[0, 0, 0])
2. create_pyramid(base_size=2, block_size=50, location=[800, 400, 0])  # Garden feature
3. spawn_physics_blueprint_actor (name="GardenSphere1", mesh_path="/Engine/BasicShapes/Sphere.Sphere", location=[600, 200, 50])
4. spawn_physics_blueprint_actor (name="GardenSphere2", mesh_path="/Engine/BasicShapes/Sphere.Sphere", location=[700, 300, 50])
```

--------------------------------

### Create Seasonal Versions of a Location (Spring)

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate a spring version of a location, including a house and foliage.

```bash
construct_house(house_style="cottage", location=[0, 0, 0])
# Add green spheres as "foliage"
spawn_physics_blueprint_actor (name="Tree1", mesh_path="/Engine/BasicShapes/Sphere.Sphere", location=[300, 300, 100])
spawn_physics_blueprint_actor (name="Tree2", mesh_path="/Engine/BasicShapes/Sphere.Sphere", location=[-200, 400, 100])
```

--------------------------------

### Open-Source Local MCP Architecture

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

Diagram illustrating the architecture of the open-source local Flop MCP, detailing the connection between AI clients, a Python server, and the UnrealMCP Plugin within Unreal Engine.

```mermaid
graph TB
    A[AI Client<br/>Cursor / Claude / Windsurf] -->|MCP Protocol<br/>stdio| B[Python Server<br/>unreal_mcp_server_advanced.py]
    B -->|TCP Socket| C[UnrealMCP Plugin<br/>C++]
    C -->|Native API| D[Unreal Engine 5.5+
Editor]
    
    B --> E[Tools]
    E --> F[World Building]
    E --> G[Physics & Materials]
    E --> H[Blueprint System]
    E --> I[Actor Management]
```

--------------------------------

### Create Modern Architectural Elements

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate modern architectural elements like houses and towers.

```bash
5. construct_house(house_style="modern", location=[400, 0, 0])  
6. create_tower(height=12, base_size=3, tower_style="square", location=[600, 0, 0])
```

--------------------------------

### Verify Blueprint Integrity

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Verify blueprints using `bp_brief` or `bp_inspect` for structural checks. Use `pie_test_bp` for runtime behavioral verification, as compile-clean blueprints can still have runtime bugs.

```text
bp_brief
```

```text
bp_inspect
```

```text
pie_test_bp
```

--------------------------------

### Configure Cline/Local LLMs for Hosted Flop MCP

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

This JSON configuration is for Cline or other local LLM clients (like Ollama, LM Studio) to connect to the Flopperam MCP server. Replace YOUR_API_KEY with your provided API key.

```json
{
  "mcpServers": {
    "flopperam-unreal": {
      "type": "streamableHttp",
      "url": "https://agent.flopperam.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

--------------------------------

### Build Medieval Castle Complex

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Constructs a medieval castle with a main keep, defensive walls, and cylindrical towers. Adjust wall and tower parameters for desired scale and appearance.

```bash
1. construct_house(house_style="mansion", width=1000, depth=1000, location=[0, 0, 0])  # Main keep
2. create_tower(height=12, base_size=3, tower_style="cylindrical", location=[-600, -600, 0])  # Corner tower
3. create_tower(height=12, base_size=3, tower_style="cylindrical", location=[600, -600, 0])   # Corner tower  
4. create_wall(length=12, height=4, orientation="x", location=[-600, -800, 0])  # North wall
5. create_wall(length=12, height=4, orientation="y", location=[-800, -600, 0])  # West wall
6. create_arch(radius=200, segments=8, location=[0, -800, 0])  # Grand entrance
```

--------------------------------

### Run Advanced MCP Server

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Python/README_advanced.md

Command to execute the streamlined Unreal MCP server. This script provides access to the advanced composition and building tools.

```bash
python unreal_mcp_server_advanced.py
```

--------------------------------

### Create Multiple Colored Spheres

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Creates a generic sphere blueprint and then iterates through a list of colors and locations to spawn multiple instances with different colors. Ensure the base blueprint is created and compiled before spawning instances.

```bash
# Create base Blueprint once
create_blueprint(name="BP_GenericSphere", parent_class="Actor")
add_component_to_blueprint(
    blueprint_name="BP_GenericSphere",
    component_name="SphereMesh",
    component_type="StaticMeshComponent"
)
set_static_mesh_properties(
    blueprint_name="BP_GenericSphere",
    component_name="SphereMesh", 
    static_mesh="/Engine/BasicShapes/Sphere.Sphere"
)

# Apply different colors and spawn multiple instances
colors = [
    ([1.0, 0.0, 0.0, 1.0], [0, 0, 200]),      # Red at origin
    ([0.0, 1.0, 0.0, 1.0], [300, 0, 200]),    # Green to the right
    ([0.0, 0.0, 1.0, 1.0], [600, 0, 200]),    # Blue further right
]

for i, (color, location) in enumerate(colors):
    # Set color for this instance
    set_mesh_material_color(
        blueprint_name="BP_GenericSphere",
        component_name="SphereMesh",
        color=color,
        material_path="/Engine/BasicShapes/BasicShapeMaterial",
        parameter_name="BaseColor"
    )
    
    compile_blueprint(blueprint_name="BP_GenericSphere") 
    
    spawn_blueprint_actor(
        actor_name=f"Sphere_{i}",
        blueprint_name="BP_GenericSphere",
        location=location
    )
```

--------------------------------

### Compile and Spawn Blue Box

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Compiles the blueprint for the blue box and spawns an instance of it in the scene at a specified location. Ensure the blueprint is compiled before spawning.

```bash
compile_blueprint(blueprint_name="BP_BlueBox")
spawn_blueprint_actor(
    actor_name="BlueBoxInstance",
    blueprint_name="BP_BlueBox",
    location=[300, 0, 200]
)
```

--------------------------------

### Create Seasonal Versions of a Location (Winter)

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate a winter version of a location, including a house and snow blocks.

```bash
construct_house(house_style="cottage", location=[0, 0, 0])  
# Add white cubes as "snow blocks"
spawn_actor(name="Snow1", type="StaticMeshActor", location=[100, 100, 25])
spawn_actor(name="Snow2", type="StaticMeshActor", location=[200, 150, 25])
```

--------------------------------

### Create Ancient/Classical Architectural Elements

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate ancient or classical architectural elements like arches and towers.

```bash
1. create_arch(radius=300, segments=10, location=[-1000, 0, 0])
2. create_tower(height=8, base_size=4, tower_style="cylindrical", location=[-800, 0, 0])
```

--------------------------------

### Create a Medium Modern Town

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Use `create_town` to generate urban environments. Specify town size, architectural style, building density, and location.

```bash
create_town(town_size="medium", architectural_style="modern", building_density=0.8, location=[0, 0, 0])
```

--------------------------------

### Configure Claude Desktop for MCP Server

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/DEBUGGING.md

Create or update the claude_desktop_config.json file to specify the MCP server command and arguments. Ensure the path to the server script is correct for your system.

```json
{
  "mcpServers": {
    "unreal-advanced": {
      "command": "python",
      "args": [
        "C:\\Path\\To\\Your\\unreal-engine-mcp\\Python\\unreal_mcp_server_advanced.py"
      ]
    }
  }
}
```

--------------------------------

### Configure Claude Code for Hosted Flop MCP

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/README.md

Use this command in your terminal to add the Flopperam MCP server configuration to Claude Code. Ensure you replace YOUR_API_KEY with your actual API key.

```bash
claude mcp add -H "Authorization: Bearer YOUR_API_KEY" --transport http flopperam-unreal https://agent.flopperam.com/mcp
```

--------------------------------

### construct_house

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Build realistic multi-room houses with architectural details.

```APIDOC
## construct_house

### Description
Build realistic multi-room houses with architectural details.

### Parameters
#### Path Parameters
- `width` (int): House width in centimeters (default: 1200)
- `depth` (int): House depth in centimeters (default: 1000)
- `height` (int): Wall height in centimeters (default: 600)
- `location` (array): House center position
- `house_style` (string): "modern", "cottage", or "mansion"
- `mesh` (string): Static mesh asset path
- `name_prefix` (string): Prefix for house components

### Features
- Foundation & Floor: Proper structural base
- Room Division: Interior walls creating realistic spaces
- Windows & Doors: Authentic openings with proper sizing
- Pitched Roof: Angled rooftop instead of flat surface
- Style Variations: Different proportions and decorative elements

### Request Example
```bash
# Modern family home
construct_house(house_style="modern", location=[0, 0, 0])

# Large mansion
construct_house(width=1500, depth=1200, house_style="mansion", location=[2000, 0, 0])

# Cozy cottage  
construct_house(house_style="cottage", location=[-1000, 1000, 0])
```
```

--------------------------------

### Configure Enhanced Input with bp_input

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Use `bp_input` to create Input Actions, Input Modifier Composite, key mappings, modifiers, and triggers in a single call.

```text
bp_input({actions: [...], bindings: [...], bind?: {...}})
```

--------------------------------

### Create Blueprint Class

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Creates a new Blueprint class, typically an Actor, to serve as a base for custom objects.

```bash
create_blueprint(name="BP_ColoredSphere", parent_class="Actor")
```

--------------------------------

### Add Plugin to Existing Project

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Integrate the MCP plugin into your current Unreal Engine project by copying the plugin files and enabling it within the Unreal Editor.

```bash
cp -r UnrealMCP/ YourProject/Plugins/

# Enable in Unreal Editor
# Edit → Plugins → Search "UnrealMCP" → Enable → Restart Editor
```

--------------------------------

### Create and Connect Nodes

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Store node IDs returned from add_node() to establish connections between nodes. This is a good practice for managing node relationships.

```python
# Good practice: Store node IDs
event_node = add_node("BP_MyActor", "Event", event_type="BeginPlay")
print_node = add_node("BP_MyActor", "Print", message="Hello")

# Use IDs for connections
connect_nodes("BP_MyActor",
              event_node["node_id"], "then",
              print_node["node_id"], "execute")
```

--------------------------------

### Inspect Material Before Editing

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/material-vfx/SKILL.md

Always run `material_inspect` before editing an existing material to understand its current structure, connections, and references.

```text
material_inspect
```

--------------------------------

### Collaborative World Building - District Assignments

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Assigns tasks to multiple AI agents for building different districts of a city. Includes commands for residential, commercial, and entertainment zones.

```bash
# AI 1: Residential District
construct_house(house_style="cottage", location=[-1000, -1000, 0])
construct_house(house_style="modern", location=[-500, -1000, 0])
construct_house(house_style="cottage", location=[-1000, -500, 0])

# AI 2: Commercial District  
create_town(town_size="small", architectural_style="downtown", location=[0, 0, 0])
create_tower(height=15, base_size=5, tower_style="square", location=[200, 200, 0])

# AI 3: Entertainment District
create_maze(rows=10, cols=10, location=[1000, 0, 0])
```

--------------------------------

### Commit Blueprint Changes

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Use `bp_commit` to compile the blueprint, auto-layout graphs, and generate a health report. Investigate all warnings, as 'UpToDateWithWarnings' is not a success state.

```text
bp_commit(blueprint_path)
```

--------------------------------

### Generate Game Level with Challenge Areas

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Generate a complete game level with multiple challenge areas using a phased approach.

```bash
1. create_maze(rows=12, cols=12, wall_height=3, location=[0, 0, 0])          # Central maze
2. create_town(town_size="small", location=[2000, 0, 0])                      # Safe zone
```

```bash
4. create_pyramid(base_size=3, location=[0, 2000, 0])                        # Climbable structure
6. spawn_physics_blueprint_actor (name="MovableCrate", location=[500, 500, 50])         # Interactive object
```

```bash
9. construct_house(house_style="cottage", location=[1800, 200, 0])           # Quest hub building
```

--------------------------------

### create_tower

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Build architectural towers with various styles and decorative elements.

```APIDOC
## create_tower

### Description
Build architectural towers with various styles and decorative elements.

### Parameters
#### Path Parameters
- `height` (int): Number of vertical levels (default: 10)
- `base_size` (int): Base diameter/width (default: 4)
- `tower_style` (string): "cylindrical", "square", or "tapered"
- `block_size` (float): Size of building blocks in cm
- `location` (array): Tower base center position
- `mesh` (string): Static mesh for blocks
- `name_prefix` (string): Actor naming prefix

### Styles
- Cylindrical: Round tower with blocks in circular pattern
- Square: Hollow square tower with corner reinforcements  
- Tapered: Tower that narrows toward the top

### Request Example
```bash
create_tower(height=15, base_size=6, tower_style="cylindrical", location=[1000, 0, 0])
```
```

--------------------------------

### Author Wiring with bp_wire

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/skills/blueprint-authoring/SKILL.md

Use `bp_wire` for batched operations on execution and data edges, pin defaults, and pin operations. Ensure both exec and data edges are included in a single call.

```text
bp_wire({blueprint_path, graph, edges: [...], defaults: [...], pin_ops: [...]})
```

--------------------------------

### Check Xcode and SDK Version on macOS

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Verify your Xcode and SDK versions on macOS. This is a prerequisite for patching the Unreal Engine SDK configuration if you encounter compilation errors.

```bash
xcodebuild -version
xcrun --show-sdk-version
```

--------------------------------

### Add LLVM Version Mapping for Xcode

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/LOCAL_SETUP.md

Extend the 'AppleVersionToLLVMVersions' array in the Apple SDK configuration to include a mapping for your specific Xcode version. This is crucial for correct LLVM toolchain selection during compilation.

```json
{
  "AppleVersionToLLVMVersions": [
    "14.0.0-14.0.0",
    "14.0.3-15.0.0",
    "15.0.0-16.0.0",
    "16.0.0-17.0.6",
    "16.3.0-19.1.4",
    "YOUR_XCODE_VERSION.0.0-19.1.4"  // e.g., "26.0.0-19.1.4" for Xcode 26.x
  ]
}
```

--------------------------------

### Compile Blueprint

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Compile the Blueprint after adding nodes and connections to ensure changes are applied. This is a crucial step for updating the Blueprint.

```bash
compile_blueprint("BP_MyActor")
```

--------------------------------

### create_pyramid

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Build stepped pyramids from stacked blocks.

```APIDOC
## create_pyramid

### Description
Build stepped pyramids from stacked blocks.

### Parameters
#### Path Parameters
- `base_size` (int): Number of blocks on base edge (default: 3)
- `block_size` (float): Edge length of each block in cm (default: 100)
- `location` (array): Pyramid base center
- `mesh` (string): Static mesh asset path
- `name_prefix` (string): Actor naming prefix
```

--------------------------------

### create_staircase

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Build stepped staircases with configurable dimensions.

```APIDOC
## create_staircase

### Description
Build stepped staircases with configurable dimensions.

### Parameters
#### Path Parameters
- `steps` (int): Number of steps (default: 5)
- `step_size` (array): [width, depth, height] of each step (default: [100, 100, 50])
- `location` (array): Staircase starting position
- `mesh` (string): Static mesh asset path
- `name_prefix` (string): Actor naming prefix
```

--------------------------------

### Apply Backup Color Parameter to Mesh Material

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Sets the 'Color' parameter of a mesh's material, serving as a fallback for different material versions. Ensures color compatibility.

```bash
set_mesh_material_color(
    blueprint_name="BP_ColoredSphere", 
    component_name="SphereMesh",
    color=[1.0, 0.0, 0.0, 1.0],  # Same red color
    material_path="/Engine/BasicShapes/BasicShapeMaterial",
    parameter_name="Color"
)
```

--------------------------------

### Compile Blueprint

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

Compiles a specified Blueprint class to apply all its modifications. This step is crucial before spawning actors based on the Blueprint.

```bash
compile_blueprint(blueprint_name="BP_ColoredSphere")
```

--------------------------------

### Build Suburban Neighborhood with Arch Entrance

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/prompt-examples.md

Constructs a suburban area with various house styles and adds an archway as a neighborhood entrance. Ensure house locations do not overlap.

```bash
1. construct_house(house_style="modern", location=[0, 0, 0])
2. construct_house(house_style="cottage", location=[800, 0, 0]) 
3. construct_house(house_style="mansion", location=[1600, 0, 0])
4. construct_house(house_style="modern", location=[0, 800, 0])
5. create_arch(radius=150, segments=6, location=[800, 400, 0])  # Neighborhood entrance
```

--------------------------------

### create_town

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Create complete urban environments with buildings, roads, and infrastructure.

```APIDOC
## create_town

### Description
Create complete urban environments with buildings, roads, and infrastructure.

### Parameters
#### Path Parameters
- `town_size` (string): "small", "medium", "large", or "metropolis"
- `architectural_style` (string): "modern", "medieval", "suburban", "downtown", "mixed", or "futuristic"
- `building_density` (float): How packed the buildings are (0.0-1.0)
- `location` (array): [X, Y, Z] world position for town center
- `include_infrastructure` (bool): Add roads, utilities, etc.
- `name_prefix` (string): Prefix for spawned building actors

### Request Example
```bash
create_town(town_size="medium", architectural_style="modern", building_density=0.8, location=[0, 0, 0])
```
```

--------------------------------

### Create and Spawn Colored Spheres

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/colored-shapes-tutorial.md

This Python code iterates through a list of colors to create unique blueprints and spawn actors for each color, arranging them in a line.

```python
colors = [
    [1.0, 0.0, 0.0, 1.0],  # Red
    [1.0, 0.5, 0.0, 1.0],  # Orange  
    [1.0, 1.0, 0.0, 1.0],  # Yellow
    [0.0, 1.0, 0.0, 1.0],  # Green
    [0.0, 0.0, 1.0, 1.0],  # Blue
    [0.5, 0.0, 1.0, 1.0],  # Indigo
    [1.0, 0.0, 1.0, 1.0],  # Violet
]

for i, color in enumerate(colors):
    # Create unique Blueprint for each color
    create_blueprint(name=f"BP_Rainbow_{i}", parent_class="Actor")
    # ... (rest of setup process)
    spawn_blueprint_actor(
        actor_name=f"RainbowSphere_{i}",
        blueprint_name=f"BP_Rainbow_{i}",
        location=[i * 300, 0, 200]
    )
```

--------------------------------

### Add a BeginPlay event node

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Adds a BeginPlay event node to a specified Blueprint. This is useful for triggering logic when an actor begins its lifecycle.

```bash
> "Add a BeginPlay event node to BP_MyActor"
→ add_node("BP_MyActor", "Event", event_type="BeginPlay", pos_x=0, pos_y=0)
```

--------------------------------

### spawn_physics_blueprint_actor

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Creates actors with custom physics properties and materials. This function allows for detailed configuration of physics simulation, mass, and gravity for newly spawned actors.

```APIDOC
## spawn_physics_blueprint_actor

### Description
Create actors with custom physics properties and materials.

### Parameters
#### Path Parameters
- `name` (string): Actor name (must be unique)
- `mesh_path` (string): Path to static mesh asset
- `location` (array): Spawn position (default: [0, 0, 0])
- `mass` (float): Physics mass in kg (default: 1.0)
- `simulate_physics` (bool): Enable physics simulation (default: true)
- `gravity_enabled` (bool): Enable gravity effects (default: true)

### Process
1. Creates temporary Blueprint class
2. Adds StaticMeshComponent with specified mesh
3. Configures physics properties
4. Compiles Blueprint and spawns actor
```

--------------------------------

### create_wall

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Generate straight walls from repeated block elements.

```APIDOC
## create_wall

### Description
Generate straight walls from repeated block elements.

### Parameters
#### Path Parameters
- `length` (int): Number of blocks along wall (default: 5)
- `height` (int): Number of block layers vertically (default: 2)
- `block_size` (float): Block dimensions in cm (default: 100)
- `location` (array): Wall starting position
- `orientation` (string): Direction to extend - "x" or "y"
- `mesh` (string): Static mesh asset path
- `name_prefix` (string): Actor naming prefix
```

--------------------------------

### create_arch

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Create decorative arch structures using blocks arranged in semicircles.

```APIDOC
## create_arch

### Description
Create decorative arch structures using blocks arranged in semicircles.

### Parameters
#### Path Parameters
- `radius` (float): Arch radius in centimeters (default: 300)
- `segments` (int): Number of blocks forming the arch (default: 6)
- `location` (array): Arch center base position
- `mesh` (string): Static mesh asset path
- `name_prefix` (string): Actor naming prefix
```

--------------------------------

### Connect Blueprint Nodes

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/blueprint-graph-guide.md

Connects two nodes in a Blueprint, establishing execution or data flow. Ensure you have the correct blueprint name, node IDs, and pin names.

```python
connect_nodes(
    blueprint_name: str,      # Name of the Blueprint
    source_node_id: str,      # ID of the source node (from add_node return)
    source_pin_name: str,     # Output pin name (e.g., "then", "execute")
    target_node_id: str,      # ID of the target node
    target_pin_name: str      # Input pin name (e.g., "execute")
)
```

```bash
> "Connect the BeginPlay event to the Print node in BP_MyActor"
→ connect_nodes("BP_MyActor", "K2Node_Event_0", "then", "K2Node_CallFunction_1", "execute")
```

--------------------------------

### create_maze

Source: https://github.com/flopperam/unreal-engine-mcp/blob/main/Guides/tools-reference.md

Generate solvable mazes using recursive backtracking algorithm.

```APIDOC
## create_maze

### Description
Generate solvable mazes using recursive backtracking algorithm.

### Parameters
#### Path Parameters
- `rows` (int): Maze height in cells (default: 8)
- `cols` (int): Maze width in cells (default: 8)
- `cell_size` (float): Size of each maze cell in cm (default: 300)
- `wall_height` (int): Height of walls in block layers (default: 3)
- `location` (array): Maze center position

### Features
- Guaranteed Solvable: Uses recursive backtracking for valid paths
- Clear Entrance/Exit: Marked with distinctive objects
- Open Top Design: Walls are limited height for aerial viewing
- No Dead Ends: Every area is accessible

### Request Example
```bash
create_maze(rows=12, cols=12, wall_height=4, cell_size=250, location=[0, 0, 0])
```
```