Godot AI MCP Server

Findings (3)

• mediumMedium. Worth checking, often a vulnerable dependency or a setup problem.
  Turns off TLS certificate checking, allowing traffic interception.

  src/godot_ai/attach/ensure.py:345
• lowLow. Minor, or common in normal tools. Shown for information.
  No manifest declaring network access and environment variables (agent.json)
• lowLow. Minor, or common in normal tools. Shown for information.
  Contacted these domains while starting up (no manifest to compare against)

  pypi.org

Network activity

Tools exposed (47)

• session_activate

  Set the active Godot editor session for subsequent tool calls. Accepts either an exact session_id or a substring hint matched against the session's short name (project folder basename), project_path, or session_id. An exact id match always wins; a substring must resolve to exactly one session or th

• session_manage

  Session listing. Resource form: ``godot://sessions`` — prefer for resource-aware clients. Ops: • list() List every connected Godot editor with metadata: session_id, short name, godot_version, project_path, plugin_version, server_version, editor_pid, server_launch_mode, cu

• editor_state

  Get current Godot editor state: version, readiness, open scene, play state. Resource form: ``godot://editor/state`` — prefer for active-session reads. Also reachable as ``editor_manage(op="state")`` (same handler) for clients that prefer a single rolled-up tool. Code-mode MCP adapters keep the ser

• logs_read

  Read recent log lines from the Godot editor, plugin, or running game. Resource form: ``godot://logs/recent`` — prefer for active-session reads. Sources: - "plugin" (default): MCP plugin recv/send/event traffic. Buffer 500. - "game": stdout/stderr/push_error/push_warning from playing game via ``_

• editor_screenshot

  Capture a screenshot of the Godot editor viewport or running game. Picking a source: the default ``"viewport"`` captures the editor's 3D viewport, which is empty if the edited scene has no Node3D anywhere in the tree (or no scene is open). Those cases return ``EDITOR_NOT_READY`` with ``error.data =

