Godot MCP Server
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 scene tree of the current scene"
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.
Godot MCP Server
MCP server that bridges Claude Code with the Godot editor via WebSocket. This repo only provides the MCP server — the Godot addon must be installed separately.
Prerequisites
Install the Godot addon from: https://github.com/youichi-uda/godot-mcp-pro
The addon connects automatically to the MCP server at ws://localhost:6505 when the editor starts.
This repo is a free client for the premium addon Godot MCP Pro. Get the premium version here:
Related MCP server: Godot MCP Bridge
Setup
1. Clone this repo
git clone https://github.com/neondeex/GodotMCP-Pro-Free-Client
cd GodotMCP-Pro-Free-Client2. Install dependencies
npm install3. Start the server
npm startConfigure Claude Code
Add this to ~/.claude.json under mcpServers:
{
"mcpServers": {
"godot": {
"command": "node",
"args": ["/absolute/path/to/GodotMCP-Pro-Free-Client/index.js"]
}
}
}Or via CLI:
claude mcp add godot node -- /absolute/path/to/GodotMCP-Pro-Free-Client/index.jsAvailable Tools
167 tools across 25 categories:
Category | Tools | Description |
Project | 9 | Project info, filesystem, settings, autoloads |
Scene | 9 | Create, open, save, list, play scenes |
Node | 13 | Add, delete, move, rename, signals, properties |
Script | 7 | List, read, create, edit, attach, validate GDScript |
Editor | 13 | State, errors, screenshots, settings, EditorScript |
Input | 5 | Simulate keyboard, mouse, actions, sequences |
Runtime | 18 | Live game inspection, properties, signals, physics |
Animation | 6 | List, create, delete animations and keyframes |
Animation Tree | 8 | State machines, transitions, blend parameters |
Audio | 6 | Buses, effects, volumes, AudioStreamPlayer |
Batch | 7 | Multi-node operations, scene analysis |
Shader | 6 | Create, read, edit shaders, assign materials |
Export | 3 | List presets, export project, preset info |
Resource | 4 | Read, edit, create, preview Godot resources |
Input Map | 2 | Get and set input action bindings |
Scene 3D | 6 | Meshes, lights, materials, camera, environment |
Physics | 6 | Collision shapes, physics bodies, layers, raycast |
Analysis | 6 | Unused resources, signal flow, dependencies, metrics |
Navigation | 5 | NavRegion, NavAgent, bake mesh, layer config |
Particles | 5 | Create particles, materials, presets, properties |
Profiling | 2 | Performance monitors (game + editor) |
Testing | 5 | Test scenarios, assertions, stress tests |
Theme | 7 | Colors, fonts, styleboxes, apply to nodes |
Tilemap | 6 | Set cells, fill rect, clear, get info |
Android | 3 | List devices, deploy, preset info |
How It Works
Claude Code ──(MCP/stdio)──▶ MCP Server ──(WebSocket :6505)──▶ Godot addonClaude invokes a tool (e.g.
get_scene_tree)The MCP server forwards it as a JSON-RPC request to the Godot addon
Godot executes the command and returns the result
The MCP server relays the result back to Claude
The server tries ports 6505–6514 in order and binds to the first available one.
Available Tools
167 toolsadd_animation_trackC
Add a track to an animation in an AnimationPlayer.
Inputs: node_path (required), target_path (required), animation_name (required), track_type.
add_audio_busC
Add a new audio bus.
Inputs: name (required), volume_db.
add_audio_bus_effectC
Add an audio effect to a bus.
Inputs: bus_name (required), effect_type (required).
add_audio_playerC
Add an AudioStreamPlayer node to the scene.
Inputs: bus, parent_path, stream_path.
add_mesh_instanceC
Add a MeshInstance3D with a primitive mesh to the scene.
Inputs: mesh_type (required), name, properties, parent_path.
add_nodeC
Add a new node to the currently open scene.
Inputs: type (required), name, properties, parent_path.
add_raycastC
Add a RayCast3D/2D node to the scene.
Inputs: properties, parent_path, target_position.
add_scene_instanceB
Instance an existing scene into the currently open scene.
Inputs: scene_path (required), name, parent_path.
add_state_machine_stateC
Add a state to an AnimationNodeStateMachine inside an AnimationTree.
Inputs: node_path (required), state_name (required), animation.
add_state_machine_transitionC
Add a transition between two states in an AnimationNodeStateMachine.
Inputs: to (required), from (required), node_path (required).
add_world_environmentC
Add a WorldEnvironment node with a sky to the scene.
Inputs: sky_type, parent_path.
analyze_code_complexityB
Analyze a GDScript file and report cyclomatic complexity, function count, line count, etc.
Inputs: script_path (required).
analyze_scene_complexityB
Analyze a scene and report node count, depth, script count, and other complexity metrics.
Inputs: scene_path.
analyze_signal_flowC
Analyze and map all signal connections for a node and its children.
Inputs: node_path (required).
apply_particle_presetC
Apply a named particle effect preset to a particle node.
Inputs: preset (required), node_path (required).
apply_theme_to_nodeC
Apply a Theme resource to a Control node.
Inputs: node_path (required), theme_path (required).
assert_node_stateB
Assert that a node's properties match expected values in the running game.
Inputs: node_path (required), assertions (required).
assert_screen_textB
Assert that a given text string appears on the screen within a timeout.
Inputs: text (required), timeout.
assign_shader_materialC
Assign a shader (as a ShaderMaterial) to a node.
Inputs: node_path (required), shader_path (required).
attach_scriptC
Attach an existing script to a node in the current scene.
Inputs: node_path (required), script_path (required).
batch_add_nodesB
Add multiple nodes to the scene in a single call.
Inputs: nodes (required).
batch_delete_nodesB
Delete multiple nodes from the scene in a single call.
Inputs: node_paths (required).
batch_set_propertyC
Set the same property on multiple nodes at once.
Inputs: value (required), property (required), node_paths (required).
call_game_node_methodC
Call a method on a node in the running game.
Inputs: method (required), node_path (required), args.
capture_framesC
Capture multiple screenshots from the running game at a given interval.
Inputs: count, interval.
clear_editor_errorsB
Clear the error list in the Godot editor output panel.
Inputs: no named parameters.
close_sceneB
Close the currently open scene.
Inputs: no named parameters.
connect_game_signalC
Listen to a signal on a node in the running game and return fired events.
Inputs: node_path (required), signal_name (required), duration.
connect_signalC
Connect a signal from one node to a method on another node.
Inputs: method_name (required), signal_name (required), source_path (required), target_path (required).
create_animationB
Create a new animation in an AnimationPlayer node.
Inputs: node_path (required), animation_name (required), length.
create_animation_treeC
Create and attach an AnimationTree node.
Inputs: node_path (required).
create_directoryC
Create a directory inside the project filesystem.
Inputs: path (required).
create_particlesC
Add a GPUParticles3D or CPUParticles2D node to the scene.
Inputs: name, type_2d, parent_path.
create_resourceC
Create a new Godot Resource file of the given type.
Inputs: path (required), type (required), properties.
create_sceneC
Create a new scene file in the project.
Inputs: name (required), path, root_type.
create_scriptC
Create a new GDScript file, optionally with initial content and optionally attach it to a node.
Inputs: path (required), content, attach_to.
create_shaderC
Create a new shader file.
Inputs: path (required), code, type.
create_themeC
Create a new Theme resource file.
Inputs: path (required).
delete_animationC
Delete an animation from an AnimationPlayer node.
Inputs: node_path (required), animation_name (required).
delete_fileB
Delete a file from the project filesystem.
Inputs: path (required).
delete_nodeC
Delete a node from the currently open scene.
Inputs: node_path (required).
deploy_to_androidC
Build and deploy the project to a connected Android device.
Inputs: preset, device_id.
detach_scriptC
Remove the script attached to a node.
Inputs: node_path (required).
detect_circular_dependenciesB
Detect circular script/resource dependencies in the project.
Inputs: no named parameters.
disconnect_signalC
Disconnect a previously connected signal.
Inputs: method_name (required), signal_name (required), source_path (required), target_path (required).
dismiss_dialogsB
Dismiss any open modal dialogs in the Godot editor.
Inputs: no named parameters.
duplicate_nodeC
Duplicate a node in the scene.
Inputs: node_path (required), new_name.
edit_resourceC
Update properties of an existing Godot Resource file.
Inputs: path (required), properties (required).
edit_scriptB
Overwrite the content of an existing GDScript file.
Inputs: path (required), content (required).
edit_shaderB
Overwrite the GLSL code of an existing shader file.
Inputs: code (required), path (required).
execute_game_scriptB
Execute arbitrary GDScript code in the running game context.
Inputs: code (required).
export_projectC
Export the project using a named export preset.
Inputs: preset (required), path, debug.
find_game_nodeB
Find a node by name in the running game scene tree.
Inputs: name (required).
find_missing_referencesB
Find broken/missing resource references in the current scene.
Inputs: no named parameters.
find_nodes_by_typeA
Find all nodes of a given type in the editor scene.
Inputs: type (required), root_path.
find_unused_resourcesB
Find resource files in the project that are not referenced by any scene or script.
Inputs: path.
focus_nodeC
Focus/frame a node in the 2D/3D viewport.
Inputs: node_path (required).
get_android_preset_infoB
Get information about the Android export preset configuration.
Inputs: no named parameters.
get_audio_bus_layoutA
Get the current audio bus layout (buses, effects, volumes).
Inputs: no named parameters.
get_autoloadsB
Get the list of autoload singletons registered in the project.
Inputs: no named parameters.
get_collision_layers_infoB
Get collision layer names and bitmask configuration from the project settings.
Inputs: no named parameters.
get_current_sceneB
Get information about the currently open scene in the editor.
Inputs: no named parameters.
get_editor_errorsA
Get current errors and warnings shown in the Godot editor output/debugger.
Inputs: no named parameters.
get_editor_performanceA
Get performance metrics for the Godot editor process itself.
Inputs: no named parameters.
get_editor_screenshotB
Capture a screenshot of the Godot editor window.
Inputs: no named parameters.
get_editor_settingC
Get an EditorSettings value.
Inputs: setting (required).
get_editor_stateA
Get the current state of the Godot editor (open scene, selected node, play state, etc.).
Inputs: no named parameters.
get_export_infoB
Get details about an export preset (platform, options, features).
Inputs: preset (required).
get_filesystem_treeB
Get the filesystem tree of the project starting at the given path.
Inputs: path, max_depth.
get_game_autoloadsB
Get all autoload singletons from the running game.
Inputs: no named parameters.
get_game_globalsB
Get global autoload singletons and their properties from the running game.
Inputs: no named parameters.
get_game_node_propertiesC
Get properties of a node in the running game.
Inputs: node_path (required).
get_game_performanceB
Get performance monitor values from the running game (FPS, memory, draw calls, etc.).
Inputs: no named parameters.
get_game_render_infoB
Get rendering information from the running game (render time, object count, etc.).
Inputs: no named parameters.
get_game_scene_treeB
Get the scene tree of the running game.
Inputs: no named parameters.
get_game_screenshotB
Capture a screenshot of the running game viewport.
Inputs: no named parameters.
get_game_signalsC
Get signals defined on a node in the running game.
Inputs: node_path (required).
get_input_actionsA
Get all input actions and their event bindings from the project Input Map.
Inputs: no named parameters.
get_node_childrenC
Get the direct children of a node.
Inputs: node_path (required).
get_node_propertiesC
Get all properties and their values for a node in the scene.
Inputs: node_path (required).
get_node_signalsC
List all signals defined by a node.
Inputs: node_path (required).
get_particle_infoC
Get configuration and status information about a particle node.
Inputs: node_path (required).
get_performance_monitorsC
Get all available Performance monitor values from the running game.
Inputs: no named parameters.
get_physics_stateA
Get physics body state (velocity, angular velocity, contacts) for a node in the running game.
Inputs: node_path (required).
get_project_infoA
Get general information about the current Godot project (name, path, Godot version, settings).
Inputs: no named parameters.
get_project_settingC
Get the current value of a project setting.
Inputs: setting (required).
get_project_statisticsB
Get high-level statistics about the project (file counts by type, total scene nodes, etc.).
Inputs: no named parameters.
get_resource_previewB
Get a preview image (base64) for a resource file.
Inputs: path (required).
get_scene_treeA
Get the full scene tree structure of the currently open scene.
Inputs: no named parameters.
get_script_dependenciesC
Get all resources and scripts that a given script depends on.
Inputs: script_path (required).
get_selected_nodesB
Get the list of currently selected nodes in the editor.
Inputs: no named parameters.
get_shader_paramsC
Get all shader uniform parameters from a node's ShaderMaterial.
Inputs: node_path (required).
get_test_resultsC
Get the results of the last test run.
Inputs: no named parameters.
get_theme_colorsB
Get all color entries in a Theme resource.
Inputs: theme_path (required).
get_theme_infoC
Get a summary of all entries in a Theme resource.
Inputs: theme_path (required).
get_tileset_infoC
Get information about the TileSet resource attached to a TileMap.
Inputs: node_path (required).
get_tree_parameterC
Get a parameter value from an AnimationTree.
Inputs: node_path (required), parameter (required).
list_android_devicesB
List Android devices connected via ADB.
Inputs: no named parameters.
list_animationsB
List all animations in an AnimationPlayer node.
Inputs: node_path (required).
list_export_presetsA
List all export presets defined in the project.
Inputs: no named parameters.
list_game_nodes_by_typeB
Find all nodes of a given type in the running game scene tree.
Inputs: type (required).
list_scenesB
List all scene files (.tscn) in the project.
Inputs: no named parameters.
list_scriptsA
List all GDScript files in the project (or under a specific path).
Inputs: path.
list_state_machine_statesC
List all states in an AnimationNodeStateMachine.
Inputs: node_path (required).
monitor_propertyB
Monitor a node property over time in the running game and return sampled values.
Inputs: property (required), node_path (required), duration.
move_fileC
Move or rename a file within the project filesystem.
Inputs: to (required), from (required).
move_nodeC
Reparent a node to a different parent in the scene tree.
Inputs: node_path (required), new_parent_path (required).
open_sceneC
Open a scene in the Godot editor.
Inputs: path (required).
play_animationC
Play an animation on an AnimationPlayer node.
Inputs: node_path (required), animation_name (required).
play_sceneC
Run the project (or a specific scene) in the Godot game window.
Inputs: path.
read_resourceC
Read properties of a Godot Resource file.
Inputs: path (required).
read_scriptB
Read the source code of a GDScript file.
Inputs: path (required).
read_shaderC
Read the GLSL source of a shader file.
Inputs: path (required).
reload_pluginC
Reload an editor plugin by name.
Inputs: plugin_name (required).
remove_audio_busC
Remove an audio bus by name.
Inputs: name (required).
remove_state_machine_stateC
Remove a state from an AnimationNodeStateMachine.
Inputs: node_path (required), state_name (required).
rename_nodeC
Rename a node in the scene.
Inputs: new_name (required), node_path (required).
replace_node_typeA
Replace a node with a new node of a different type (preserving children and position).
Inputs: new_type (required), node_path (required).
run_editor_scriptB
Execute arbitrary GDScript code in the editor context (EditorScript).
Inputs: code (required).
run_stress_testC
Run a stress test scenario and collect performance data over time.
Inputs: duration, scenario.
run_test_scenarioB
Run a structured test scenario in the running game and collect results.
Inputs: scenario (required).
save_sceneB
Save the currently open scene.
Inputs: path.
search_filesC
Search for files matching a pattern inside the project.
Inputs: pattern (required), path.
select_nodeC
Select a node in the editor scene tree panel.
Inputs: node_path (required).
set_animation_keyframeC
Set a keyframe value on an animation track.
Inputs: time (required), value (required), node_path (required), track_index (required), +1 more.
set_animation_tree_rootC
Set the root AnimationNode type on an AnimationTree.
Inputs: node_path (required), root_type (required).
set_audio_bus_volumeC
Set the volume of an audio bus.
Inputs: name (required), volume_db (required).
set_collision_layer_nameB
Set the name of a collision layer in the project settings.
Inputs: name (required), layer (required).
set_editor_settingC
Set an EditorSettings value.
Inputs: value (required), setting (required).
set_game_node_propertyB
Set a property on a node in the running game (live edit).
Inputs: value (required), property (required), node_path (required).
set_input_actionC
Create or update an input action in the Input Map.
Inputs: action (required), events.
set_material_3dC
Create and assign a StandardMaterial3D (or BaseMaterial3D) to a MeshInstance3D.
Inputs: node_path (required), properties, material_type.
set_node_ownerA
Set the owner of a node (required for saving packed scenes).
Inputs: node_path (required), owner_path (required).
set_particle_materialC
Set the process material properties on a particle node.
Inputs: node_path (required), properties.
set_particle_propertyC
Set a single property on a particle node.
Inputs: value (required), property (required), node_path (required).
set_physics_layersC
Set the collision layer and mask bitmasks on a physics body node.
Inputs: node_path (required), mask, layer.
set_project_settingC
Set a project setting value in the Godot ProjectSettings.
Inputs: value (required), setting (required).
set_shader_paramC
Set a shader uniform parameter on a node's ShaderMaterial.
Inputs: value (required), node_path (required), param_name (required).
set_theme_colorC
Set a color entry in a Theme resource.
Inputs: name (required), color (required), node_type (required), theme_path (required).
set_theme_font_sizeC
Set a font size entry in a Theme resource.
Inputs: name (required), size (required), node_type (required), theme_path (required).
set_theme_styleboxC
Set a StyleBox entry in a Theme resource.
Inputs: name (required), node_type (required), theme_path (required), stylebox_type (required), +1 more.
set_tree_parameterC
Set a parameter on an AnimationTree (e.g. blend position, condition).
Inputs: value (required), node_path (required), parameter (required).
setup_camera_3dB
Add a Camera3D node to the scene with optional configuration.
Inputs: properties, parent_path.
setup_collisionC
Add a CollisionShape3D/2D with a given shape to a node.
Inputs: node_path (required), properties, shape_type.
setup_lightingC
Add a light node to the scene.
Inputs: light_type (required), properties, parent_path.
setup_physics_bodyC
Add a physics body node (RigidBody3D, CharacterBody3D, StaticBody3D, etc.) to the scene.
Inputs: body_type (required), name, parent_path.
setup_reflection_probeC
Add a ReflectionProbe node to the scene.
Inputs: properties, parent_path.
simulate_actionB
Simulate an Input Map action in the running game.
Inputs: action (required), pressed.
simulate_keyC
Simulate a keyboard key event in the running game.
Inputs: keycode (required), alt, ctrl, shift, +1 more.
simulate_mouse_clickC
Simulate a mouse button click in the running game.
Inputs: button, pressed, position.
simulate_mouse_moveC
Simulate mouse movement in the running game.
Inputs: position (required).
simulate_sequenceC
Simulate a sequence of input events in the running game.
Inputs: events (required).
start_frame_captureB
Start continuous frame capture from the running game.
Inputs: no named parameters.
stop_frame_captureA
Stop continuous frame capture from the running game.
Inputs: no named parameters.
stop_sceneB
Stop the currently running game.
Inputs: no named parameters.
tilemap_clearC
Clear all cells in a TileMap layer.
Inputs: node_path (required), layer.
tilemap_fill_rectC
Fill a rectangular area of a TileMap with a specific tile.
Inputs: x (required), y (required), width (required), height (required), +3 more.
tilemap_get_infoB
Get information about a TileMap node (layers, cell size, used rect, etc.).
Inputs: node_path (required).
tilemap_get_used_cellsB
Get all used cell coordinates in a TileMap layer.
Inputs: node_path (required), layer.
tilemap_set_cellC
Set a single cell in a TileMap node.
Inputs: x (required), y (required), node_path (required), layer, +3 more.
update_propertyC
Set a property value on a node in the currently open scene.
Inputs: value (required), property (required), node_path (required).
validate_scriptB
Check a GDScript file for syntax/parse errors.
Inputs: path (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 167 tools
The set spans many distinct Godot domains, but there are many parallel editor-vs-running-game variants and multiple performance/analysis tools with close boundaries (e.g., get_node_properties vs get_game_node_properties, get_game_performance vs get_performance_monitors vs get_editor_performance). Descriptions help clarify intent, but the sheer volume increases the chance of tool misselection.
Nearly all tools use snake_case and predictable verb/resource wording, which keeps names readable. However, some names lead with a domain/tool prefix (e.g., tilemap_set_cell, game_...) while others lead with the verb, so the pattern is not perfectly uniform.
167 tools is far beyond a reasonable MCP tool surface and is an extreme mismatch for practical tool selection, even for a broad Godot editor/runtime integration. The count creates significant cognitive overload and makes discovery and correct invocation difficult.
Coverage is very broad: filesystem, scenes, nodes, scripts, editor/runtime control, animation, audio, shaders, exports, resources, input, 3D/physics/navigation, particles, testing, themes, tilemaps, and Android deployment are all represented. Some lifecycle gaps remain, such as scene deletion/duplication, audio playback control, richer UI-control creation, and asset import workflows.
Maintenance
Related MCP Connectors
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Make all the audio for your game from a single prompt. Describe your game and your AI assistant plans every sound it needs (sound effects, ambience loops, music tracks and character voice lines), then generates them all in one go. You get several AI versions of each sound and keep the ones you like. Sounds are organized per game in folders and scenes, and the free Godot plugin installs them into your project, ready to play with one line of code. Works with Claude, Claude Code, Cursor and any MCP client, with OAuth login (no API key needed). Free plan included; sounds can be used in commercial games.
Your own Claude designs and codes Godot 4 games; each build is tested with real screenshots.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Related MCP Servers
- AlicenseAqualityDmaintenanceConnects Claude directly to Godot 4 projects to read and manipulate scenes, nodes, scripts, and assets within the editor. It enables real-time scene tree management, script editing, and resource configuration through a local Node.js bridge and GDScript plugin.16775 npmMIT
- FlicenseCqualityDmaintenanceEnables AI assistants to control Godot game engine projects through a WebSocket bridge. Supports scene editing, node manipulation, script management, and project introspection via 163 registered tools.1001-
- FlicenseNot gradedqualityDmaintenanceBridges AI assistants with the Godot 4 editor, exposing tools to inspect scenes, create nodes, modify properties, capture screenshots, debug scripts, and manage project files via the Model Context Protocol.-
- AlicenseNot gradedqualityBmaintenanceLet Claude, Cursor, or any MCP-compatible AI work inside your Godot project: read and edit scenes, write and validate scripts, run the game, drive it, and read the errors — without copy-pasting anything.10MIT