# Godot MCP Native: an MCP server written inside the Godot editor, with no Node.js in sight

> A Godot 4.x plugin that implements the Model Context Protocol natively in the engine, exposing 155 tools for scenes, scripts, nodes, and debugging, plus a gdmcp CLI built for coding agents.

**yurineko73/Godot-MCP-Native** — 一款支持godot开源引擎的的mcp插件，支持常见godot引擎操作，使用Godot原生实现MCPServer，无需安装依赖，开箱即用，支持多种AI工具调用。An MCP plugin that supports the open-source Godot engine, enabling common Godot engine operations. It implements the MCP Server using Godot's native HTTP, requires no dependency installation, is ready to use out of the box, and supports invocation by various AI tools.

- Repository: https://github.com/yurineko73/Godot-MCP-Native
- Stars: 814 · Forks: 73
- Language: GDScript
- License: MIT
- Published: 2026-09-19 · Updated: 2026-09-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/yurineko73-godot-mcp-native

## What it is and why the native part matters

Godot MCP Native is a Godot 4.x editor plugin, published by yurineko73 under the MIT license and currently at version 1.0.8, that turns the engine into a Model Context Protocol server. Once it is enabled, an AI assistant such as Claude can read and modify your project directly: scripts, scenes, nodes, and resources, all driven by natural language requests routed through the protocol.

The distinguishing choice is in the name. Most MCP servers for game engines run as a separate Node.js process that pokes at the editor from outside. This one implements the MCP server using Godot's own native HTTP stack, so the entire thing lives inside the editor process. There is no dependency to install, no runtime to keep alive alongside the editor, and no version drift between the tool and the engine. You enable the plugin and the server exists.

## 155 tools across six domains

The tool set is large: 155 tools in total, organized as 30 core and 125 supplementary, spread across six domains. Node tools, 9 core plus 11 advanced, create and modify scene nodes, handle duplication, renaming, signal connections, anchor presets, groups, batch operations, and scene auditing. Script tools cover editing, analyzing, creating, attaching, and validating GDScript and C# files, executing scripts, searching inside files, and symbol indexing with definition and reference lookup.

Scene tools manipulate structure, save scenes, and manage scene tabs. Editor tools control editor functionality, take screenshots, inspect signals, reload the filesystem, and manage exports. Debug tools are the deepest bench, 3 core plus 68 advanced, spanning logging, debugger sessions, breakpoints, stack and variable inspection, profilers, a runtime probe, and runtime control of animation, audio, shaders, and tilemaps. Project tools expose project settings, resources, input mappings, autoloads, and diagnostics. The breadth matters because a coding agent that has to stop and ask the user to click things loses most of its value.

## The gdmcp CLI for coding agents

Loading 155 tool schemas into a model context is wasteful, so the plugin ships a second interface aimed at agents with shell access such as Codex, Claude Code, and Cursor. The gdmcp CLI uses progressive discovery: about 33 domain commands for common operations, with on-demand schema retrieval for the supplementary tools. The quick start from the README:
```bash
gdmcp --json doctor
gdmcp --json scenes tree --depth 4
gdmcp --json scripts read res://player.gd --lines 1:200
gdmcp --json nodes properties set /root/Player --property speed --value 300
```


Every command takes a --json flag so the output is machine-readable. The CLI can be installed from the MCP dock inside the editor or from GitHub Releases, and the repository includes a companion Codex skill under skills/gdmcp that teaches an agent the CLI workflow by copying it to the codex skills directory. For agent-first workflows this is the recommended path; the raw tool list remains available for assistants that connect over the protocol directly.

## Installation and server configuration

There are two installation paths. The recommended one is the Godot Asset Library: open the AssetLib tab, search for Godot MCP Native, and install. The manual path copies the addons/godot_mcp folder into your project and enables the plugin under Project Settings. Either way, the server lives in the editor once the plugin status is set to Enable.

Two transport modes are supported. HTTP mode serves the protocol on a configurable port, 9080 by default, with optional token authentication. A headless mode lets you run the editor purely as an MCP server:
```bash
godot --editor --path /path/to/project -- --mcp-server
godot --editor --path /path/to/projectA -- --mcp-server --mcp-port=9080
godot --editor --path /path/to/projectB -- --mcp-server --mcp-port=19081
```


Settings changed in the editor panel persist to user://mcp_settings.cfg and are honored by headless mode, while command line flags take precedence, which is what makes running several projects in parallel with isolated ports straightforward.

## Connecting the major AI tools

Client configuration is documented for Claude Desktop, Cursor, Trae, Cline, OpenCode, and Codex. Claude Desktop needs the mcp-remote package installed first:
```json
{
  "mcpServers": {
    "godot-mcp": {
      "url": "http://localhost:9080/mcp"
    }
  }
}
```


Cursor and Trae use the same URL form, and authentication is a matter of adding an Authorization header with a bearer token. Cline uses a streamableHttp type entry, OpenCode uses a remote type, and Codex takes a TOML block in its configuration. The README even covers the WSL case, noting that OpenCode running inside WSL should point at the host machine IP rather than localhost. Whatever your client, the pattern is the same: point it at the editor's HTTP endpoint and the 155 tools appear.

## Practical considerations

A plugin that can edit scripts and scenes under AI instruction is powerful enough to deserve a little caution. The authentication option exists for HTTP mode, and it is worth enabling if the port is reachable beyond your machine. Screenshots from the editor give the assistant visual feedback, and the debugger and profiler tools mean an agent can observe a running game rather than guessing from static code.

For teams, the appeal is workflow integration: the same agent that writes your application code can open a scene tree, attach a script, run the project, and read the debugger output without a human shuttling text between windows. For solo developers, the main win is iteration speed on the tedious middle layer of game development, wiring nodes, adjusting exports, renaming things across scenes, where the work is mechanical and the engine already knows the answers.

## Conclusion

Godot MCP Native earns its spot in a game development toolkit by removing the two usual frictions of editor automation: the external runtime dependency and the shallow tool surface. A native MCP server inside the editor, 155 tools that reach from scene trees down to debugger state, a headless mode for CI-style automation, and a progressive-discovery CLI for coding agents add up to the most complete bridge between Godot and AI assistants currently packaged as a single plugin.

## FAQ

### Is there an MCP for Godot?

Yes. Godot MCP Native is an MIT-licensed Godot 4.x plugin that implements an MCP server natively inside the editor, exposing 155 tools for scenes, scripts, nodes, resources, editor control, and debugging over HTTP, with a gdmcp CLI for shell-based coding agents.

### Does Godot MCP Native require installing Node.js?

No. The MCP server is implemented with Godot's own native HTTP stack and runs entirely within the editor process, which is the main difference from MCP servers that run as separate Node.js processes outside the engine.

### Can I run several Godot MCP servers at the same time?

Yes. Launch each project headlessly with its own port, for example --mcp-port=9080 for one project and --mcp-port=19081 for another. Command line flags override the settings persisted in user://mcp_settings.cfg, so parallel instances stay isolated.

## Sources

- [Issues](https://github.com/yurineko73/Godot-MCP-Native/issues)
- [License: MIT](https://github.com/yurineko73/Godot-MCP-Native/blob/main/LICENSE)
- [README](https://github.com/yurineko73/Godot-MCP-Native/blob/main/README.md)
- [Releases](https://github.com/yurineko73/Godot-MCP-Native/releases)
- [yurineko73/Godot-MCP-Native on GitHub](https://github.com/yurineko73/Godot-MCP-Native)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yurineko73-godot-mcp-native