How do I use godot-mcp-server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@godot-mcp-server List the nodes in the main 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

by Fulviuus

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

godot-mcp-server

An MCP server that gives AI coding agents first-class access to the Godot game engine: project inspection, project.godot editing, scene/script parsing, headless exports, running games with live control (eval, scene-tree inspection, hot reload and screenshots), and version-accurate API documentation search.

It targets Godot 4.7 and works without the editor open — agents drive Godot through its command line and a small in-game bridge. An optional desktop app manages the server and wires it into your AI agents in one click.

It ships 180+ tools: a native suite (28 godot_* tools for project/build/run/ docs) plus a vendored full-control suite (154 game_*/scene/editor tools) for deep runtime and editor manipulation — see Full-control tool suite.

This is the Godot counterpart to defold-mcp, built with the same architecture.

Related MCP server: Godot MCP Extended

Features

Project parsing — turn project.godot, .tscn/.tres scenes and .gd/.cs scripts into structured JSON (node trees, signals, exports, connections, outlines).
Toolchain management — resolve the project's target version, download and cache the matching editor binary and export templates, or use a binary you already have (GODOT_BIN).
Build pipeline — headless import (compile check), multi-mode exports (release/debug/pack) from your presets, clean, and a doctor diagnostic.
Runtime control — launch games as child processes, stream logs, stop them, and (with the bridge) inspect the live scene tree, evaluate expressions, set node properties, hot-reload scripts, and capture screenshots.
API docs — search and read the Godot class reference for the exact engine version in use (generated locally via --doctool, with a GitHub fallback).
Two transports — stdio (default) or HTTP, so multiple agents can share one server.
Desktop manager — an optional Tauri app: live console, start/stop, and one-click MCP setup for 9 AI agents.

Requirements

Node.js 18+
A Godot 4.x editor binary — the server can download one automatically, or you can point it at an existing install with GODOT_BIN.
Network access for the first toolchain/doc download (not needed afterwards, or at all if you set GODOT_BIN and skip docs search).

Install

git clone https://github.com/Fulviuus/godot-mcp.git && cd godot-mcp
npm install
npm run build      # generates dist/index.js
npm test           # runs the test suite (optional)

Configuration

Add the server to your MCP client. For a stdio config (Claude Code / Claude Desktop style):

{
  "mcpServers": {
    "godot": {
      "command": "node",
      "args": ["/path/to/godot-mcp/dist/index.js"],
      "env": { "GODOT_PROJECT_ROOT": "/path/to/your/game" }
    }
  }
}

Or run it over HTTP (shared by multiple agents):

node dist/index.js --transport http --port 7878
# then point clients at http://127.0.0.1:7878/mcp

Don't want to edit config files by hand? The desktop app writes the right config into each agent for you.

CLI options

Flag	Default	Purpose
`--transport <stdio\|http>`	`stdio`	Transport to serve on.
`--host <host>`	`127.0.0.1`	HTTP bind host.
`--port <port>`	`7878`	HTTP bind port.
`--exit-with-parent`	off	Exit when the controlling stdin/parent closes.
`--version`, `--help`	—	Print version / usage.

Environment variables

Variable	Purpose
`GODOT_PROJECT_ROOT`	Default project root (folder with `project.godot`).
`GODOT_BIN`	Path to a pre-installed Godot editor binary; skips downloads.
`GODOT_MCP_CACHE_DIR`	Where to cache editors/templates/docs (default `~/.cache/godot-mcp`).
`GODOT_MCP_MONO`	Set to `1` to use the .NET/Mono build.
`GODOT_MCP_LOG_LEVEL`	`debug` / `info` / `warn` / `error`.
`GODOT_PATH`	Godot executable for the full-control suite (falls back to `GODOT_BIN`, then PATH).
`GODOT_MCP_ADVANCED`	Set to `0` to disable the vendored full-control suite (register only the 28 native tools).

Most tools also accept a project_root and version argument to override the defaults per call.

Tools

The native suite is 28 tools across eight areas. Every native tool accepts response_format: "markdown" | "json". (The vendored full-control suite adds 154 more — see the next section.)

Area	Tools
Project	`godot_project_info`, `godot_get_settings`, `godot_set_setting`, `godot_list_addons`
Resources	`godot_list_resources`, `godot_parse_resource`, `godot_create_resource`, `godot_find_references`
Build	`godot_setup`, `godot_build`, `godot_export`, `godot_clean`, `godot_doctor`
Runtime	`godot_run`, `godot_stop`, `godot_game_logs`, `godot_list_games`
Live engine	`godot_engine_info`, `godot_scene_tree`, `godot_eval`, `godot_set_node_property`, `godot_hot_reload`, `godot_engine_command`
Editor	`godot_validate_script`, `godot_install_bridge`
Screenshot	`godot_screenshot`
Docs	`godot_api_search`, `godot_api_doc`

A typical agent flow:

godot_project_info            → understand the project
godot_setup                   → provision editor + templates + bridge
godot_build                   → confirm it imports/compiles
godot_run live:true           → launch with live control
godot_scene_tree / godot_eval → inspect the running game
godot_hot_reload              → apply script changes without restarting
godot_screenshot              → see the result
godot_export preset:"Linux"   → produce a build

