How do I use godot-devtool?

1. Click on "Install 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-devtool show me the project structure" 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-devtool

by wangdiandao

Overview Schema Related Servers Score Discussions

TypeScript

Local

# godot-devtool

License: MIT Version Godot MCP TypeScript

English | 中文

Buy me a coffee on Patreon if this project helps you. I am not very familiar with editing Patreon pages yet; thanks for your understanding.

godot-devtool is a Godot 4 MCP server for AI-assisted project inspection, editing, validation, and runtime automation. The stdio MCP server starts without binding the WebSocket bridge port; bridge tools open the local bridge on demand, keep it alive while run_project is active or a runtime client is connected, and otherwise release the port after tool-call cleanup.

Architecture

MCP client
  -> node build/index.js over stdio
  -> native/headless Godot tools
  -> optional ws://127.0.0.1:8766 bridge
  -> addons/godot_devtool editor plugin
  -> runtime autoload bridge

The MCP server always runs over stdio.
Native routes inspect and edit project files without opening the editor.
Headless routes call Godot for scene/resource/script operations.
Editor routes use the bundled WebSocket plugin for live selection, Inspector writes, UndoRedo scene mutations, scene save, and plugin reload.
Runtime routes use the installed autoload bridge for running-game scene tree, properties, input simulation, screenshots, and QA checks.
Browser visualizer routes serve a local read-only HTTP dashboard for bridge/client status and live-route orientation.
The local WebSocket listener is a shared broker, so multiple MCP clients or AI agents can use the same bridge port instead of each spawning an exclusive listener.
Editor and runtime sessions are identified by projectPath, context, sessionId, and runId; ambiguous live targets return candidates instead of guessing.
run_project creates tracked run instances. Use list_run_instances, get_debug_output, stop_project, and stop_run_instance with runId when multiple game instances are active.
get_capabilities supports focused workflow filters such as project_setup, live_editor, runtime_test, multi_instance, and release_verify to keep assistant context small.
tools/list is router-only: it exposes only entry tools plus tool category metadata, with no cursor pagination or environment-variable mode switch. Load full tool input schemas through filtered get_capabilities calls.

Related MCP server: Gear

Requirements

Node.js 18 or newer.
Godot 4.x. Set GODOT_PATH unless godot is already on PATH.
An MCP client such as Codex, Claude Code, Cursor, Cline, Roo Code, VS Code Copilot, or another client that can launch stdio MCP servers.
A Godot project containing project.godot.

Codex And Claude Plugin Bundle

The repository is also packaged like an IDE plugin bundle for agentic coding tools:

plugin.json exposes the shared plugin metadata, agents/, and skills/.
.codex-plugin/plugin.json exposes Codex marketplace/interface metadata.
.claude-plugin/plugin.json exposes Claude Code plugin metadata.
agents/godot-dev.agent.md is the user-invocable godot-dev Agent. It routes work through skills/godot-devtool/SKILL.md and the focused workflow skills.

npm run build copies these manifests, the Agent, and all Skills into build/ so a release zip contains the MCP server plus the IDE-style guidance layer.

Install From Local Build

Build from source, or extract a published release zip to a stable path. The release asset name for this version is godot-devtool-build-3.2.1.zip.
```
Expand-Archive ".\godot-devtool-build-3.2.1.zip" "E:\godot-devtool" -Force
```

Confirm the server entry exists:

Test-Path "E:\godot-devtool\build\index.js"
Test-Path "E:\godot-devtool\build\addons\godot_devtool\plugin.gd"

Add this MCP server to your client configuration:

{
  "mcpServers": {
    "godot-devtool": {
      "command": "node",
      "args": ["E:/godot-devtool/build/index.js"],
      "env": {
        "GODOT_PATH": "D:/Program Files/Godot/Godot_v4.x.exe",
        "GODOT_DEVTOOL_WS_PORT": "8766"
      }
    }
  }
}

Codex Desktop uses TOML in config.toml:

[mcp_servers.godot-devtool]
command = "node"
args = ["E:/godot-devtool/build/index.js"]
env = { GODOT_PATH = "D:/Program Files/Godot/Godot_v4.x.exe", GODOT_DEVTOOL_WS_PORT = "8766" }

Restart the MCP client and ask it to call:

get_godot_version
get_capabilities
get_capabilities {"toolNames":["plugin_install","plugin_status","plugin_cleanup_port"],"includeSchemas":true}

GODOT_DEVTOOL_WS_PORT defaults to 8766. The stdio MCP server starts without opening that port. Bridge tools open it on demand; editor-only calls release it during cleanup, while a project launched through run_project or an already connected runtime client keeps the listener open so runtime commands do not depend on a one-call reconnect window. If another godot-devtool process already owns the same port, broker-aware calls can forward through that listener instead of killing it.

