Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Godot MCP Server Show me the current scene tree and read the player.gd script"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Connect Claude to your Godot 4 project. Claude can read and manipulate scenes, nodes, scripts, and assets directly in your editor.
Claude (claude.ai)
│ MCP (stdio)
▼
godot-mcp-server (Node.js, runs locally)
│ HTTP localhost:9080
▼
MCP Bridge Plugin (GDScript, runs inside Godot editor)
│
▼
Godot EditorRelated MCP server: Godot MCP Server
cd godot-mcp-server
npm install
npm run buildCopy the godot-plugin/addons/mcp_bridge folder into your Godot project's addons/ directory:
your-godot-project/
└── addons/
└── mcp_bridge/
├── plugin.cfg
├── mcp_bridge.gd
└── mcp_http_server.gdThen in Godot: Project → Project Settings → Plugins → enable MCP Bridge.
You should see: [MCP Bridge] Listening on http://127.0.0.1:9080 in the Output panel.
Add to your Claude MCP config (claude_desktop_config.json or equivalent):
{
"mcpServers": {
"godot": {
"command": "node",
"args": ["/absolute/path/to/godot-mcp-server/dist/index.js"],
"env": {
"GODOT_PORT": "9080"
}
}
}
}Variable | Default | Description |
|
| Host where Godot is running |
|
| Port the MCP Bridge plugin listens on |
Tool | Description |
| List all open scenes |
| Get full node hierarchy |
| Get all properties of a specific node |
| Add a new node to a scene |
| Remove a node and its children |
| Set one or more properties on a node |
| Move a node to a new parent |
| Add a .tscn as an instance in a scene |
| Save the current scene to disk |
Tool | Description |
| Read a .gd file |
| Write/create a .gd file |
| Execute a GDScript expression in the editor |
Tool | Description |
| List files in the project |
| Get metadata about a resource |
| Assign a resource to a node property |
| Create a new empty .tscn file |
Once connected, you can ask Claude things like:
"Show me the scene tree of the current scene"
"Add a Sprite2D called PlayerSprite as a child of /root/Main/Player"
"Set the position of the Enemy node to (400, 300)"
"Instantiate res://enemies/goblin.tscn under /root/Level at position (200, 150)"
"List all .tscn files in the project"
"Read the player.gd script"
"Create a new scene at res://levels/level2.tscn with a Node2D root"
The MCP Bridge plugin must be active and Godot must be open for any tools to work.
godot_run_script executes arbitrary GDScript — use with care.
Scene edits are live in the editor but not saved automatically. Use godot_save_scene to persist changes.
The plugin binds to 127.0.0.1 only (no external access).
Adds a new node of the specified type as a child of the given parent node.
Args:
parent_path (string): Node path of the parent e.g. "/root/Main"
node_type (string): Godot class name e.g. "Sprite2D", "CharacterBody2D", "Label", "AudioStreamPlayer"
node_name (string): Name for the new node
scene_path (string, optional): Scene to modify. Defaults to active scene.
properties (object, optional): Initial property values to set on the new node.
Returns: { name, type, path } of the created node.
Examples:
Use when: "Add a Sprite2D called PlayerSprite under /root/Main"
Use when: "Add a Label node to the HUD with text 'Score: 0'"
Inputs: parent_path (required), node_type (required), node_name (required), scene_path, +1 more.
Loads a resource and assigns it to a property of a node. Useful for setting textures, materials, audio streams, etc.
Args:
node_path (string): Node path e.g. "/root/Main/Player/Sprite2D"
property (string): Property name e.g. "texture", "material", "stream"
resource_path (string): res:// path to the resource to assign
scene_path (string, optional): Scene to modify. Defaults to active scene.
Returns: Confirmation of the assignment.
Examples:
Use when: "Set the player sprite texture to res://assets/player.png" -> node_path: "/root/Main/Player/Sprite2D", property: "texture", resource_path: "res://assets/player.png"
Inputs: node_path (required), property (required), resource_path (required), scene_path.
Creates a new empty scene file (.tscn) with a specified root node type.
Args:
scene_path (string): res:// path for the new scene e.g. "res://levels/level2.tscn"
root_type (string): Godot class for the root node e.g. "Node2D", "Node3D", "Control", "CharacterBody2D"
root_name (string, optional): Name for the root node (defaults to the scene file stem)
open_in_editor (boolean, optional): Open the new scene in the editor (default: true)
Returns: { path, root_node, root_type } of the created scene.
Inputs: scene_path (required), root_type (required), root_name, open_in_editor.
Returns all properties of a specific node by its scene path.
Args:
node_path (string): Full node path e.g. "/root/Main/Player" or "Player/Sprite2D"
scene_path (string, optional): Scene to look in. Defaults to active scene.
Returns: { name, type, path, properties: Record<string, unknown> }
Examples:
Use when: "What are the properties of the Player node?"
Use when: "Get transform of res://enemy.tscn root node"
Inputs: node_path (required), scene_path.
Returns metadata about a specific resource file (texture, audio, mesh, etc.).
Args:
resource_path (string): res:// path to the resource e.g. "res://assets/player.png"
Returns: { path, type, name, metadata: object }
Inputs: resource_path (required).
Returns the full node hierarchy of the specified scene (or the currently active scene if no path given).
Args:
scene_path (string, optional): Path to the scene file e.g. "res://levels/main.tscn". Defaults to the active scene.
depth (number, optional): Maximum recursion depth (default: 10, max: 50).
Returns: Nested node tree: { name, type, path, children[], properties? }
Examples:
Use when: "Show me the scene tree" or "What nodes are in res://player.tscn?"
Inputs: scene_path, depth.
Instantiates an existing .tscn file as a child node inside another scene.
Args:
scene_to_instantiate (string): res:// path of the scene to instance e.g. "res://enemies/goblin.tscn"
parent_path (string): Node path of the parent in the target scene e.g. "/root/Main"
node_name (string, optional): Override the instance name. Defaults to the scene file's stem.
target_scene_path (string, optional): Scene that will receive the instance. Defaults to active scene.
properties (object, optional): Properties to override on the root node of the instance.
Returns: { name, type, path } of the instantiated node.
Examples:
Use when: "Add a Goblin enemy to the level at position (300, 100)" -> scene_to_instantiate: "res://enemies/goblin.tscn", parent_path: "/root/Level" properties: { "position": {"x": 300, "y": 100} }
Inputs: scene_to_instantiate (required), parent_path (required), node_name, target_scene_path, +1 more.
Lists files in the Godot project filesystem under a given directory.
Args:
directory (string, optional): res:// directory path (default: "res://")
filter_type (string, optional): Filter by extension e.g. "tscn", "gd", "png", "tres". Omit for all.
recursive (boolean, optional): Include subdirectories (default: false)
limit (number, optional): Max results (default: 50, max: 200)
offset (number, optional): Pagination offset (default: 0)
Returns: { total, count, offset, has_more, items: [{ path, type, name }] }
Inputs: directory, filter_type, recursive, limit, +1 more.
Returns all scenes currently open in the Godot editor, including the active scene.
Returns: Array of scene objects: { path: string, root_node: string, root_type: string, node_count: number }
Examples:
Use when: "What scenes are open?" or "List all scenes"
Inputs: no named parameters.
Reads the content of a GDScript (.gd) or other text-based resource file.
Args:
file_path (string): res:// path e.g. "res://player/player.gd"
Returns: { path: string, content: string }
Inputs: file_path (required).
Removes a node (and all its children) from the scene. This is destructive and cannot be undone via MCP.
Args:
node_path (string): Full node path to remove e.g. "/root/Main/OldEnemy"
scene_path (string, optional): Scene to modify. Defaults to active scene.
Returns: Confirmation message.
Inputs: node_path (required), scene_path.
Moves a node to a new parent within the same scene, preserving its world transform.
Args:
node_path (string): Node to move e.g. "/root/Main/Enemy"
new_parent_path (string): Destination parent e.g. "/root/Main/EnemyGroup"
scene_path (string, optional): Scene to modify. Defaults to active scene.
keep_global_transform (boolean, optional): Whether to preserve world-space transform (default: true)
Returns: New node path after reparenting.
Inputs: node_path (required), new_parent_path (required), scene_path, keep_global_transform.
Executes a GDScript expression or block in the Godot editor context (via EditorScript). Useful for querying engine state or performing quick operations.
Args:
code (string): GDScript code to execute. Should be a valid expression or a series of statements. Has access to: Engine, ProjectSettings, EditorInterface (in editor context).
timeout_ms (number, optional): Max execution time in milliseconds (default: 5000, max: 30000).
Returns: { success: boolean, output: string, error?: string }
Examples:
Use when: "What is the current project name?" -> code: "ProjectSettings.get_setting('application/config/name')"
Use when: "List all files in res://levels/" -> code: "DirAccess.get_files_at('res://levels/')"
Warning: This runs arbitrary code in the editor. Use with care.
Inputs: code (required), timeout_ms.
Saves the specified scene (or active scene) to disk.
Args:
scene_path (string, optional): res:// path of the scene to save. Omit for active scene.
save_as (string, optional): New res:// path to save a copy to (like Save As).
Returns: Confirmation with the saved path.
Inputs: scene_path, save_as.
Sets one or more properties on an existing node.
Args:
node_path (string): Full node path e.g. "/root/Main/Player"
properties (object): Key/value pairs to set. Values must be JSON-serialisable Godot variants. Common keys: "position", "rotation", "scale", "visible", "modulate", "text", "texture"
scene_path (string, optional): Scene to modify. Defaults to active scene.
Returns: Updated property values.
Examples:
Use when: "Move the Player to position (100, 200)" -> properties: { "position": {"x": 100, "y": 200} }
Use when: "Hide the HUD node" -> properties: { "visible": false }
Inputs: node_path (required), properties (required), scene_path.
Writes (creates or overwrites) a GDScript file at the given path.
Args:
file_path (string): res:// path e.g. "res://player/player.gd"
content (string): Full GDScript source code to write.
Returns: Confirmation with the file path.
Examples:
Use when: "Create a new movement script for the Player"
Inputs: file_path (required), content (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 16 tools
Each tool has a distinct purpose with clear boundaries: node operations (add, get, remove, reparent, set property), scene operations (create, get tree, instantiate, save, list), resource operations (assign, get), file operations (list files, read/write script), and a general-purpose run_script. No significant overlap exists; descriptions clarify specific use cases.
All tools follow a consistent 'godot_verb_noun' pattern with snake_case throughout. The verb-noun structure is predictable (e.g., godot_add_node, godot_get_scene_tree), making the set easy to navigate and understand.
16 tools is slightly high but reasonable for a Godot editor server covering nodes, scenes, resources, files, and scripts. Each tool serves a specific function, though some could potentially be consolidated (e.g., list_files and list_scenes). The count aligns well with the domain's complexity.
The toolset provides comprehensive coverage for Godot editor interactions: full CRUD for nodes (add, get, remove, reparent, set property), scene lifecycle (create, instantiate, save, list), resource handling (assign, get), file management (list, read/write scripts), and advanced operations (run_script). No obvious gaps exist for typical agent workflows.
Work on your own computers from Claude or ChatGPT: run commands, edit and search files.
Connect Claude to your Platform7n workspaces: chat, links, work and decks. One-click OAuth.
Your own Claude designs and codes Godot 4 games; each build is tested with real screenshots.
Manage your IoT device fleet directly from Claude. Create device templates with datastreams and events, provision new devices, read live sensor data, and control outputs. The Blynk connector integrates with the Blynk IoT platform, enabling direct configuration and monitoring of connected devices and infrastructure.