• editor_reload_plugin

  Reload the Godot editor plugin. Disables and re-enables the plugin on the next frame. The response shape depends on whether this MCP server was spawned by the plugin or launched externally: - **Plugin-managed (default install)**: returns a pre-flight ack ``{status: "reload_initiated", transport_

• editor_manage

  Editor selection, performance monitors, quit, log clearing, game eval. Resource forms (prefer for active-session reads): godot://editor/state, godot://selection/current, godot://performance Ops: • state() Editor version, project name, current scene, readiness, play state. • selection

• scene_get_hierarchy

  Get the scene tree hierarchy from the open scene. Returns a paginated flat list of nodes with name, type, path, and child count. Walks up to the specified depth. Resource form: ``godot://scene/hierarchy`` — prefer for active-session reads.

• scene_open

  Open an existing scene file (.tscn) in the editor. If ``path`` is already the currently edited scene this is a no-op — the in-memory state (including any unsaved MCP mutations) is preserved. Pass ``force_reload=True`` when the file on disk is the authority and the editor should discard the open in-

• scene_save

  Save the currently edited scene to disk. Node and property mutation tools change the editor's in-memory scene; call this explicitly to persist those mutations to the existing path.

• scene_manage

  Scene authoring (create, save_as, close a scene tab, list open roots). Resource form: ``godot://scene/current`` and ``godot://scene/hierarchy`` — prefer for active-session reads. Ops: • create(path, root_type="Node3D", root_name="") Create the initial .tscn with the given root and open i

• node_get_properties

  Get properties of a node. Resource form: ``godot://node/{path}/properties`` — prefer for active-session reads (returns the full property set). The default returns every editor-visible property, which can be 50-150 entries. Pass ``fields`` to return only the properties you need — a large response-s

• node_create

  Create (spawn) a new node in the scene tree. Creates a node of the given type and adds it to the parent, or instantiates a PackedScene from ``scene_path``. type and scene_path are mutually exclusive — when scene_path is given, type is ignored. Creating below an instance's internal nodes requires E

• node_set_property

  Set a property on a node. Overrides on an instance's internal nodes require Editable Children to be explicitly enabled; otherwise the call fails before mutation. Verify the property name first — call ``node_get_properties`` (or read ``godot://node/{path}/properties``) to confirm the exact name and

• node_find

  Find nodes in the scene tree by name, type, or group. At least one filter must be provided. Filters AND together. Paginated.

• node_manage

  Node tree manipulation (delete, duplicate, rename, reorder, reparent, groups, hierarchy reads). Resource forms (prefer for active-session reads): godot://node/{path}/properties, godot://node/{path}/children, godot://node/{path}/groups Ops: • get_children(path) Direct children of a no

• project_run

  Run (play) the Godot project from the editor. Modes: - "main": Run the project's main scene (default). - "current": Run the currently open scene. - "custom": Run a specific scene (requires ``scene``). Idempotent: if the project is already running, returns success with ``data.was_already_running=tr

• project_manage

  Project run/stop and project.godot settings. Resource form: ``godot://project/info`` and ``godot://project/settings`` — prefer for active-session reads. Ops: • stop() Stop the running project (game). Takes no params — call as ``project_manage(op="stop")`` or with ``params={}``. I

• script_create

  Create a script file on disk: GDScript (.gd, validated) or C# (.cs, text only). Writes content to the path. Overwrites if it exists. Registers the file with the editor. New files include ``data.cleanup.rm`` listing the file and, when supported by the editor, its ``.uid`` sidecar; overwrite omits it

• script_patch

  Anchor-based string-replace edit on a .gd or .cs file. Finds an exact ``old_text`` and replaces with ``new_text``. Fails on multiple matches unless ``replace_all=True``; fails on zero matches. Exact byte match (whitespace significant). Triggers filesystem scan. .gd: parse-validated (``diagnostics``

• script_attach

  Attach a script to a node in the scene tree. Replaces any existing script on the node. Undoable.

• script_manage

  Script (.gd / .cs) reading, detachment, and outline. Resource form: ``godot://script/{path}`` — prefer for active-session reads. Ops: • read(path) Read full source, line count, file size. • detach(path) Remove the currently attached script from a node. Undoable. • find_symbol

• resource_manage

  Resource (asset) search, inspection, assignment, and creation. Covers generic Resource subclasses plus specialized authoring (Curve, Environment, physics shapes, gradient/noise textures). Ops: • search(type="", path="", offset=0, limit=100) Search for resources by type or path. Type match

• api_manage

  Inspect Godot API documentation-shaped metadata from the connected editor's ClassDB: "what properties does X have", method signatures, signals, enums, constants, defaults, and property hint strings. Resource form (prefer for active-session reads): godot://class/{class_name} Ops: - get_class(cl

• filesystem_manage

  Project filesystem access via the Godot editor's EditorFileSystem. Ops: • read_text(path) Read a text file at a ``res://`` path. Returns content, size, line_count. • write_text(path, content="") Create or overwrite a text file. Updates the editor filesystem entry

• client_manage

  Configure AI clients to use this Godot AI MCP server. Writes / removes client config files (Claude Code, Codex, Antigravity, Cursor, Devin Desktop (Windsurf), Zed, etc.). Ops: • status() List every supported client with id, display_name, status (configured | not_configured | confi

• signal_manage

  Signals (Godot's event/observer mechanism) — list, connect, disconnect. Ops: • list(path, include_editor=False) List all signals on the node and their current connections (built-in and custom). By default editor-internal connections (the SceneTreeEditor dock and friends) a

• autoload_manage

  Autoload (global singleton) management. Autoloads are scripts or scenes loaded automatically at project start, accessible globally by name when ``singleton=True``. Persisted to ``project.godot``. Ops: • list() List autoloads with name, path, and singleton flag. • add(name, path, singlet

• input_map_manage

  InputMap actions and bindings (keyboard, mouse, gamepad). Persisted to ``project.godot``. Resource form: ``godot://input_map`` — prefer for active-session reads. Ops: • list(include_builtin=False) List input actions and their bound events. By default only user-authored actions (t

• game_manage

  Runtime game inspection and input simulation. These ops target the running game process through Godot's EngineDebugger bridge. Start the project first with project_run and poll editor_state until game_capture_ready=true. Ops: - get_scene_tree(depth=10, root_path="") Inspect the running s

• test_run

  Run GDScript test suites inside the connected Godot editor. Discovers test_*.gd in res://tests/, instantiates them, and runs all test_* methods. Returns a compact summary by default (counts, suite names, duration) plus failures only. verbose=True includes every individual test result (each with per

• test_manage

  Test result inspection (re-fetches the most recent ``test_run`` payload). Resource form: ``godot://test/results`` — prefer for active-session reads. Ops: • results_get(verbose=False) Same shape as test_run — full results from the last run, no re-execution. verbose=True includes e

• batch_execute

  Execute a list of editor sub-commands in order, stopping on first error. Each item must be `{"command": "<plugin_command>", "params": {...}}`. Use the underlying plugin command names (e.g. `create_node`, `set_property`, `delete_node`, `attach_script`), not the MCP tool names. Commands run sequentia

• ui_manage

  UI / Control authoring (HUD, menus, layouts, vector decoration). Ops: • set_anchor_preset(path, preset, resize_mode="minsize", margin=0) Apply a Control layout preset. preset: top_left | top_right | bottom_left | bottom_right | center_left | center_top | center_right | cen

• theme_manage

  Theme authoring (Godot's stylesheet-like resource for Controls). Cascades down a Control subtree when assigned via theme_apply. Stylebox numeric fields (border widths, corner radii, margins, shadow) must be finite numbers and stylebox flags (anti_aliasing, draw_center) must be real booleans; a non-

• animation_create

  Create a new Animation clip inside an AnimationPlayer's default library. After creating the clip, add tracks via ``animation_manage`` ops ``add_property_track`` / ``add_method_track`` / ``create_simple``. Track node paths are stored relative to the AnimationPlayer's ``root_node`` (default: its pare

• animation_manage

  Animation authoring (players, libraries, tracks and AnimationTree graphs). Ops: • tree_create(parent_path, player_path, name="AnimationTree", root_type="state_machine") Create an inactive AnimationTree linked to the player. root_type: state_machine|blend_tree|blend_space_1d|blend_

• material_manage

  Material authoring (StandardMaterial3D, ORMMaterial3D, ShaderMaterial, CanvasItemMaterial), raw shader source (.gdshader / .gdshaderinc), and VisualShader graph authoring/editing. Albedo, metallic/roughness, emission, transparency, shader uniforms, render modes. Resource forms: ``godot://materials`

• particle_manage

  Particle systems (GPUParticles2D/3D, CPUParticles2D/3D). All write ops create the node + sub-resources (ProcessMaterial, default QuadMesh draw pass) in a single undo action. Ops: • create(parent_path, name="Particles", type="gpu_3d") Create an emitter. type: "gpu_3d" | "gpu_2d" | "cpu_3d"

• camera_manage

  Camera2D / Camera3D authoring (zoom, FOV, projection, smoothing, follow). Ops: • create(parent_path, name="Camera", type="2d", make_current=False) Create a Camera2D ("2d") or Camera3D ("3d"). When make_current=True, unmarks previously current cameras of the same class in one undo.

• audio_manage

  Sound effects, music, ambience (AudioStreamPlayer / 2D / 3D). Bus/effect edits use global editor undo. Godot may autosave them to its active layout. bus_layout_save only exports a snapshot and does not switch that target. Ops: • bus_list() List buses, sends, volume, mute, solo, bypass, a

• tilemap_manage

  TileMap / TileMapLayer authoring (set tiles, fill rects, clear, read cells). All operations target TileMapLayer nodes in the currently edited scene by scene-relative path (e.g. "/LavaLake20x20/Ground"). All write ops are undoable via EditorUndoRedoManager. source_id is the TileSet source index. at

• tileset_manage

  TileSet management — atlas inspection tools. Ops: • tileset_create_atlas(resource_path, texture_path, tile_size, tiles, source_id=0, margins=None, separation=None, overwrite=False) Build a saved TileSet with one native atlas source. tile_size is {x,y} in p

• gridmap_manage

  GridMap authoring (set items, fill 3D regions, clear, read cells + library items). All operations target GridMap nodes in the currently edited scene by scene-relative path (e.g. "/Main/Terrain"). All write ops are undoable via EditorUndoRedoManager. item is the item id from the GridMap's MeshLibra

• navigation_manage

  Bounded 3D mesh-only navigation baking and 2D/3D path queries on an explicitly selected map. Ops: • bake(path, scene_file="", force_sync=True) Bake a 3D region from bounded mesh-only children. Requires NavigationMesh root-children source mode and mesh-instance or both geometry set

• csg_manage

  CSG authoring (create boolean shapes, set their operation). Create CSG shapes (box, sphere, cylinder, torus, polygon) under a Node3D parent in the currently edited scene and set their boolean operation (union / intersection / subtraction) so geometry like holes, caves and tunnels can be carved dire

• custom_manage

  List or invoke custom tools registered by third-party addons. Active session only. Use op="list" to discover registered tools. op="invoke" requires params: tool_name (string); optional: params (dict, forwarded to the addon handler unvalidated — shape per the tool's params_schema from op="list"). In