If another listener already holds the port while a bridge tool runs, use plugin_status and plugin_cleanup_port to inspect it. Only call plugin_cleanup_port with kill=true after confirming the listener is stale; switching ports creates a separate bridge and does not adopt editor clients connected to the old one.

Build From Source

git clone https://github.com/wangdiandao/godot-devtool.git
cd godot-devtool
npm install
npm run build

Use build/index.js as the MCP server entry. The bundled Godot addon is copied into build/addons/godot_devtool during npm run build.

Install The Godot Plugin

The plugin is included in the release/build package. It still must be installed into each Godot project that needs live editor or runtime routes.

Start your MCP client with godot-devtool configured.

Ask the AI or call the tool directly:

plugin_install

Arguments:

{
  "projectPath": "E:/my-godot-project",
  "overwrite": true,
  "websocketPort": 8766
}

Open the Godot project.

Enable the plugin:

Project > Project Settings > Plugins > godot-devtool > Enable

Check installation and connection:
```
plugin_status
```

For runtime routes, plugin_install also registers:

autoload/DevtoolRuntime = *res://addons/godot_devtool/runtime_bridge.gd

Run the project from Godot before using runtime_ws tools. The editor plugin connects while the editor is open; the runtime bridge connects while the game is running.

Ask AI To Install It

After adding the MCP server to your client, you can paste this prompt into the AI assistant:

Use the godot-devtool MCP server to install and verify the Godot plugin for my project.

Project path: "E:/my-godot-project"
WebSocket port: 8766

Steps:
1. Call get_godot_version and get_capabilities for the lightweight tool catalog.
2. Confirm plugin_install, plugin_status, plugin_reload, and plugin_cleanup_port are available.
3. If you need input schemas, call get_capabilities with toolNames=["plugin_install","plugin_status","plugin_reload","plugin_cleanup_port"] and includeSchemas=true.
4. Call plugin_install with overwrite=true for the project path above.
5. Call plugin_status and summarize installed files, autoload registration, bridge mode, and WebSocket port.
6. Tell me exactly how to enable the plugin in Godot.
7. If runtime routes are needed, tell me to run the project and then verify runtime bridge status.
Do not edit unrelated files.

Chinese prompt:

请使用 `godot-devtool` MCP server 帮我安装并验收 Godot 插件。

项目路径: "E:/my-godot-project"
WebSocket 端口: 8766

步骤:
1. 调用 get_godot_version 和 get_capabilities，先获取轻量工具目录。
2. 确认 plugin_install、plugin_status、plugin_reload、plugin_cleanup_port 可用。
3. 如果需要输入 schema，调用 get_capabilities，传入 toolNames=["plugin_install","plugin_status","plugin_reload","plugin_cleanup_port"] 和 includeSchemas=true。
4. 对上述项目路径调用 plugin_install，overwrite=true。
5. 调用 plugin_status，总结已安装文件、autoload 注册、bridge mode 和 WebSocket 端口。
6. 告诉我在 Godot 编辑器里如何启用插件。
7. 如果需要 runtime 路由，提醒我运行项目后再验证 runtime bridge 状态。
不要修改无关文件。

What It Can Do

Use get_capabilities as the source of truth. The MCP tools/list response is a context-budget-safe router surface: it exposes only get_capabilities, get_godot_version, and list_projects, plus _meta.toolCategories summaries for route groups, workflows, transports, and risk levels. It does not support cursor pagination and does not provide an environment-variable switch back to full-schema tools/list. The default get_capabilities call returns a lightweight catalog with routeGroup, transport, riskLevel, requiresEditor, requiresRuntime, and canonicalName when a tool is implemented through a shared capability. It does not include input schemas by default. To load full input schemas, narrow the request with workflow, routeGroup, transport, riskLevel, toolNames, or query, then set includeSchemas=true; unfiltered schema requests are rejected to keep the response small.

Core project tools inspect project.godot, list projects, read and update project settings with dry-run support, configure InputMap actions with native Godot syntax, run the project, stop the current run, export configured presets, update Godot 4.4+ UIDs, and run release-friendly project checks. Scene and node tools create/open/save scenes, inspect scene trees, add/delete/rename/duplicate/move nodes, update properties with structured Variant values, manage groups, inspect dependencies, and apply cross-scene edits.

Script, filesystem, and resource tools index GDScript files, read/write scripts, create and attach scripts, run syntax checks, read/write/list/search/delete project files, load/save resources, build dependency graphs, inspect export presets, and preview resource content. Visual workflow tools cover shaders, materials, particles, UI themes/templates, physics bodies and collision layers, navigation regions/agents/meshes, lighting/environment setup, TileMap edits, animation tracks/keyframes, and AnimationTree state machine operations.

