Skip to main content
Glama
Godot MCP Server

Godot MCP Server

by neondeex

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-Client

2. Install dependencies

npm install

3. Start the server

npm start

Configure 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.js

Available 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 addon
  1. Claude invokes a tool (e.g. get_scene_tree)

  2. The MCP server forwards it as a JSON-RPC request to the Godot addon

  3. Godot executes the command and returns the result

  4. 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 tools
add_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).

bake_navigation_meshC

Bake the navigation mesh for a NavigationRegion3D node.

Inputs: node_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_navigation_map_infoB

Get information about the navigation maps in the current scene.

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_navigation_layersC

Set the navigation layer bitmask on a navigation node.

Inputs: layers (required), node_path (required).

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_navigation_agentC

Add a NavigationAgent3D/2D node to the scene.

Inputs: properties, parent_path.

setup_navigation_regionC

Add a NavigationRegion3D/2D with a NavigationMesh to the scene.

Inputs: 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

    C2.7/5.0

    Scored across 167 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Connects 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.
      16
      775 npm
      MIT
    • F
      license
      C
      quality
      D
      maintenance
      Enables 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.
      100
      1
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Bridges 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.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Let 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.
      10
      MIT