The live-control bridge

Godot's headless mode can't render and has no general runtime RPC, so live control is provided by a tiny bridge addon (addons/godot_mcp) that godot_setup (or godot_run live:true) installs into your project. It registers an autoload that, only when a port is provided, opens a localhost TCP socket speaking newline-delimited JSON. The server uses it for godot_eval, godot_scene_tree, godot_set_node_property, godot_hot_reload and godot_screenshot. It is inert during normal runs and easy to remove (delete the addons/godot_mcp folder and the MCPBridge autoload).

Full-control tool suite

Alongside the native tools, the server registers a 154-tool full-control suite vendored from tugcantopaloglu/godot-mcp (MIT), which extends Coding-Solo/godot-mcp (MIT). It gives agents deep runtime and editor manipulation across networking, 3D/2D rendering, UI controls, audio, animation trees, physics, signals, file I/O, runtime GDScript eval, node inspection/mutation, project creation and more. Names are unprefixed (game_eval, run_project, read_scene, game_set_property, game_raycast, game_light_3d, …) so they never collide with the godot_* native tools.

It works through two channels, both driven by Godot-side engines shipped with the server (src/advanced/scripts/):

Headless operations (godot_operations.gd) — scene/resource/file/project tools run godot --headless --script godot_operations.gd; no running game needed. (Scene ops like read_scene need the project imported once — open it in the editor, or run godot_build / godot --import.)
Live interaction (mcp_interaction_server.gd) — the ~120 game_* runtime tools talk to a TCP autoload (port 9090) inside the running game. Call run_project to launch the game; it installs that autoload and connects automatically. (This is separate from the native godot_run bridge; use the suite that matches the tools you're calling.)

Set GODOT_MCP_ADVANCED=0 to register only the 28 native tools. Point the suite at your engine with GODOT_PATH (or reuse GODOT_BIN).

Attribution and license terms for the vendored code are in NOTICE; the vendored files carry source headers and everything is MIT-licensed.

Desktop app

desktop/ is an optional Tauri control panel (the Godot counterpart to the defold-mcp manager). It supervises the server and connects it to your agents without touching config files by hand:

Console — a live stream of everything the server does (tool calls, export output, game logs, listener status).
Server control — start/stop the server in Streamable HTTP mode on a chosen host/port (default 127.0.0.1:9820), with a status pill showing the live tool count and PID.
Agent auto-configuration — pick an agent and click Configure: the app merges a godot entry into that agent's own MCP config file (backing it up first) in the client's correct dialect, over HTTP or stdio. Supported agents: Claude Code, Claude Desktop, OpenAI Codex, Cursor, Gemini CLI, VS Code (Copilot), Windsurf, Cline, Zed. Files it can't safely edit (e.g. JSONC with comments) are never modified — it shows a paste-ready snippet instead.

The server is bundled into the app, so end users only need Node installed. See desktop/README.md to build and run it.

Architecture

src/
├── index.ts            Entry point: server construction, stdio/HTTP, lifecycle
├── http.ts             Streamable HTTP transport + /health
├── constants.ts        Versions, release-asset naming, cache locations
├── context.ts          Project-root resolution, res:// ↔ filesystem mapping
├── state.ts            Running-game registry + log buffers
├── util/               Parsers & helpers (ini, scene, gdscript, csharp, fs, http)
├── services/           Engine-facing logic (toolchain, processes, engine bridge,
│                       refdoc, screenshot, editor, templates)
└── tools/              MCP tool modules (project, resources, build, run, engine,
                        editor, screenshot, docs) + shared registration

desktop/                Optional Tauri desktop manager (see desktop/README.md)
test/                   node --test suite + a minimal Godot fixture project

The engine-specific layers map cleanly onto Godot: the godot editor binary + export templates replace Defold's bob.jar; the text scene format replaces protobuf; GDScript/C# replace Lua; and the bridge replaces Defold's TCP engine service.

Development

npm run dev          # run from source with tsx
npm run build        # type-check + emit dist/
npm test             # unit + server (stdio) + http tests
npm run bundle:server  # esbuild single-file bundle (used by the desktop app)

The toolchain-dependent flow (setup → build → run → eval → screenshot → export) is covered by an opt-in smoke test that needs a real Godot install:

node test/live-smoke.mjs            # uses a temp copy of the fixture
node test/live-smoke.mjs /my/game   # or your own project

Desktop app (Rust/Tauri) tests:

cd desktop/src-tauri && cargo test   # config writers, merging, backups

Credits

The full-control tool suite (src/advanced/) is vendored from godot-mcp by Tugcan Topaloglu, which extends godot-mcp by Solomon Elias (Coding-Solo). Both are MIT licensed. See NOTICE.
The native suite, transports, toolchain automation, tests, desktop app and packaging are original to this project, which mirrors the architecture of defold-mcp.

License

MIT — see LICENSE. Vendored components are MIT; see NOTICE.

Available Tools

182 tools

add_nodeadd_nodeC

Add a node to an existing scene

Inputs: nodeName (required), nodeType (required), scenePath (required), projectPath (required), +2 more.

attach_scriptattach_scriptC

Attach a GDScript to a scene node (headless)

Inputs: nodePath (required), scenePath (required), scriptPath (required), projectPath (required).

create_directorycreate_directoryB

Create a directory inside a Godot project

Inputs: projectPath (required), directoryPath (required).

create_projectcreate_projectB

Create a new Godot project from scratch

Inputs: projectName (required), projectPath (required).

create_resourcecreate_resourceC

Create a .tres resource file (headless)

Inputs: projectPath (required), resourcePath (required), resourceType (required), properties.

create_scenecreate_sceneB

Create a new Godot scene file

Inputs: scenePath (required), projectPath (required), rootNodeType.

create_scriptcreate_scriptB

Create a GDScript file from a template

Inputs: scriptPath (required), projectPath (required), source, extends, +2 more.

delete_filedelete_fileB

Delete a file from a Godot project

Inputs: filePath (required), projectPath (required).

export_mesh_libraryexport_mesh_libraryB

Export a scene as a MeshLibrary resource

Inputs: scenePath (required), outputPath (required), projectPath (required), meshItemNames.

export_projectexport_projectC

Export a Godot project using a preset

Inputs: outputPath (required), presetName (required), projectPath (required), debug.

game_3d_effectsgame_3d_effectsB

Create ReflectionProbe, Decal, or FogVolume

Inputs: effectType (required), parentPath (required), name, size, +1 more.

game_add_collisiongame_add_collisionB

Add a collision shape to a physics body node

Inputs: shapeType (required), parentPath (required), disabled, shapeParams, +2 more.

game_animation_controlgame_animation_controlC

AnimationPlayer seek/queue/speed/info control

Inputs: action (required), nodePath (required), speed, position, +1 more.

game_animation_treegame_animation_treeC

AnimationTree state machine travel and params

Inputs: action (required), nodePath (required), paramName, stateName, +1 more.

game_audio_busgame_audio_busB

Set volume, mute, or solo on an audio bus

Inputs: mute, solo, volume, busName.

game_audio_bus_layoutgame_audio_bus_layoutC

Create/remove/reorder audio buses and routing

Inputs: action (required), index, sendTo, busName.

game_audio_effectgame_audio_effectC

Add/remove/configure audio bus effects

Inputs: action (required), index, busName, effectType, +1 more.

game_audio_playgame_audio_playB

Play, stop, or pause an AudioStreamPlayer node

Inputs: nodePath (required), bus, pitch, action, +3 more.

game_audio_spatialgame_audio_spatialB

Configure AudioStreamPlayer3D spatial properties

Inputs: action (required), nodePath (required), maxDb, unitSize, +2 more.

game_await_signalgame_await_signalB

Await a signal with timeout and return args

Inputs: nodePath (required), signalName (required), timeout.

game_bone_posegame_bone_poseC

Get or set bone poses on a Skeleton3D node

Inputs: nodePath (required), scale, action, boneName, +3 more.

game_call_methodgame_call_methodC

Call a method on any node in the running game with optional arguments

Inputs: method (required), nodePath (required), args.

game_camera_attributesgame_camera_attributesB

Configure DOF, exposure, auto-exposure on camera

Inputs: action, dofBlurFar, dofBlurNear, autoExposure, +3 more.

game_canvasgame_canvasB

Create/configure CanvasLayer and CanvasModulate

Inputs: action (required), name, color, layer, +2 more.

game_canvas_drawgame_canvas_drawC

2D drawing: line/rect/circle/polygon/text/clear

Inputs: action (required), to, from, rect, +8 more.

game_change_scenegame_change_sceneA

Switch to a different scene file in the running game

Inputs: scenePath (required).

game_clickgame_clickB

Click at a position in the running Godot game window

Inputs: x (required), y (required), button.

game_connect_signalgame_connect_signalB

Connect a signal from one node to a method on another node in the running game

Inputs: method (required), nodePath (required), signalName (required), targetPath (required).

game_create_animationgame_create_animationB

Create an animation with tracks and keyframes

Inputs: nodePath (required), animationName (required), length, tracks, +2 more.

game_create_jointgame_create_jointB

Create a physics joint between two bodies

Inputs: jointType (required), parentPath (required), length, damping, +4 more.

game_create_timergame_create_timerC

Create a Timer node with configuration

Inputs: name, oneShot, waitTime, autostart, +1 more.

game_csggame_csgB

Create/configure CSG nodes with boolean operations

Inputs: action (required), name, size, height, +6 more.

game_debug_drawgame_debug_drawB

Draw debug lines, spheres, or boxes in 3D

Inputs: action (required), to, from, size, +4 more.

game_disconnect_signalgame_disconnect_signalB

Disconnect a signal connection in the running game

Inputs: method (required), nodePath (required), signalName (required), targetPath (required).

game_emit_signalgame_emit_signalA

Emit a signal on a node in the running game, optionally with arguments

Inputs: nodePath (required), signalName (required), args.

game_environmentgame_environmentC

Get or set environment and post-processing settings

Inputs: action, contrast, glowBloom, brightness, +15 more.

game_evalgame_evalC

Execute GDScript in the running game. Use "return" for values.

Inputs: code (required).

game_find_nodes_by_classgame_find_nodes_by_classB

Find all nodes of a specific class type in the running game

Inputs: className (required), rootPath.

game_gamepadgame_gamepadB

Send gamepad button or axis input event

Inputs: type (required), index (required), value (required), device.

game_get_audiogame_get_audioB

Get audio bus layout and playing streams

Inputs: no named parameters.

game_get_cameragame_get_cameraA

Get active camera position, rotation, and size

Inputs: no named parameters.

game_get_errorsgame_get_errorsA

Get new push_error/push_warning messages since last call

Inputs: no named parameters.

game_get_logsgame_get_logsA

Get new print output from the running game since last call

Inputs: no named parameters.

game_get_node_infogame_get_node_infoB

Get node info: class, properties, signals, methods, children

Inputs: nodePath (required).

game_get_nodes_in_groupgame_get_nodes_in_groupB

Get all nodes belonging to a specific group in the running game

Inputs: group (required).

game_get_propertygame_get_propertyA

Get a property value from any node in the running game by its path

Inputs: nodePath (required), property (required).

game_get_scene_treegame_get_scene_treeB

Get scene tree structure of the running game

Inputs: no named parameters.

game_get_uigame_get_uiB

Get visible UI elements from the running game

Inputs: no named parameters.

game_gigame_giB

Create/configure VoxelGI or LightmapGI

Inputs: giType (required), parentPath (required), name, size.

game_gridmapgame_gridmapB

GridMap set/get/clear cells and query used cells

Inputs: action (required), nodePath (required), x, y, +3 more.

game_http_requestgame_http_requestB

HTTP GET/POST/PUT/DELETE with headers and body

Inputs: url (required), body, method, headers, +1 more.

game_input_actiongame_input_actionC

Manage runtime InputMap actions and strength

Inputs: action (required), key, strength, actionName.

game_input_stategame_input_stateC

Query pressed keys, mouse position, connected pads

Inputs: x, y, action, mouseMode.

game_instantiate_scenegame_instantiate_sceneA

Load a PackedScene and add it as a child of a node in the running game

Inputs: scenePath (required), parentPath.

game_key_holdgame_key_holdA

Hold a key down without auto-releasing

Inputs: key, action.

game_key_pressgame_key_pressC

Send a key press or input action to the running game

Inputs: key, action, pressed.

game_key_releasegame_key_releaseC

Release a previously held key

Inputs: key, action.

game_light_2dgame_light_2dA

Create/configure 2D lights and light occluders

Inputs: action (required), name, color, range, +3 more.

game_light_3dgame_light_3dB

Create/configure 3D lights (directional/omni/spot)

Inputs: action (required), name, color, range, +6 more.

game_list_signalsgame_list_signalsB

List all signals on a node with connections

Inputs: nodePath (required).

game_localegame_localeC

Set/get locale and translate strings at runtime

Inputs: action (required), key, locale.

game_manage_groupgame_manage_groupC

Add or remove a node from a group, or list groups

Inputs: action (required), group, nodePath.

game_mesh_instancegame_mesh_instanceB

Create MeshInstance3D with primitive meshes

Inputs: meshType (required), parentPath (required), name, size, +3 more.

game_mouse_draggame_mouse_dragB

Drag mouse between two points over N frames

Inputs: toX (required), toY (required), fromX (required), fromY (required), +2 more.

game_mouse_movegame_mouse_moveC

Move the mouse in the running Godot game

Inputs: x (required), y (required), relative_x, relative_y.

game_multimeshgame_multimeshB

Create/configure MultiMeshInstance3D for instancing

Inputs: action (required), name, count, index, +4 more.

game_multiplayergame_multiplayerC

ENet multiplayer create server/client/disconnect

Inputs: action (required), port, address, maxClients.

game_navigate_pathgame_navigate_pathC

Query a navigation path between two points

Inputs: end (required), start (required), optimize.

game_navigation_3dgame_navigation_3dB

Create/configure NavigationRegion3D and bake

Inputs: action (required), name, cellSize, nodePath, +3 more.

game_os_infogame_os_infoA

Get platform, locale, screen, adapter, memory info

Inputs: no named parameters.

game_parallaxgame_parallaxB

Create/configure ParallaxBackground and layers

Inputs: action (required), name, nodePath, mirroring, +3 more.

game_path_2dgame_path_2dC

Path2D/Curve2D management and AnimatedSprite2D

Inputs: action (required), name, point, points, +2 more.

game_path_3dgame_path_3dB

Create Path3D/Curve3D and manage curve points

Inputs: action (required), name, point, points, +2 more.

game_pausegame_pauseB

Pause or unpause the running game

Inputs: paused.

game_performancegame_performanceB

Get performance metrics (FPS, memory, draw calls)

Inputs: no named parameters.

game_physics_2dgame_physics_2dA

Area2D queries and 2D point/shape intersections

Inputs: action (required), to, from, nodePath, +1 more.

game_physics_3dgame_physics_3dC

Area3D queries and point/shape intersection tests

Inputs: action (required), to, from, nodePath, +1 more.

game_physics_bodygame_physics_bodyB

Configure physics body properties (mass, velocity, etc.)

Inputs: nodePath (required), mass, bounce, freeze, +7 more.

game_play_animationgame_play_animationB

Control an AnimationPlayer node: play, stop, pause, or list animations

Inputs: nodePath (required), action, animation.

game_procedural_meshgame_procedural_meshC

Generate meshes via ArrayMesh from vertex data

Inputs: vertices (required), parentPath (required), uvs, name, +2 more.

game_process_modegame_process_modeC

Set node process mode (pausable/always/disabled)

Inputs: mode (required), nodePath (required).

game_raycastgame_raycastB

Cast a ray and return collision results

Inputs: to (required), from (required), collisionMask.

game_remove_nodegame_remove_nodeB

Remove and free a node from the running game's scene tree

Inputs: nodePath (required).

game_render_settingsgame_render_settingsC

Get/set MSAA, FXAA, TAA, scaling mode/scale

Inputs: taa, fxaa, action, msaa2d, +3 more.

game_reparent_nodegame_reparent_nodeA

Move a node to a new parent in the running game's scene tree

Inputs: nodePath (required), newParentPath (required), keepGlobalTransform.

game_resourcegame_resourceC

Runtime resource load, save, or preload

Inputs: path (required), action (required), nodePath, property.

game_rpcgame_rpcC

Call or configure RPC methods on nodes

Inputs: action (required), method (required), nodePath (required), args, +3 more.

game_screenshotgame_screenshotA

Screenshot the running game (returns base64 PNG)

Inputs: no named parameters.

game_scriptgame_scriptB

Attach, detach, or get source of node scripts

Inputs: action (required), nodePath (required), source, className.

game_scrollgame_scrollB

Send mouse scroll wheel event at position

Inputs: x (required), y (required), amount, direction.

game_serialize_stategame_serialize_stateB

Save or load node tree state as JSON

Inputs: data, action, maxDepth, nodePath.

game_set_cameragame_set_cameraB

Move or rotate the active camera

Inputs: fov, zoom, position, rotation.

game_set_particlesgame_set_particlesB

Configure GPUParticles2D/3D node properties

Inputs: nodePath (required), amount, oneShot, emitting, +5 more.

game_set_propertygame_set_propertyB

Set a property on a node in the running game

Inputs: nodePath (required), property (required), value, typeHint.

game_set_shader_paramgame_set_shader_paramB

Set a shader parameter on a node's material

Inputs: nodePath (required), paramName (required), value, typeHint.

game_shape_2dgame_shape_2dC

Line2D/Polygon2D point manipulation

Inputs: action (required), nodePath (required), color, point, +2 more.

game_skeleton_ikgame_skeleton_ikC

SkeletonIK3D start/stop/set target position

Inputs: action (required), nodePath (required), target.

game_skygame_skyB

Create/configure Sky with procedural/physical sky

Inputs: action (required), skyType, topColor, sunEnergy, +2 more.

game_spawn_nodegame_spawn_nodeC

Create a new node of any type at runtime

Inputs: type (required), name, parentPath, properties.

game_terraingame_terrainC

Create/modify terrain meshes from heightmap data

Inputs: action (required), x, z, name, +9 more.

game_tilemapgame_tilemapC

Get or set cells in a TileMapLayer node

Inputs: action (required), nodePath (required), x, y, +2 more.

game_time_scalegame_time_scaleB

Get/set Engine.time_scale and timing info

Inputs: action, timeScale.

game_touchgame_touchB

Simulate touch press/release/drag and gestures

Inputs: x (required), y (required), action (required), toX, +3 more.

game_tween_propertygame_tween_propertyC

Tween a node property in the running game

Inputs: nodePath (required), property (required), duration, easeType, +2 more.

game_ui_controlgame_ui_controlC

Set focus, anchors, tooltip, mouse filter on Control

Inputs: action (required), nodePath (required), minSize, tooltip, +2 more.

game_ui_item_listgame_ui_item_listB

ItemList/OptionButton: get/select/add/remove items

Inputs: action (required), nodePath (required), text, index.

game_ui_menugame_ui_menuC

PopupMenu/MenuBar: add/remove/get menu items

Inputs: action (required), nodePath (required), id, text, +2 more.

game_ui_popupgame_ui_popupC

Show/hide/popup for Popup/Dialog/Window nodes

Inputs: action (required), nodePath (required), size, text, +1 more.

game_ui_rangegame_ui_rangeB

ProgressBar/Slider/SpinBox/ColorPicker get/set

Inputs: action (required), nodePath (required), step, color, +3 more.

game_ui_tabsgame_ui_tabsB

TabContainer/TabBar: get/set current tab

Inputs: action (required), nodePath (required), index, title.

game_ui_textgame_ui_textC

LineEdit/TextEdit/RichTextLabel text operations

Inputs: action (required), nodePath (required), text, selectionTo, +2 more.

game_ui_themegame_ui_themeC

Apply theme overrides to a Control node

Inputs: nodePath (required), overrides (required).

game_ui_treegame_ui_treeC

Tree control: get/select/collapse/add/remove items

Inputs: action (required), nodePath (required), text, column, +1 more.

game_videogame_videoA

Video playback control: play, pause, stop, seek on VideoStreamPlayer

Inputs: action (required), loop, name, volume, +5 more.

game_viewportgame_viewportC

Create or configure a SubViewport node

Inputs: msaa, name, width, action, +4 more.

game_visual_shadergame_visual_shaderC

Create and edit VisualShader graphs: add/connect/disconnect nodes

Inputs: action (required), toNode, toPort, fromNode, +6 more.

game_waitgame_waitB

Wait N frames in the running game

Inputs: frames.

game_websocketgame_websocketC

WebSocket client connect/disconnect/send messages

Inputs: action (required), url, message.

game_windowgame_windowB

Get/set window size, fullscreen, title, position

Inputs: title, vsync, width, action, +4 more.

game_world_settingsgame_world_settingsB

Get/set gravity, physics FPS, and world settings

Inputs: action, gravity, physicsFps, gravityDirection.

get_debug_outputget_debug_outputA

Get the current debug output and errors

Inputs: no named parameters.

get_godot_versionget_godot_versionA

Get the installed Godot version

Inputs: no named parameters.

get_project_infoget_project_infoB

Retrieve metadata about a Godot project

Inputs: projectPath (required).

get_uidget_uidB

Get the UID for a specific file in a Godot project (for Godot 4.4+)

Inputs: filePath (required), projectPath (required).

godot_api_docGet class documentationA

Read-only

Return the reference documentation for a Godot class: inheritance, description, methods, properties, signals and constants.

Inputs: class_name (required), members, version, project_root, +1 more.

godot_api_searchSearch API docsC

Read-only

Search the Godot class reference for the target version: matches class names, brief descriptions, and method/member/signal names. Returns ranked hits.

Inputs: query (required), limit, version, project_root, +1 more.

godot_buildBuild (import resources)A

Import/reimport the project headlessly, compiling scripts and generating the .godot cache. Surfaces script and scene errors. This is the Godot equivalent of a compile check.

Inputs: version, project_root, response_format.

godot_cleanClean projectA

Destructive

Remove generated artifacts: the .godot cache, legacy .import folder, and optionally the export/ output.

Inputs: project_root, include_exports.

godot_create_resourceCreate resourceB

Create a new resource from a template: a GDScript (gdscript) or C# (csharp) script, a scene (scene) or a generic resource (resource). Fails if the target exists unless overwrite=true.

Inputs: kind (required), resource (required), base, overwrite, +4 more.

godot_doctorDiagnose setupA

Read-only

Run diagnostics: confirm a usable editor binary, version alignment with the project, export template availability, and whether the project imports cleanly.

Inputs: version, project_root, response_format.

godot_engine_commandRaw engine commandA

Send a raw JSON command to the godot_mcp bridge (advanced). Supported commands: ping, info, scene_tree, eval, set_property, reload, screenshot, quit. Payload is merged into the request.

Inputs: command (required), game_id, payload.

godot_engine_infoEngine infoA

Read-only

Query a running game via its bridge: engine version, FPS, frame count, current scene and node count.

Inputs: game_id, response_format.

godot_evalEvaluate GDScriptA

Run GDScript in the running game and return the result as a string. The code is compiled as a real script, so autoload singletons (e.g. GameState), method calls and await all work. A bare expression is auto-wrapped to return its value; multi-line code should return explicitly. The locals tree (SceneTree), root (Window) and scene (current scene) are provided. Examples: "GameState.last_health", "scene.get_node("Player").position", "return await some_node.some_async()".

Inputs: expression (required), game_id, response_format.

godot_exportExport bundleA

Export a project using a preset from export_presets.cfg. Mode "release"/"debug" produce a runnable bundle; "pack" produces a .pck/.zip data pack. With no preset, lists the available presets.

Inputs: mode, output, preset, version, +2 more.

godot_find_referencesFind referencesA

Read-only

Find resources that reference a given resource, by scanning scenes, resources and scripts for its res:// path, filename, UID, or preload/load usage.

Inputs: resource (required), limit, offset, project_root, +1 more.

godot_game_logsGame logsB

Read-only

Return recent stdout/stderr from a running or finished game.

Inputs: lines, stream, game_id, response_format.

godot_get_settingsGet project settingsB

Read-only

List project.godot settings as section/key/value entries, optionally filtered to one section.

Inputs: limit, offset, section, project_root, +1 more.

godot_hot_reloadHot reloadA

Reload GDScript files and/or the current scene in the running game without restarting it. Pass script res:// paths to reload, and/or reload_scene=true to reinstantiate the current scene.

Inputs: game_id, scripts, reload_scene, response_format.

godot_install_bridgeInstall bridge addonA

Idempotent

Install (or refresh) the godot_mcp live-control bridge addon and its autoload in the project. Normally handled by godot_setup or godot_run, but available explicitly.

Inputs: project_root.

godot_list_addonsList addonsA

Read-only

List installed editor addons under addons/, with their plugin.cfg metadata and enabled state.

Inputs: project_root, response_format.

godot_list_gamesList gamesA

Read-only

List all launched games this session, running and exited, with their handles and status.

Inputs: response_format.

godot_list_resourcesList resourcesA

Read-only

List project resources as res:// paths, optionally filtered by extension (e.g. ".tscn", ".gd"). Skips .godot/ and .gdignore-marked folders.

Inputs: limit, offset, extension, project_root, +1 more.

godot_parse_resourceParse resourceA

Read-only

Parse a resource into structured JSON-ish output. Scenes (.tscn) and resources (.tres) yield their node tree, ext/sub resources and connections; scripts (.gd/.cs) yield an outline of classes, functions, signals, exports and variables.

Inputs: resource (required), project_root, response_format.

godot_project_infoProject infoA

Read-only

Summarise a Godot project: name, target engine version, main scene, autoloads, input actions, enabled features and a resource-type breakdown.

Inputs: project_root, response_format.

godot_runRun gameB

Launch the project (or a specific scene) as a child process and return a handle. With live=true the godot_mcp bridge is enabled (auto-installed if needed) so you can inspect the scene tree, eval expressions, hot reload and screenshot the running game.

Inputs: live, scene, version, headless, +5 more.

godot_scene_treeLive scene treeA

Read-only

Dump the live scene tree of a running game (node names, types and attached scripts).

Inputs: game_id, max_depth, response_format.

godot_screenshotScreenshot gameB

Read-only

Capture the current frame of a running game (launched with godot_run live=true, non-headless) and return it as an image. Optionally also saves a PNG to disk.

Inputs: embed, output, game_id.

godot_set_node_propertySet node propertyC

Set a property on a node in the running scene by node path (e.g. "Player", "Player/Sprite2D").

Inputs: node (required), value (required), property (required), game_id, +1 more.

godot_set_settingSet project settingA

Idempotent

Set or add a setting in project.godot. The section is created if missing. Use type="raw" to write a Godot literal verbatim (e.g. a Vector2 or PackedStringArray).

Inputs: key (required), value (required), section (required), type, +1 more.

godot_setupSet up toolchainA

Idempotent

Provision the Godot toolchain for a project: resolve the target version, download/locate the editor binary, install matching export templates, and (by default) install the godot_mcp live-control bridge addon. Safe to run repeatedly.

Inputs: version, project_root, install_bridge, response_format, +1 more.

godot_stopStop gameA

Idempotent

Terminate a running game by handle (or the only running game). Attempts a clean bridge quit before SIGTERM/SIGKILL.

Inputs: game_id, response_format.

godot_validate_scriptValidate scriptA

Read-only

Parse a GDScript file headlessly with --check-only and report any parse/compile errors without running the game.

Inputs: script (required), version, project_root, response_format.

launch_editorlaunch_editorB

Launch Godot editor for a specific project

Inputs: projectPath (required).

list_project_fileslist_project_filesB

List project files, optionally filtered by extension

Inputs: projectPath (required), extensions, subdirectory.

list_projectslist_projectsB

List Godot projects in a directory

Inputs: directory (required), recursive.

load_spriteload_spriteC

Load a sprite into a Sprite2D node

Inputs: nodePath (required), scenePath (required), projectPath (required), texturePath (required).

manage_autoloadsmanage_autoloadsA

Add, remove, or list autoloads in a Godot project

Inputs: action (required), projectPath (required), name, path.

manage_ci_pipelinemanage_ci_pipelineC

Create/read GitHub Actions workflow for automated Godot exports

Inputs: action (required), projectPath (required), platforms, godotVersion.

manage_docker_exportmanage_docker_exportC

Create Dockerfile for headless Godot export

Inputs: action (required), projectPath (required), baseImage, exportPreset, +1 more.

manage_export_presetsmanage_export_presetsB

Create or modify export preset configuration

Inputs: action (required), projectPath (required), name, platform, +1 more.

manage_input_mapmanage_input_mapB

Add, remove, or list input actions and bindings

Inputs: action (required), projectPath (required), key, deadzone, +1 more.

manage_layersmanage_layersC

List/set named layer definitions in project

Inputs: action (required), projectPath (required), name, layer, +1 more.

manage_pluginsmanage_pluginsB

List/enable/disable editor plugins

Inputs: action (required), projectPath (required), pluginName.

manage_resourcemanage_resourceC

Read or modify .tres/.res resource files

Inputs: action (required), projectPath (required), resourcePath (required), properties.

manage_scene_signalsmanage_scene_signalsB

List/add/remove signal connections in .tscn files

Inputs: action (required), scenePath (required), projectPath (required), method, +3 more.

manage_scene_structuremanage_scene_structureB

Rename/duplicate/move nodes within .tscn scenes

Inputs: action (required), nodePath (required), scenePath (required), projectPath (required), +2 more.

manage_shadermanage_shaderB

Create or read .gdshader files

Inputs: action (required), shaderPath (required), projectPath (required), source, +1 more.

manage_theme_resourcemanage_theme_resourceB

Create/read/modify Theme .tres resources

Inputs: action (required), projectPath (required), resourcePath (required), properties.

manage_translationsmanage_translationsB

List/add/remove translation files in project

Inputs: action (required), projectPath (required), translationPath.

modify_project_settingsmodify_project_settingsC

Modify a project.godot setting

Inputs: key (required), value (required), section (required), projectPath (required).

modify_scene_nodemodify_scene_nodeC

Modify node properties in a scene file (headless)

Inputs: nodePath (required), scenePath (required), properties (required), projectPath (required).

read_fileread_fileB

Read a text file from a Godot project

Inputs: filePath (required), projectPath (required).

read_project_settingsread_project_settingsA

Read project.godot as structured JSON

Inputs: projectPath (required).

read_sceneread_sceneA

Read scene file as JSON node tree (headless)

Inputs: scenePath (required), projectPath (required).

remove_scene_noderemove_scene_nodeC

Remove a node from a scene file (headless)

Inputs: nodePath (required), scenePath (required), projectPath (required).

rename_filerename_fileB

Rename or move a file within the project

Inputs: newPath (required), filePath (required), projectPath (required).

run_projectrun_projectB

Run the Godot project and capture output

Inputs: projectPath (required), scene.

save_scenesave_sceneB

Save changes to a scene file

Inputs: scenePath (required), projectPath (required), newPath.

set_main_sceneset_main_sceneC

Set the main scene in project.godot

Inputs: scenePath (required), projectPath (required).

stop_projectstop_projectB

Stop the currently running Godot project

Inputs: no named parameters.

update_project_uidsupdate_project_uidsB

Update UID references by resaving resources (4.4+)

Inputs: projectPath (required).

write_filewrite_fileB

Create or overwrite a text file in a Godot project

Inputs: content (required), filePath (required), projectPath (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

C2.7/5.0

Scored 2026-09-09 18:15 across 182 tools

Disambiguation1/5

There are direct duplicates such as game_eval/godot_eval, game_get_scene_tree/godot_scene_tree, game_screenshot/godot_screenshot, and game_set_property/godot_set_node_property, plus overlapping log/project-setting/export tools. An agent selecting among 182 tools would frequently pick the wrong one.

Naming Consistency3/5

Everything is snake_case and grouped by prefixes like game_, godot_, manage_, and create_, which is readable. However, conventions are mixed: many game_* tools use noun phrases (game_ui_menu, game_render_settings, game_3d_effects) instead of verb_noun, and equivalent operations are named inconsistently across the game_ and godot_ families.

Tool Count1/5

182 tools is an extreme count for a single server, even for a broad engine like Godot, and most of the surface is created by two overlapping tool generations. The count is far beyond what an agent can reliably navigate.

Completeness5/5

The combined surface covers project lifecycle, file/scene/resource CRUD, input mapping, autoloads, export presets, running-game inspection and control, UI, audio, 2D/3D, physics, networking, and CI. There are no obvious dead ends for the server's apparent scope.

Maintenance

ActivityInactive

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

Shiny Gen
ai.shinygen
AI game maker: build, run, screenshot and play-test Godot and retro console games in a live project
Games & Gamification Developer Tools Code Execution
1
https://mcp.shinygen.ai/mcp
FileaifyA
com.fileaify
Project memory, documentation and controlled secret access for AI coding agents.
Knowledge & Memory Documentation Access Security
431
https://fileaify.com/mcp
Krtuworks Partner
com.krtuworks
Run your Krtuworks apps from an AI agent: setup, remote config, stats, players, bug reports.
Games & Gamification Developer Tools Monitoring
1
https://mcp.krtuworks.com/dev
Hexis
io.github.Bevel-Software
Git-backed platform for skills, tools, and context for AI agents
Agent Orchestration Developer Tools
1126
https://demo.bevel.software/api/mcp

Related MCP Servers

Godot MCP
Developer Tools Autonomous Agents Code Execution
MhrnMhrn
A
license
A
quality
D
maintenance
Enables AI agents to create, edit, and run Godot 4.5+ games by providing tools for project scaffolding, scene manipulation, and engine interaction. It supports full game development workflows including node editing, script attachment, and project execution with debugging capabilities.
Updated 7 months ago (2026-04-01 14:25 UTC)
24
5
MIT
Godot MCP Extended
Developer Tools Games & Gamification Code Execution
ibnutoriq
A
license
A
quality
D
maintenance
Enables AI agents to launch, edit, debug, and test Godot game projects with comprehensive scene and script manipulation tools.
Updated 5 months ago (2026-06-21 18:46 UTC)
50
1
MIT
Godot MCP Flash
Developer Tools Games & Gamification Code Analysis
gurolayanlar
A
license
B
quality
C
maintenance
Enables AI agents to inspect, modify, run, and debug Godot projects, including scene and script analysis, editor and project management, and visual verification through screenshots.
Updated 2 months ago (2026-09-12 18:03 UTC)
22
19 npm
14
MIT
godot-mcp
Games & Gamification Developer Tools
Sovr23
A
license
A
quality
C
maintenance
Enables AI agents to launch and control the Godot game engine, run projects, capture debug output, and manage scenes and project configurations.
Updated 2 months ago (2026-09-07 21:10 UTC)
14
187 npm
MIT

godot-mcp-server

Contents

Features

Requirements

Install

Configuration

CLI options

Environment variables

Tools

The live-control bridge

Full-control tool suite

Desktop app

Architecture

Development

Credits

License

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Godot MCP

Godot MCP Extended

Godot MCP Flash

godot-mcp