Editor tools install and verify the bundled godot-devtool plugin, reload it through the WebSocket bridge, read the live editor selection, select nodes, perform UndoRedo, read/write Inspector properties, and add/delete/rename/move/duplicate nodes in the currently open scene without forcing an external disk reload. The GDT dock shows connection state, the active edited scene, current selection, live-edit availability, save mode, runtime session diagnostics, and the latest command result. Runtime tools work while the game is running: they can read the live scene tree and node properties, set runtime properties, capture screenshots/frames, simulate input actions, inspect UI text/buttons, wait for nodes, navigate agents, monitor properties, record/replay interactions, and run QA-style assertions and stress checks.

Browser visualizer tools start, inspect, and stop a local read-only dashboard. Use browser_visualizer_start to open a http://127.0.0.1:<port>/ page that refreshes bridge status, connected editor/runtime clients, pending command count, and the existing screenshot/scene/input route names to call from the MCP client.

The table below is generated from the actual tool definitions so the README stays aligned with the MCP server.

All 235 Tools

Project Tools (18)

Tool	Description
`add_autoload`	Exact-name compatibility route for add_autoload. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`export_project`	Run a controlled Godot export for a configured preset
`get_autoload`	Exact-name compatibility route for get_autoload. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_input_actions`	Get input actions using the project_input_action implementation.
`get_project_info`	Retrieve metadata about a Godot project
`get_project_statistics`	Get project statistics using the get_project_info implementation.
`list_projects`	List Godot projects in a directory
`project_get_settings`	Read Godot project.godot settings by section or section/key list
`project_input_action`	List or update project InputMap actions in project.godot
`project_set_setting`	Update Godot project.godot settings with dry-run preview and audit logging
`reload_project`	Exact-name compatibility route for reload_project. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`remove_autoload`	Exact-name compatibility route for remove_autoload. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`run_project`	Run the Godot project and capture output
`run_project_checks`	Run stable project checks for CI, review, and release workflows
`set_input_action`	Set input action using the project_input_action implementation.
`stop_project`	Stop the currently running Godot project
`uid_to_project_path`	Exact-name compatibility route for uid_to_project_path. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`update_project_uids`	Update UID references in a Godot project by resaving resources (for Godot 4.4+)

Scene Tools (51)

Tool	Description
`add_animation_track`	Add animation track using the animation implementation.
`add_audio_bus`	Exact-name compatibility route for add_audio_bus. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_audio_bus_effect`	Exact-name compatibility route for add_audio_bus_effect. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_audio_player`	Add audio player using the audio implementation.
`add_scene_instance`	Exact-name compatibility route for add_scene_instance. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`analyze_scene_complexity`	Exact-name compatibility route for analyze_scene_complexity. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`analyze_signal_flow`	Exact-name compatibility route for analyze_signal_flow. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`animation`	Create, inspect, remove, and edit AnimationPlayer tracks and keyframes
`animation_state_machine`	Create, inspect, and configure AnimationTree state machines
`audio`	Create and list AudioStreamPlayer nodes with basic playback configuration
`bake_navigation_mesh`	Bake navigation mesh using the navigation implementation.
`connect_signal`	Connect signal using the signal implementation.
`create_animation`	Create animation using the animation implementation.
`create_animation_tree`	Create animation tree using the animation_state_machine implementation.
`create_scene`	Create a new Godot scene file
`cross_scene_set_property`	Exact-name compatibility route for cross_scene_set_property. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`disconnect_signal`	Disconnect signal using the signal implementation.
`find_signal_connections`	Exact-name compatibility route for find_signal_connections. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_animation_info`	Get animation info using the animation implementation.
`get_animation_tree_structure`	Exact-name compatibility route for get_animation_tree_structure. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_audio_bus_layout`	Get audio bus layout using the audio implementation.
`get_audio_info`	Get audio info using the audio implementation.
`get_collision_info`	Get collision info using the physics implementation.
`get_navigation_info`	Get navigation info using the navigation implementation.
`get_physics_layers`	Exact-name compatibility route for get_physics_layers. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_scene_dependencies`	Exact-name compatibility route for get_scene_dependencies. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_scene_tree`	Return the node tree for a Godot scene
`get_signals`	Get signals using the signal implementation.
`list_animations`	List animations using the animation implementation.
`navigation`	Create, inspect, configure, bake, query, and debug NavigationRegion and NavigationAgent nodes
`physics`	Create, inspect, configure, template, and analyze physics bodies, areas, collision layers, and shapes
`remove_animation`	Remove animation using the animation implementation.
`save_scene`	Save changes to a scene file
`scene_get_current`	Return the current scene tracked by this MCP session, if one was opened
`scene_open`	Open a scene in the MCP session using headless/file-based scene access
`set_animation_keyframe`	Set animation keyframe using the animation implementation.
`set_audio_bus`	Exact-name compatibility route for set_audio_bus. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_navigation_layers`	Exact-name compatibility route for set_navigation_layers. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_physics_layers`	Set physics layers using the physics implementation.
`setup_collision`	Set up collision using the physics implementation.
`setup_navigation_agent`	Set up navigation agent using the navigation implementation.
`setup_navigation_region`	Set up navigation region using the navigation implementation.
`setup_physics_body`	Set up physics body using the physics implementation.
`signal`	List, connect, or disconnect node signals in a scene
`tilemap`	Create, list, and edit TileMapLayer or legacy TileMap nodes
`tilemap_clear`	Clear TileMap using the tilemap implementation.
`tilemap_fill_rect`	Fill TileMap rect using the tilemap implementation.
`tilemap_get_cell`	Get TileMap cell using the tilemap implementation.
`tilemap_get_info`	Get TileMap info using the tilemap implementation.
`tilemap_get_used_cells`	Get TileMap used cells using the tilemap implementation.
`tilemap_set_cell`	Set TileMap cell using the tilemap implementation.

Node Tools (17)

Tool	Description
`add_node`	Add a node to an existing scene
`delete_node`	Delete a non-root node from a Godot scene
`find_node_references`	Exact-name compatibility route for find_node_references. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`find_nodes_by_type`	Find nodes by type using the node_find implementation.
`find_nodes_in_group`	Exact-name compatibility route for find_nodes_in_group. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_node_groups`	Exact-name compatibility route for get_node_groups. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_node_properties`	Read selected properties from a node in a Godot scene
`group`	List, add, or remove node groups
`move_node`	Move node using the node_move implementation.
`node_duplicate`	Duplicate a node in a Godot scene
`node_find`	Find nodes in a scene by name, type, or path substring
`node_get`	Get node information from a Godot scene
`node_move`	Move a node by setting its position or reparenting it in a Godot scene
`rename_node`	Rename a node in a Godot scene
`set_blend_tree_node`	Exact-name compatibility route for set_blend_tree_node. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_node_groups`	Exact-name compatibility route for set_node_groups. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`update_node_properties`	Update properties on a node in a Godot scene

