# io.github.tomyud1/godot-mcp (npm · godot-mcp-server)

MCP server for Godot game engine integration — control the Godot editor with AI

- Trust score: 61/100 (medium)
- Change this week: +9
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `godot-mcp-server`: 61/100 (this document), [markdown](https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server.md), [page](https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `godot-mcp-server`
- Version: `0.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 70/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects @modelcontextprotocol/sdk 1.25.3, a direct dependency. A fixed version is available.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (93 of 97), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 103 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 81/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 8537 tokens (~121/item across 70 items; 65 tools + 5 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 93% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add tomyud1-godot-mcp -- npx -y godot-mcp-server
```

### Codex

```bash
codex mcp add tomyud1-godot-mcp -- npx -y godot-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tomyud1-godot-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "godot-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add tomyud1-godot-mcp --command npx --arg -y --arg godot-mcp-server
```

### Hermes

```yaml
mcp_servers:
  tomyud1-godot-mcp:
    command: "npx"
    args: ["-y", "godot-mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "tomyud1-godot-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "godot-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 61, +36)

- [security regression] CVE-2026-25536 affects this package: high
- [security regression] GHSA-frvp-7c67-39w9 affects this package: high
- [security regression] Provenance: unverified → fail
- [security regression] Known CVEs: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → good
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional] Licence: MIT

### 2026-07-31 (score 25, −27)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-27 (score 52)

First indexed and scored.

## MCP tools (65)

### `get_godot_status` (~23 tokens)

Check if Godot editor is connected to the MCP server.

### `get_guide` (~155 tokens)

Read a short markdown guide from the server. Same content as the MCP resources/read protocol, exposed as a tool so it works in MCP clients that do not support resources (e.g. Claude Desktop, Cursor chat). Call with no args to list available guides: testing-loop, scene-editing, asset-generation, troubleshooting, tool-index. Call with {slug: "..."} to get the full markdown. Useful when a workflow is non-obvious (testing a running game, choosing between scene-editing tools, troubleshooting "Runtime helper not connected", etc.).

Input parameters:

- `slug` (string): Guide slug. Omit to list all available guides. Known slugs: testing-loop, scene-editing, asset-generation, troubleshooting, tool-index.

### `list_dir` (~56 tokens)

List files and folders under a Godot project path (e.g., res://). Returns arrays of files and folders in the specified directory.

Input parameters:

- `root` (string, required): Starting path like res://addons/ai_assistant or res://

### `read_file` (~103 tokens)

Read a text file from the Godot project, optionally a specific line range. Useful for reading GDScript files, scene files, or any text-based content.

Input parameters:

- `end_line` (number): Inclusive end line; 0 or missing means to end of file (optional)
- `path` (string, required): res:// path to the file (e.g., res://scripts/player.gd)
- `start_line` (number): 1-based inclusive start line (optional)

### `search_project` (~72 tokens)

Search the Godot project for a substring and return file hits with line numbers. Useful for finding usages of functions, variables, or any text pattern.

Input parameters:

- `glob` (string): Optional glob filter like **/*.gd to search only GDScript files
- `query` (string, required): Case-insensitive substring to find

### `create_script` (~114 tokens)

Create a NEW GDScript file (.gd) that does not exist yet. Use this for creating new scripts, NOT for editing existing files (use edit_script for edits). Use classdb_query to verify unfamiliar Godot class methods. After creating a script, consider using run_scene to test and get_errors to check for issues.

Input parameters:

- `content` (string, required): Full GDScript content to write to the file
- `path` (string, required): Script file path (res://scripts/player.gd) - must not exist yet

### `create_scene` (~225 tokens)

Create a new Godot scene (.tscn) file with nodes. Use this to create player scenes, UI screens, game objects, etc.

Input parameters:

- `attach_script` (string): Optional script path to attach to root node (res://path/to/script.gd)
- `nodes` (array): Array of child nodes to add. Each node spec: {name|node_name, type|node_type, properties?, script?, groups?, children?}. Use either {name, type} or the same {node_name, node_type} keys used at the to…
- `root_node_name` (string): Name of root node (default: derived from filename)
- `root_node_type` (string, required): Type of root node (e.g., Node2D, CharacterBody2D, Control, Node3D). REQUIRED.
- `scene_path` (string, required): Scene file path (e.g., res://Scenes/player.tscn)

### `read_scene` (~73 tokens)

Read and parse a scene file to get its full node structure and properties. Use this to understand a scene before editing.

Input parameters:

- `include_properties` (boolean): Include node properties in the output (default: false)
- `scene_path` (string, required): Path to the scene file (res://path/to/scene.tscn)

### `add_node` (~313 tokens)

Add a node to an existing scene file. Supports an optional script attachment, group memberships, and a tree of children created in the same call (1 tool call instead of N). Children format: {name|node_name, type|node_type, properties?, script?, groups?, children?}. Both key styles are accepted so children can reuse the same keys you use at the top level (node_name, node_type) or the shorter form (name, type). Unknown child keys are rejected with a clear error.

Input parameters:

- `children` (array): Optional tree of children to create under the new node. Each entry has the same shape as add_node's args (minus parent_path). Use this to build sub-trees in one call.
- `groups` (array): Optional list of node groups this node should belong to. Persisted to the .tscn file.
- `node_name` (string, required): Name for the new node
- `node_type` (string, required): Type of node (e.g., Sprite2D, Camera2D, RigidBody2D, CollisionShape2D)
- `parent_path` (string): Path to parent node (. for root, or relative path like Sprite2D)
- `properties` (object): Optional dictionary of properties to set on the node
- `scene_path` (string, required): Path to the scene file (res://path/to/scene.tscn)
- `script` (string): Optional script path to attach to the new node (res://path/to/script.gd)

### `remove_node` (~52 tokens)

Remove a node from an existing scene file.

Input parameters:

- `node_path` (string, required): Path to the node to remove (cannot be root, use relative path)
- `scene_path` (string, required): Path to the scene file

### `modify_node_property` (~404 tokens)

Modify a single property on a node in a .tscn scene file. For multiple properties at once use set_node_properties. ALWAYS use a tool to modify .tscn files — NEVER edit them as text. To attach or change a script, use attach_script (NOT modify_node_property with property="script") — modify_node_property only rewrites the .tscn on disk, leaving the editor's in-memory node without the script, which makes connect_signal fail.

Input parameters:

- `node_path` (string): Path to the node (. for root, or relative path like "Sprite2D")
- `property_name` (string, required): Name of the property to modify (position, scale, rotation, modulate, visible, etc.)
- `scene_path` (string, required): Path to the .tscn scene file
- `value` (required): New value for the property. ANY JSON value accepted: primitives (numbers, strings, booleans, null), arrays, or objects. Use the {type, ...} discriminated form for Godot variant types. Common forms: n…

### `rename_node` (~55 tokens)

Rename a node in a scene.

Input parameters:

- `new_name` (string, required): New name for the node
- `node_path` (string, required): Path to the node to rename
- `scene_path` (string, required): Path to the scene file

### `move_node` (~96 tokens)

Move a node to a different parent in a scene and optionally control its position among siblings.

Input parameters:

- `new_parent_path` (string, required): Path to the new parent node (. for root)
- `node_path` (string, required): Path to the node to move
- `scene_path` (string, required): Path to the scene file
- `sibling_index` (number): Optional position among siblings (0 = first child). Omit or -1 to append.

### `attach_script` (~73 tokens)

Attach or change a script on a node in a scene.

Input parameters:

- `node_path` (string): Path to the node (. for root, or relative path)
- `scene_path` (string, required): Path to the scene file
- `script_path` (string, required): Path to the script file (res://path/to/script.gd)

### `detach_script` (~46 tokens)

Remove a script from a node in a scene.

Input parameters:

- `node_path` (string, required): Path to the node (. for root)
- `scene_path` (string, required): Path to the scene file

### `set_collision_shape` (~168 tokens)

Create and assign a collision shape resource to a CollisionShape2D or CollisionShape3D node. Supports: CircleShape2D, RectangleShape2D, CapsuleShape2D, SphereShape3D, BoxShape3D, etc.

Input parameters:

- `node_path` (string): Path to the CollisionShape2D/3D node
- `scene_path` (string, required): Path to the .tscn scene file
- `shape_params` (object): Shape parameters: {radius: 32} for circles, {size: {x: 64, y: 64}} for rectangles, etc.
- `shape_type` (string, required): Shape type: CircleShape2D, RectangleShape2D, CapsuleShape2D, SphereShape3D, BoxShape3D, etc.

### `set_sprite_texture` (~322 tokens)

Assign a texture resource to a Sprite2D / Sprite3D / TextureRect node in a .tscn scene file. Modes:
  • FromPath  — load any texture file from disk (png/jpg/webp/svg/.tres) via load(). Returns whatever Texture2D the importer produced (usually CompressedTexture2D). Most common after generate_2d_asset.
  • ImageTexture (DEPRECATED ALIAS for FromPath, kept for back-compat)
  • NewImageTexture — force-create an ImageTexture (in-memory) from a raw image file.
  • PlaceholderTexture2D — in-scene placeholder of a given size.
  • GradientTexture2D / NoiseTexture2D — procedural textures.
Response always includes texture_class (the actual Godot class the texture decoded to), width, height, and texture_path so the agent can confirm what landed without an extra get_resource_info call.

Input parameters:

- `node_path` (string): Path to the Sprite2D/Sprite3D/TextureRect node
- `scene_path` (string, required): Path to the .tscn scene file
- `texture_params` (object): Texture parameters. FromPath / ImageTexture / NewImageTexture: {path: "res://assets/sprite.png"}. PlaceholderTexture2D: {size: {x: 64, y: 64}}. GradientTexture2D / NoiseTexture2D: {width, height}.
- `texture_type` (string, required): How to obtain the texture. Prefer FromPath for assets on disk.

### `instance_scene` (~200 tokens)

Add an instance of another scene (.tscn) as a child node. This is how you compose scenes from reusable parts (like prefabs). The instance maintains a live reference to the source scene. Use this instead of add_node when you want to reuse an existing scene.

Input parameters:

- `instance_path` (string, required): Path to the .tscn scene to instance (the child/prefab scene)
- `node_name` (string): Optional name for the instance. If omitted, uses the instanced scene's root node name.
- `parent_path` (string): Path to parent node within the scene (. for root, or relative path like Level/Enemies)
- `properties` (object): Optional property overrides on the instance root (e.g., {position: {type: "Vector3", x: 5, y: 0, z: 10}})
- `scene_path` (string, required): Path to the scene file being edited (the parent scene)

### `set_mesh` (~279 tokens)

Create and assign a mesh resource to a MeshInstance3D node. REQUIRED to make 3D geometry visible. Primitive types: BoxMesh, SphereMesh, CylinderMesh, CapsuleMesh, PlaneMesh, PrismMesh, TorusMesh, QuadMesh, TextMesh. Or load from file.

Input parameters:

- `mesh_params` (object): BoxMesh: {size:{x,y,z}}. SphereMesh: {radius,height,radial_segments,rings}. CylinderMesh: {top_radius,bottom_radius,height}. CapsuleMesh: {radius,height}. PlaneMesh: {size:{x,y}}. PrismMesh: {left_to…
- `mesh_type` (string, required): Mesh class: "BoxMesh", "SphereMesh", "CylinderMesh", "CapsuleMesh", "PlaneMesh", "PrismMesh", "TorusMesh", "QuadMesh", "TextMesh", or "file" to load from a resource path
- `node_path` (string): Path to the MeshInstance3D node within the scene
- `scene_path` (string, required): Path to the .tscn scene file

### `set_material` (~205 tokens)

Create and assign a material to a MeshInstance3D, CSG, or GeometryInstance3D node. Supports StandardMaterial3D or loading from file.

Input parameters:

- `material_params` (object): StandardMaterial3D: {albedo_color:{r,g,b,a}, metallic:0-1, roughness:0-1, emission:{r,g,b}, emission_energy:float, transparency:0=disabled/1=alpha/2=scissor/3=hash/4=depth_pre_pass}. file: {path:"res…
- `material_type` (string, required): "StandardMaterial3D" or "file" to load from a resource path
- `node_path` (string): Path to the target node
- `scene_path` (string, required): Path to the .tscn scene file
- `surface_index` (number): For MeshInstance3D only: surface index for per-surface override. Omit for material_override on all surfaces.

### `get_node_spatial_info` (~128 tokens)

Query computed 3D spatial data for a Node3D in a scene file. Returns local/global positions, scales, rotation quaternions, and subtree bounding boxes (AABB) when available. Use this before making precise 3D placement decisions.

Input parameters:

- `include_bounds` (boolean): Include computed subtree AABBs when visual descendants exist (default: true)
- `node_path` (string): Path to the Node3D (. for root, or relative path like Level/Props/Crate)
- `scene_path` (string, required): Path to the .tscn scene file

### `measure_node_distance` (~88 tokens)

Measure the world-space distance between two Node3D nodes in a scene file. Returns both the full 3D delta and the horizontal XZ distance.

Input parameters:

- `from_node_path` (string, required): Path to the first Node3D
- `scene_path` (string, required): Path to the .tscn scene file
- `to_node_path` (string, required): Path to the second Node3D

### `snap_node_to_grid` (~153 tokens)

Snap a Node3D position to a grid in local or global space. Useful for modular level building and keeping 3D scenes aligned.

Input parameters:

- `axes` (array): Axes to snap. Any of: ["x"], ["x","z"], ["x","y","z"] (default: all axes)
- `grid_size` (required): Positive grid size. Use a number for uniform snapping or {x,y,z} for per-axis snapping.
- `node_path` (string): Path to the Node3D to snap
- `scene_path` (string, required): Path to the .tscn scene file
- `space` (string): Coordinate space: "local" or "global" (default: "global")

### `set_node_properties` (~151 tokens)

Set MULTIPLE properties on a node in a single tool call. Non-atomic: each property is applied independently; the response separates "applied" from "failed" so partial success surfaces clearly. Saves the scene once at the end. Resource-typed properties must use set_resource_property / set_sprite_texture / etc.

Input parameters:

- `node_path` (string): Path to the node (. for root, or relative path)
- `properties` (object, required): Map of property_name -> value. Each value follows the same form as modify_node_property.value (primitives, arrays, or {type:"Vector3",...} discriminated objects).
- `scene_path` (string, required): Path to the .tscn scene file

### `set_node_groups` (~124 tokens)

Set, add, or remove a node's group memberships in a .tscn scene file. Groups persist to disk so the running game can call get_tree().get_nodes_in_group(name).

Input parameters:

- `groups` (array, required): List of group names to apply
- `mode` (string): replace (default): node ends up in EXACTLY the listed groups. add: union with existing. remove: drop the listed groups.
- `node_path` (string): Path to the node (. for root)
- `scene_path` (string, required): Path to the .tscn scene file

### `get_node_groups` (~42 tokens)

Read the list of groups a node belongs to in a .tscn scene file.

Input parameters:

- `node_path` (string)
- `scene_path` (string, required)

### `find_nodes_in_group` (~76 tokens)

Find every node in a .tscn that belongs to a given group. Returns paths, names, and types. Useful for verifying that level.gd will actually pick up the right nodes via get_tree().get_nodes_in_group().

Input parameters:

- `group` (string, required): Group name to search for
- `scene_path` (string, required)

### `set_resource_property` (~200 tokens)

Modify a property on a Resource that is currently held by a node (or by another resource attached to that node). Use this to tweak shape radii, material colors, gradient stops, etc., WITHOUT recreating the resource. resource_path walks from the node down to the resource using "/"-separated property names, e.g. "shape", "material", or "material/next_pass". After the change, saves the scene.

Input parameters:

- `node_path` (string): Path to the node owning the resource
- `property_name` (string, required): Property on the target resource to set (e.g. "radius", "albedo_color")
- `resource_path` (string, required): Path from node to the target resource via property names. Examples: "shape", "material", "material/next_pass"
- `scene_path` (string, required): Path to the .tscn scene file
- `value` (required): New value (same shape as modify_node_property.value)

### `save_resource_to_file` (~147 tokens)

Save a Resource currently held by a node (or sub-resource) to a standalone .tres file so it can be referenced by other scenes / shared / committed. The node's property is then re-pointed to the loaded-from-disk version, so future set_resource_property calls write through to that file. Works for any Resource subclass: Material, Mesh, Shape, Curve, Gradient, etc.

Input parameters:

- `node_path` (string)
- `resource_path` (string, required): Path from node to the resource (e.g. "shape", "material")
- `save_to` (string, required): Destination path (res://.../foo.tres)
- `scene_path` (string, required)

### `get_resource_info` (~272 tokens)

Inspect ANY Godot Resource. Two modes:
  • path mode: pass {path: "res://foo.png"} for a resource on disk (.tres / .res / image / .glb / .ogg / .tscn / etc.)
  • node mode: pass {scene_path, node_path, resource_property} to inspect a resource attached to a node WITHOUT having to save it as .tres first (e.g. the shape on a CollisionShape2D, the material on a MeshInstance3D, the stream on an AudioStreamPlayer).
Returns class, file size (path mode), and type-specific info: width/height for textures, vertex/surface counts and AABB for meshes, length for AudioStream/Animation, node count for PackedScene, common Material properties, Shape extents, and the resource's dependencies.

Input parameters:

- `node_path` (string): Node mode: path to the node within the scene.
- `path` (string): Path mode: resource path on disk (res://...).
- `resource_property` (string): Node mode: property name on the node holding the resource (e.g. "shape", "material", "stream", "texture").
- `scene_path` (string): Node mode: path to the .tscn that owns the node.

### `list_signal_connections` (~193 tokens)

List signal connections involving a node. source="scene_file" (default) reads connections persisted to a .tscn. source="runtime" requires the game to be running and reads live connections from the SceneTree. Use the runtime mode to verify dynamically-connected signals (those connected from code in _ready, not in the editor).

Input parameters:

- `include_incoming` (boolean): Include signals from other nodes whose handler is on this node (default: true). Only honored for scene_file source.
- `include_outgoing` (boolean): Include signals that this node emits (default: true)
- `node_path` (string, required): Path to the node. For source="runtime" use absolute (/root/Main/Player) or relative to current_scene.
- `scene_path` (string): For source="scene_file": path to the .tscn
- `source` (string): Where to read connections from. Default: scene_file

### `connect_signal` (~188 tokens)

Connect a signal between two nodes inside a .tscn scene file. The target script must define the method (will refuse otherwise). Equivalent to clicking the "+" in the editor's Node > Signals panel and persists the connection to the .tscn. NOTE: scripts must be attached via attach_script (NOT via modify_node_property), otherwise the editor's in-memory node will not see the script and this tool will reject the connection.

Input parameters:

- `flags` (number): Connection flags (CONNECT_DEFERRED=1, CONNECT_PERSIST=2, CONNECT_ONE_SHOT=4). Default 0.
- `from_node` (string, required): Path to the emitting node
- `method` (string, required): Method name on the receiving node's script
- `scene_path` (string, required)
- `signal` (string, required): Signal name on the emitting node
- `to_node` (string, required): Path to the receiving node

### `disconnect_signal` (~66 tokens)

Remove a signal connection from a .tscn scene file. No-op if the connection doesn't exist.

Input parameters:

- `from_node` (string, required)
- `method` (string, required)
- `scene_path` (string, required)
- `signal` (string, required)
- `to_node` (string, required)

### `edit_script` (~153 tokens)

Apply a SMALL, SURGICAL code edit (1-10 lines) to GDScript files. Auto-applies changes. For large changes, call multiple times. ONLY for .gd files - NEVER for .tscn scene files. Use classdb_query to verify unfamiliar Godot class methods. After making changes, consider using run_scene to test and get_errors to check for issues.

Input parameters:

- `edit` (object, required): Edit spec: {type: "snippet_replace", file: "res://path.gd", old_snippet: "old code", new_snippet: "new code", context_before: "line above", context_after: "line below"}. Keep old_snippet SMALL (1-10…

### `validate_script` (~64 tokens)

Validate a GDScript file for syntax errors using Godot's built-in parser. Call after creating or modifying scripts to ensure they are error-free.

Input parameters:

- `path` (string, required): Path to the GDScript file to validate (e.g., res://scripts/player.gd)

### `create_folder` (~34 tokens)

Create a directory (with parent directories if needed).

Input parameters:

- `path` (string, required): Directory path (res://path/to/folder)

### `delete_file` (~281 tokens)

Permanently delete a file from the project. REQUIRES confirm=true as an explicit safety gate — omitting confirm returns an error. Creates a .bak backup alongside the original by default (disable with create_backup=false). REFUSES if the file is currently open in the editor (any scene tab or script editor tab); close the tab first, or pass force=true to bypass the check (not recommended — deleting the active scene out from under the editor can crash Godot). Use ONLY when deletion is explicitly requested; NEVER as a way to "edit" or "reset" a file (use edit_script instead). Does not delete directories.

Input parameters:

- `confirm` (boolean, required): REQUIRED. Must be explicitly set to true — safety gate to prevent accidental deletes. Calls without confirm=true fail with an error.
- `create_backup` (boolean): If true (default), saves a .bak copy next to the original before deletion so the file can be recovered. Set false to delete without backup.
- `force` (boolean): If true, bypass the "file is open in editor" guard. Use ONLY if you know the file is not the active scene. The guard exists because deleting the active scene tab from under the editor can crash Godot.
- `path` (string, required): Path to the file to delete (e.g. res://scenes/old.tscn)

### `rename_file` (~61 tokens)

Rename or move a file, optionally updating references in other files.

Input parameters:

- `new_path` (string, required): New file path
- `old_path` (string, required): Current file path
- `update_references` (boolean): Update references in other files (default: true)

### `list_scripts` (~21 tokens)

List all GDScript files in the project with basic metadata.

### `get_project_settings` (~53 tokens)

Concise project settings summary: main_scene, window size/stretch, physics tick rate, and render basics.

Input parameters:

- `include_physics` (boolean): Include physics settings
- `include_render` (boolean): Include render settings

### `get_input_map` (~136 tokens)

Return the full InputMap: built-in actions (ui_*, spatial_editor/*) plus all project-defined actions from project.godot. Each action maps to an object with "events" (array of key/mouse/gamepad bindings) and optionally "deadzone". Use this before configure_input_map to see current bindings and deadzones.

Input parameters:

- `include_deadzones` (boolean): Include the per-action "deadzone" field in each action object (default: true). When true, each action is {"deadzone": 0.5, "events": [...]}. When false, each action is {"events": [...]}.

### `get_collision_layers` (~24 tokens)

Return named 2D/3D physics collision layers from ProjectSettings.

### `get_node_properties` (~74 tokens)

Get available properties for a Godot node type. Use this to discover what properties exist on a node type (e.g., anchors_preset for Control, position for Node2D).

Input parameters:

- `node_type` (string, required): Node class name (e.g., "Sprite2D", "Control", "Label", "Button")

### `get_console_log` (~40 tokens)

Return the latest lines from the Godot editor output log.

Input parameters:

- `max_lines` (number): Maximum number of lines to include (default: 50)

### `get_errors` (~106 tokens)

Get errors and warnings from both the Godot Output panel and the Debugger > Errors tab. Returns file paths, line numbers, severity, stack traces, and which source each error came from. If errors mention a missing method or property, use classdb_query to verify the correct API before fixing.

Input parameters:

- `include_warnings` (boolean): Include warnings in addition to errors (default: true)
- `max_errors` (number): Maximum number of errors to return (default: 50)

### `clear_console_log` (~37 tokens)

Mark the current position in the Godot editor log. Subsequent get_console_log and get_errors calls will only return output after this point.

### `open_in_godot` (~52 tokens)

Open a file in the Godot editor at a specific line (side-effect only).

Input parameters:

- `line` (number): 1-based line number
- `path` (string, required): res:// path to open

### `scene_tree_dump` (~33 tokens)

Dump the scene tree of the scene currently open in the Godot editor (node names, types, and attached scripts).

### `list_settings` (~132 tokens)

Browse Godot project settings by category. Returns values from the editor's in-memory state — this matches project.godot after a normal Godot save, but direct edits to project.godot on disk are not reflected until the editor restarts (rescan_filesystem does not help). Call without a category to see all available categories. Call with a category to see all settings with their current values, types, and valid options.

Input parameters:

- `category` (string): Settings category prefix (e.g., "display", "physics", "rendering", "application", "audio"). Omit to list all available categories.

### `update_project_settings` (~122 tokens)

Update one or more Godot project settings. Pass a dictionary of setting paths to their new values. Use list_settings first to discover available setting paths, current values, and valid options for a category. For input action bindings, prefer configure_input_map — if you do pass input/* keys here, partial updates are merged safely (existing events are preserved).

Input parameters:

- `settings` (object, required): Dictionary of setting paths to new values (e.g., {"display/window/size/viewport_width": 1920, "display/window/size/viewport_height": 1080})

### `configure_input_map` (~214 tokens)

Add, remove, or replace input actions and their key/button bindings. Use get_input_map to see current actions before modifying.

Input parameters:

- `action` (string, required): Input action name (e.g., "move_left", "jump", "attack")
- `deadzone` (number): Action deadzone (default: 0.5)
- `events` (array): Input events to bind. Each object needs a "type" field: {"type":"key","key":"Space"} for keyboard, {"type":"mouse_button","button_index":1} for mouse (1=left,2=right,3=middle), {"type":"joypad_button…
- `operation` (string, required): "add" to create action and/or append events, "remove" to delete the action entirely, "set" to replace all events on an action (creates it if needed)

### `run_scene` (~312 tokens)

Launch a scene in the Godot editor. By default the call BLOCKS until the editor flips to playing state (so the next get_errors / take_screenshot / send_input call sees a real game). The response includes started, runtime_connected, wait_for_started_ms, wait_for_runtime_ms, scene_path, and runtime_root. Use runtime_root (e.g. "/root/Main") as the prefix for query_runtime_node node_path arguments — it is computed from the actual root node name in the .tscn, NOT from the file name. Set wait_for_runtime=true to additionally wait for the in-game MCPRuntime helper to connect (required before take_screenshot / send_input will work). Recommended testing loop: run_scene({wait_for_runtime:true}) → query_runtime_node / send_input / take_screenshot → get_errors → stop_scene.

Input parameters:

- `block_until_started` (boolean): Wait until the editor reports playing=true before returning (default: true). Up to startup_timeout_ms.
- `scene` (string): Scene to run: omit for main scene, "current" for the currently open scene, or a res:// path for a specific scene
- `startup_timeout_ms` (number): Max time in ms to wait for the above signals. Default: 10000. Bump to 15000–20000 on slower machines or autoload-heavy projects.
- `wait_for_runtime` (boolean): Wait until the MCPRuntime in-game helper connects back (required for take_screenshot/send_input). Default: false.

### `stop_scene` (~33 tokens)

Stop the currently running scene in the Godot editor. Always stop the scene before editing code to avoid errors repeating every frame.

### `is_playing` (~39 tokens)

Compatibility shim: returns {playing, scene}. For richer info (uptime, runtime helper connectivity, last-launched target) prefer get_runtime_status.

### `get_runtime_status` (~64 tokens)

Combined editor + runtime status snapshot. Returns playing, playing_scene, last_launched ("current"|"main"|res-path), uptime_ms since the most recent run_scene, and runtime_helper_connected (true once the in-game MCPRuntime autoload is talking to the MCP server).

### `wait` (~87 tokens)

Sleep server-side. Useful between input events to let the game process them. Capped at 30000ms / 30s. Pass either ms or seconds (ms wins if both given).

Input parameters:

- `ms` (number): Milliseconds to wait (1..30000).
- `seconds` (number): Seconds to wait (0.001..30). Convenient when the agent is thinking in seconds.

### `take_screenshot` (~152 tokens)

Capture the current viewport of the running game and save it as a PNG. REQUIRES the game to be running with the MCPRuntime autoload connected (run_scene with wait_for_runtime=true first). Returns resource_path, absolute_path, width, height, and (optionally) base64_png. Default save location is res://addons/godot_mcp/cache/screenshots/.

Input parameters:

- `return_base64` (boolean): Also include the PNG bytes inline as base64 (default: false). Useful when the agent has no filesystem access.
- `save_to` (string): Optional res:// or user:// destination path. Defaults to res://addons/godot_mcp/cache/screenshots/screenshot_<ms>.png

### `send_input` (~221 tokens)

Synthesize an InputEvent and dispatch it to the running game via Input.parse_input_event. REQUIRES the game to be running with the MCPRuntime autoload connected. Use this to drive automated tests: click buttons, press keys, fire input actions. For multi-step interactions, alternate send_input → wait → query_runtime_node / take_screenshot.

Input parameters:

- `event` (object, required): InputEvent descriptor:   Key: {type:"key", key:"Space", pressed:true, shift?:bool, ctrl?:bool, alt?:bool} or {type:"key", keycode:32, pressed:true}   Mouse button: {type:"mouse_button", button_index:…

### `query_runtime_node` (~178 tokens)

Query a live node in the running scene tree. REQUIRES the game to be running with the MCPRuntime autoload connected. Returns class, path, valid, groups, and a map of property values. By default returns position, global_position, rotation, scale, visible, modulate — pass `properties:["..."]` to override. Set include_children=true to also list direct child nodes.

Input parameters:

- `include_children` (boolean): List direct children {name, class}. Default: false.
- `include_groups` (boolean): Include the node's group memberships. Default: true.
- `node_path` (string, required): Absolute path (e.g. /root/Main/Player) or relative to current_scene.
- `properties` (array): Property names to read. Default: position, global_position, rotation, scale, visible, modulate.

### `get_runtime_log` (~143 tokens)

Return entries from the MCPRuntime in-game ring buffer. The buffer holds the last ~500 lines pushed via MCPRuntime.push_runtime_log(level, text) from your scripts plus internal connection events. For full engine stdout (script prints, errors, warnings) use get_console_log — the editor already captures the running game's stdout. Returns entries with ts_ms, level, and text plus started_at_ms (when the helper started) and now_ms.

Input parameters:

- `limit` (number): Maximum entries to return (default: 200, max 500)
- `since_ms` (number): Only return entries with ts_ms >= since_ms. Use 0 (default) for all.

### `classdb_query` (~165 tokens)

Query Godot's ClassDB for class information: properties, methods, signals, and inheritance. Use this to verify that a class, method, or property actually exists in the running Godot engine before writing code. Prevents using wrong method names, outdated Godot 3 API, or incorrect signatures.

Input parameters:

- `class_name` (string, required): Godot class name to query (e.g., "CharacterBody2D", "Sprite2D", "Control")
- `include_virtual` (boolean): Include well-known virtual methods like _ready, _process, _input (default: true). Set to false to see only public non-virtual methods.
- `query` (string): What to return: "all" (default), "properties", "methods", or "signals"

### `rescan_filesystem` (~51 tokens)

Trigger a full filesystem rescan in the Godot editor. Use after creating, deleting, or modifying files externally (e.g. from the terminal or another tool). The scan is asynchronous and returns immediately.

### `setup_autoload` (~103 tokens)

Register, unregister, or list autoload singletons. Autoloads are scripts/scenes loaded automatically at project start.

Input parameters:

- `name` (string): Autoload name (e.g., "GameManager", "AudioManager")
- `operation` (string, required): "add" to register, "remove" to unregister, "list" to show all autoloads
- `path` (string): res:// path to the script or scene file (required for "add")

### `generate_2d_asset` (~245 tokens)

Render an SVG to a PNG asset on disk via Image.load_svg_from_buffer. The SVG is rendered directly from bytes — no temp file is created, so concurrent calls are safe and project-rename quirks (user:// rebinding) cannot break it. Returns resource_path, absolute_path, dimensions {width,height}, and the render_scale used.

Input parameters:

- `filename` (string, required): Output filename. ".png" appended if missing.
- `height` (number): Optional desired output height in pixels. Same as width but matched on the height axis. If both width and height are provided, width takes precedence for scale derivation.
- `save_path` (string): Destination directory (default: res://assets/generated/). Created if it does not exist.
- `scale` (number): Optional explicit render scale (e.g. 2.0 = 2x). Overrides width/height-derived scaling. Default: 1.0.
- `svg_code` (string, required): Complete SVG markup. Either single or double quotes are accepted in attributes.
- `width` (number): Optional desired output width in pixels. Combined with the SVG's intrinsic width to derive a uniform render_scale.

### `map_project` (~93 tokens)

Crawl the entire Godot project and build an interactive visual map of all scripts showing their structure (variables, functions, signals), connections (extends, preloads, signal connections), and descriptions. Opens an interactive browser-based visualization.

Input parameters:

- `include_addons` (boolean): Whether to include scripts in the addons/ folder (default: false)
- `root` (string): Root path to start crawling from (default: res://)

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server#diagnostics

## Score history

- 2026-08-03: 61
- 2026-08-02: 61
- 2026-08-01: 25
- 2026-07-31: 25
- 2026-07-30: 52
- 2026-07-28: 52
- 2026-07-27: 52

## Links

- npm package: https://www.npmjs.com/package/godot-mcp-server
- Socket report: https://socket.dev/npm/package/godot-mcp-server
- Repository: https://github.com/tomyud1/godot-mcp
- Changelog RSS feed: https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/tomyud1-godot-mcp/godot-mcp-server