Script Tools (11)

Tool	Description
`analyze_script_references`	Analyze a GDScript file for class, functions, exports, node paths, and resource references
`check_gdscript_syntax`	Run Godot --check-only against a GDScript file and return diagnostics
`edit_script`	Edit script using the script_write implementation.
`execute_editor_script`	Exact-name compatibility route for execute_editor_script. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`find_nodes_by_script`	Exact-name compatibility route for find_nodes_by_script. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`find_script_references`	Exact-name compatibility route for find_script_references. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_open_scripts`	Exact-name compatibility route for get_open_scripts. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_script_index`	Return GDScript files with class, base class, exported variables, and functions
`script_attach`	Attach a GDScript resource to a node in a scene
`script_create`	Create a GDScript file inside a Godot project
`script_write`	Write full GDScript content with overwrite protection

Editor Tools (17)

Tool	Description
`editor_add_node`	Add a node to the currently open editor scene through UndoRedo without externally rewriting the scene file
`editor_delete_node`	Delete a non-root node from the currently open editor scene through UndoRedo
`editor_duplicate_node`	Duplicate a node in the currently open editor scene through UndoRedo
`editor_get_selection`	Return the current editor selection when a live editor bridge is available
`editor_inspector_get_properties`	Read Inspector properties from the selected or addressed node through the live editor bridge
`editor_inspector_set_properties`	Write Inspector properties on the selected or addressed node through the live editor bridge
`editor_move_node`	Move or reparent a node in the currently open editor scene through UndoRedo
`editor_rename_node`	Rename a node in the currently open editor scene through UndoRedo
`editor_save_scene`	Save the currently open editor scene through the live editor bridge
`editor_select_node`	Select a node in the live Godot editor when an editor bridge is available
`editor_undo_redo`	Perform undo or redo in the live Godot editor when an editor bridge is available
`plugin_cleanup_port`	Explicitly inspect and optionally stop stale godot-devtool WebSocket bridge listeners on a local port
`plugin_dock_status`	Return machine-readable godot-devtool Dock labels, tooltips, status dots, buttons, visibility, and bridge diagnostics from the live editor
`plugin_install`	Install the godot-devtool WebSocket editor/runtime plugin into a Godot project
`plugin_reload`	Reload the godot-devtool editor plugin through the WebSocket bridge
`plugin_status`	Read godot-devtool plugin installation status, WebSocket bridge configuration, connected clients, and occupied-port diagnostics
`reload_plugin`	Exact-name compatibility route for reload_plugin. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.

Filesystem Tools (11)

Tool	Description
`delete_scene`	Delete scene using the filesystem_delete implementation.
`filesystem_delete`	Delete a project-local file or directory with explicit confirmation
`filesystem_list`	List files and directories inside a Godot project
`filesystem_preview_delete`	Preview a project-local delete operation without deleting files
`filesystem_read`	Read a UTF-8 text file inside a Godot project
`filesystem_write`	Write a UTF-8 text file inside a Godot project
`get_filesystem_tree`	Get filesystem tree using the filesystem_list implementation.
`get_scene_file_content`	Get scene file content using the filesystem_read implementation.
`read_script_file`	Read a GDScript file from a Godot project
`search_files`	Exact-name compatibility route for search_files. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`search_in_files`	Exact-name compatibility route for search_in_files. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.

Resource Tools (16)

Tool	Description
`add_resource`	Add resource using the resource_create implementation.
`check_export_presets`	Inspect Godot export presets and report pre-export issues
`edit_resource`	Edit resource using the resource_save implementation.
`export_matrix`	Summarize export targets, platform families, signing/template status, and CI steps
`export_mesh_library`	Export a scene as a MeshLibrary resource
`find_unused_resources`	Find unused resources using the resource_dependency_graph implementation.
`get_export_info`	Get export info using the export_matrix implementation.
`get_export_presets`	Read configured Godot export presets
`get_resource_index`	Return a categorized resource index for a Godot project
`get_resource_preview`	Exact-name compatibility route for get_resource_preview. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_uid`	Get the UID for a specific file in a Godot project (for Godot 4.4+)
`resource_create`	Create a simple structured Godot resource file
`resource_dependency_graph`	Build a resource dependency graph and identify orphan resources
`resource_load`	Load a text-based Godot resource from the project
`resource_save`	Save text-based Godot resource content with overwrite protection
`update_export_preset`	Update fields or options for a configured Godot export preset

Visual Tools (25)

Tool	Description
`apply_particle_preset`	Exact-name compatibility route for apply_particle_preset. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`assign_shader_material`	Assign shader material using the material implementation.
`create_particles`	Create particles using the particle implementation.
`create_shader`	Create shader using the shader implementation.
`create_theme`	Create theme using the ui implementation.
`edit_shader`	Exact-name compatibility route for edit_shader. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_particle_info`	Exact-name compatibility route for get_particle_info. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_shader_params`	Get shader params using the shader implementation.
`get_theme_info`	Exact-name compatibility route for get_theme_info. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`lighting`	Create and list basic Godot light and environment nodes
`material`	Create, read, update, and apply Godot material resources
`particle`	Create and list basic Godot particle emitter nodes
`read_shader`	Read shader using the shader implementation.
`set_material_3d`	Set material 3d using the material implementation.
`set_particle_color_gradient`	Exact-name compatibility route for set_particle_color_gradient. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_particle_material`	Exact-name compatibility route for set_particle_material. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_shader_param`	Set shader param using the shader implementation.
`set_theme_color`	Exact-name compatibility route for set_theme_color. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_theme_constant`	Exact-name compatibility route for set_theme_constant. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_theme_font_size`	Exact-name compatibility route for set_theme_font_size. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_theme_stylebox`	Exact-name compatibility route for set_theme_stylebox. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`setup_environment`	Set up environment using the lighting implementation.
`setup_lighting`	Set up lighting using the lighting implementation.
`shader`	Create, read, inspect, and configure ShaderMaterial parameters
`ui`	Create Control nodes, reusable UI templates, themes, and automatic signal wiring

Runtime Tools (30)

Tool	Description
`assert_node_state`	Exact-name compatibility route for assert_node_state. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`assert_screen_text`	Exact-name compatibility route for assert_screen_text. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`capture_frames`	Runtime WebSocket compatibility route. Executes capture_frames through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`click_button_by_text`	Runtime WebSocket compatibility route. Executes click_button_by_text through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`compare_screenshots`	Exact-name compatibility route for compare_screenshots. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`create_workflow_test_scene`	Create a small Godot scene for validating MCP scene/script/check workflows
`execute_game_script`	Runtime WebSocket compatibility route. Executes execute_game_script through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`find_nearby_nodes`	Runtime WebSocket compatibility route. Executes find_nearby_nodes through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`find_ui_elements`	Runtime WebSocket compatibility route. Executes find_ui_elements through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`get_editor_screenshot`	Exact-name compatibility route for get_editor_screenshot. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_game_node_properties`	Runtime WebSocket compatibility route. Executes get_game_node_properties through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`get_game_scene_tree`	Runtime WebSocket compatibility route. Executes get_game_scene_tree through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`get_game_screenshot`	Runtime WebSocket compatibility route. Executes get_game_screenshot through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`get_performance_monitors`	Runtime WebSocket compatibility route. Executes get_performance_monitors through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`get_test_report`	Exact-name compatibility route for get_test_report. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`monitor_properties`	Runtime WebSocket compatibility route. Executes monitor_properties through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`move_to`	Runtime WebSocket compatibility route. Executes move_to through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`navigate_to`	Runtime WebSocket compatibility route. Executes navigate_to through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`replay_recording`	Runtime WebSocket compatibility route. Executes replay_recording through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`run_stress_test`	Exact-name compatibility route for run_stress_test. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`run_test_scenario`	Exact-name compatibility route for run_test_scenario. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_game_node_property`	Runtime WebSocket compatibility route. Executes set_game_node_property through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`simulate_action`	Runtime WebSocket compatibility route. Executes simulate_action through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`simulate_key`	Runtime WebSocket compatibility route. Executes simulate_key through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`simulate_mouse_click`	Runtime WebSocket compatibility route. Executes simulate_mouse_click through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`simulate_mouse_move`	Runtime WebSocket compatibility route. Executes simulate_mouse_move through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`simulate_sequence`	Runtime WebSocket compatibility route. Executes simulate_sequence through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`start_recording`	Runtime WebSocket compatibility route. Executes start_recording through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`stop_recording`	Runtime WebSocket compatibility route. Executes stop_recording through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.
`wait_for_node`	Runtime WebSocket compatibility route. Executes wait_for_node through the running Godot runtime bridge and returns a failed receipt when DevtoolRuntime is not connected.

Core Tools (39)

Tool	Description
`add_gridmap`	Exact-name compatibility route for add_gridmap. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_mesh_instance`	Exact-name compatibility route for add_mesh_instance. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_raycast`	Exact-name compatibility route for add_raycast. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_state_machine_state`	Exact-name compatibility route for add_state_machine_state. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`add_state_machine_transition`	Exact-name compatibility route for add_state_machine_transition. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`batch_get_properties`	Exact-name compatibility route for batch_get_properties. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`batch_set_property`	Exact-name compatibility route for batch_set_property. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`broker_cleanup_idle`	Stop the transient shared broker listener only when no clients, runs, or pending commands require it
`broker_status`	Read the shared godot-devtool 3.0 WebSocket broker status, connected clients, pending commands, and leases
`browser_visualizer_start`	Start a local read-only browser dashboard for Godot editor/runtime bridge status and live-route guidance
`browser_visualizer_status`	Read the local Browser visualizer URL, project filter, and connected editor/runtime bridge clients
`browser_visualizer_stop`	Stop the local Browser visualizer HTTP dashboard
`clear_debug_output`	Clear buffered output for the currently running Godot project
`create_gameplay_prototype`	Create a high-level block-based gameplay prototype scaffold in a Godot project
`detect_circular_dependencies`	Exact-name compatibility route for detect_circular_dependencies. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`generate_ci_snippet`	Generate GitHub Actions or GitLab CI snippets for Godot headless checks, export preflight, release export, and artifact archiving
`geometry`	Create and list basic 2D geometry/debug drawing nodes
`get_audit_log`	Read godot-devtool project audit log entries
`get_audit_replay`	Summarize godot-devtool audit log entries into replay steps, counters, and risk highlights
`get_capabilities`	Return a lightweight godot-devtool tool catalog by default, with optional filtered input schemas by route group, transport, risk level, tool name, or query
`get_debug_output`	Get the current debug output and errors
`get_editor_errors`	Exact-name compatibility route for get_editor_errors. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_editor_performance`	Exact-name compatibility route for get_editor_performance. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`get_godot_version`	Get the installed Godot version
`get_rollback_suggestions`	Return honest rollback guidance for an operation, audit entry, or changed paths
`get_safety_policy`	Read the project-local godot-devtool safety policy and default enforcement state
`launch_editor`	Reuse an already connected Godot editor for a project, launch one only when no bridge is connected, and refuse to open a replacement editor when the configured bridge port is occupied by another listener
`list_bridge_sessions`	List connected editor/runtime bridge sessions with sessionId, runId, project path, context, and last-seen time
`list_run_instances`	List Godot game/editor run instances managed by this MCP server
`load_sprite`	Load a sprite into a Sprite2D node
`preview_write_safety`	Preview safety policy and diff summary metadata for proposed writes or deletes
`remove_state_machine_state`	Exact-name compatibility route for remove_state_machine_state. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`remove_state_machine_transition`	Exact-name compatibility route for remove_state_machine_transition. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`resolve_bridge_target`	Resolve the editor/runtime bridge target for a project and report ambiguity candidates without sending a command
`set_anchor_preset`	Exact-name compatibility route for set_anchor_preset. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`set_safety_policy`	Configure project write allowlists and blocked paths in .godot-devtool/safety.json
`set_tree_parameter`	Exact-name compatibility route for set_tree_parameter. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`setup_camera_3d`	Exact-name compatibility route for setup_camera_3d. Executes through its registered compatibility implementation and returns a structured error when required project, editor, or runtime state is unavailable.
`stop_run_instance`	Stop one Godot run instance by runId

Which Route Should I Use?

Use native routes for project inspection, file edits, settings, indexes, safety policy, and dependency checks.
Use headless_godot routes when Godot must load or mutate scenes/resources/scripts correctly.
Use editor_ws only when the current open editor state matters.
Use runtime_ws only after the game is running and you need live game state, input, screenshots, or QA assertions.
Use get_capabilities before automating unfamiliar workflows. Request schemas only for the active workflow, route group, or exact tools; do not rely on tools/list for full schemas.

Verification

Static and package checks:

npx.cmd tsc --noEmit
npm.cmd run build
npm.cmd run verify:tools
npm.cmd run verify:gdscripts
npm.cmd run verify:visualizer
npm.cmd run verify:plugin

Full release checks require GODOT_PATH and a local Godot runtime:

npm.cmd run verify:runtime
npm.cmd run verify:process
npm.cmd run verify:security
npm.cmd run verify:all
npm.cmd run check:project -- "C:/path/to/your-godot-project"

After a development branch passes the required verification gates, merge it into main before treating the branch as complete.

Troubleshooting

get_godot_version fails: set GODOT_PATH to the exact Godot executable.
plugin_status says not installed: run plugin_install for the correct project path.
Editor routes time out: open the project in Godot and enable the plugin.
Runtime routes time out: run the game so the DevtoolRuntime autoload can connect.
Port conflict: inspect the owner with plugin_cleanup_port; stop only a verified stale listener, or deliberately set a matching alternate GODOT_DEVTOOL_WS_PORT and reinstall with the same websocketPort.
MCP client cannot start the server: confirm node is available and build/index.js exists.

Skill

Agent operating guidance is bundled at:

skills/godot-devtool/SKILL.md

Feed this SKILL.md to your AI assistant before asking it to operate on a Godot project. In clients that support file context, attach or reference the file directly; otherwise paste its contents into the chat and tell the AI to follow it when using the godot-devtool MCP server.

The skill maps common Godot operations to the correct MCP tools, teaches assistants to inspect project state first, use stdio/headless routes for repeatable edits, install/use the WebSocket plugin only when live editor or runtime state is required, and validate changes before finishing.

Available Tools

3 tools

get_capabilitiesA

Return a lightweight godot-devtool tool catalog by default, with optional filtered input schemas by route group, transport, risk level, tool name, or query

ParametersJSON Schema

Name	Required	Description
`query`	No	Optional case-insensitive search across tool name, description, route group, transport, risk level, and canonical name.
`compact`	No	Return compact JSON. Defaults to true; set false for pretty-printed JSON.
`workflow`	No	Optional focused workflow filter for compact context. Use this instead of requesting all schemas.
`riskLevel`	No	Optional risk-level filter such as read, write, destructive, or process.
`toolNames`	No	Optional exact tool names to return. When provided, results follow this requested order.
`transport`	No	Optional transport filter such as native, headless_godot, process_control, editor_ws, or runtime_ws.
`routeGroup`	No	Optional route group filter such as project, scene, node, visual, editor, runtime, filesystem, resource, script, or core.
`includeSchemas`	No	Include input schemas for the filtered tools. Defaults to false and requires routeGroup, transport, riskLevel, toolNames, or query when true.

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must disclose behavioral traits. It mentions the default lightweight output and optional filtering, but does not state that the tool is read-only, has no side effects, or describe the output format beyond 'catalog'. The behavioral implications of the 'workflow' parameter (returning a predefined set) are not explained.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence of about 25 words, front-loading the core purpose. Every word contributes meaning, with no redundancy or unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 8 parameters, no annotations, and no output schema, the description is brief. It does not describe the structure of the returned catalog (e.g., array of tool objects with fields), nor does it clarify that the tool is a safe introspection operation. While adequate for a simple tool, it lacks detail needed by an agent to fully understand the output and side effects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, so the schema already defines parameters clearly. The description adds value by summarizing filter types and providing extra guidance for the 'workflow' parameter ('Use this instead of requesting all schemas'). However, it does not detail other parameter specifics beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns a 'lightweight godot-devtool tool catalog' with filtering options by route group, transport, risk level, tool name, or query. This distinguishes it from sibling tools like 'get_godot_version' (version info) and 'list_projects' (project listing).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is for exploring available tools/capabilities but does not explicitly state when to use this tool versus alternatives. For example, it does not say 'Use this to discover available tools; use get_godot_version for version info.' The guidance is implicit but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_godot_versionA

Get the installed Godot version

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It correctly implies read-only behavior but adds no extra context. For a simple getter, it is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, directly to the point, no unnecessary words. Perfectly concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a version-check tool with no parameters or output schema, the description is complete enough. It could mention return type, but not required.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema description coverage is 100%. Baseline is 4, and the description does not need to add param info.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the verb 'Get' and resource 'installed Godot version'. It distinguishes from sibling tools like get_capabilities and list_projects, which are focused on different resources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. While the tool is simple, no context is given about typical use cases or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_projectsB

List Godot projects in a directory

ParametersJSON Schema

Name	Required	Description	Default
`directory`	Yes	Directory to search for Godot projects
`recursive`	No	Whether to search recursively (default: false)

TDQS

B3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so description carries full burden. The description does not disclose behavioral traits such as error handling (e.g., invalid directory), performance, or what qualifies as a Godot project. Only the basic action is stated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no waste, but it is too short and lacks sufficient information for effective tool usage. It is appropriately concise but under-specified.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and simple parameters, the description fails to inform about return format (list of paths? names?), error behavior, or what defines a Godot project. Significant completeness gaps persist.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, providing clear parameter descriptions. The tool description adds no extra meaning beyond 'list projects', so it meets baseline but offers no added value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists Godot projects in a directory, with a specific verb and resource. It distinguishes from siblings which are about capabilities and version.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use or not use this tool versus alternatives. No context provided on prerequisites or constraints.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

3 tool updatesv3.2.0Jun 2, 2026
- First observedget_capabilities
- First observedget_godot_version
- First observedlist_projects

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.6/5.0

Disambiguation5/5

Each tool has a distinct purpose: returning the tool catalog, retrieving the Godot version, and listing projects. There is no overlap.

Naming Consistency5/5

All tools follow a consistent verb_noun pattern with underscores (get_capabilities, get_godot_version, list_projects).

Tool Count4/5

With only 3 tools, the set is small but not unreasonable for a focused development tool. It could be more comprehensive but feels appropriate for a minimal server.

Completeness3/5

The tools cover basic information retrieval (version, project listing) but lack actions like running or exporting projects. Notable gaps exist for a development tool server.

Maintenance

ActivityStale

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

mcp-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
gread A
io.github.NitroRCr
An MCP server that gives your AI access to the source code and docs of all public github repos
Version Control Code Analysis Documentation Access
5361
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
ChiR24-unreal_mcp_serverOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
Developer Tools App Automation Software Architecture
2856

Related MCP Servers

GodotIQ
Developer Tools Code Analysis Autonomous Agents
salvo10f
A
license
Not graded
quality
B
maintenance
Intelligent MCP server for AI-assisted Godot 4 development with spatial intelligence, code analysis, and 35 tools
Updated a month ago (2026-08-03 17:22 UTC)
54
MIT
Gear
Developer Tools Code Execution App Automation
wvfp
A
license
A
quality
B
maintenance
An MCP server that enables AI assistants to directly run, inspect, modify, and debug Godot game development projects through 110+ tools covering scenes, scripts, resources, runtime debugging, and asset management.
Updated 3 months ago (2026-06-15 13:26 UTC)
33
21
2
MIT
Funplay MCP for Godot
Developer Tools Coding Agents
FunplayAI
A
license
Not graded
quality
A
maintenance
The most advanced MCP server for Godot Editor that lets AI assistants operate directly inside your running Godot project for scene creation, script generation, UI authoring, and more.
Updated a month ago (2026-07-31 04:00 UTC)
36
MIT
WazziCode Godot
Developer Tools Testing & QA Tools
robertobendi
F
license
A
quality
A
maintenance
MCP server that connects AI coding assistants to a live Godot editor, enabling scene, node, script, resource, runtime, debugger, and test workflows through natural language.
Updated 13 days ago (2026-08-24 18:12 UTC)
45
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/wangdiandao/godot-devtool'

If you have feedback or need assistance with the MCP directory API, please join our Discord server