Wie installiere ich Godot Cli?

Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.

Benötigt Godot Cli einen API-Schlüssel?

In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.

Welchen Transport verwendet Godot Cli?

Godot Cli läuft lokal über stdio.

Godot Cli MCP-Server | PlugMCP

Agenten stärken

Diesen Server hinzufügen

Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführen

Host a copy with our keys and logs.

Lokaler Befehl

npx -y [email protected]

Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.

shClaude Code

1claude mcp add godot-cli -- npx -y godot-cli@0.39.3

In einem Terminal ausführen.

jsonClaude Desktop

1{2  "mcpServers": {3    "godot-cli": {4      "command": "npx",5      "args": [6        "-y",7        "[email protected]"8      ]9    }10  }11}

claude_desktop_config.json

Lokal · npmInstallation vom HerausgeberSchritt für Schritt: in Claude hinzufügen

Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden

Auf PlugMCP ausführen

Host a copy with our keys and logs.

A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.

Starten

Server-Details

Lokal

Transport: stdio
Version: 0.39.3
Zuletzt geprüft

Vom Herausgeber

Dokumentation

# 1. Install godot-cli
npm install -g godot-cli

# 2. (Optional) Scaffold a fresh Godot C# project — skip if you already have one
godot-cli create-project --dotnet ./MyGodotProject

# 3. Install the godot_mcp addon: downloads addons/godot_mcp/ from the matching
#    GitHub release, adds the required NuGet packages + the extension-catalog
#    EmbeddedResource to your .csproj, and enables the plugin in project.godot —
#    all idempotently
godot-cli install-plugin ./MyGodotProject

# 4. Sign in to the ai-game.dev cloud — OAuth 2.1 device login (opens a browser,
#    saves a machine-wide credential the editor plugin auto-adopts; no token to copy)
godot-cli login

# 5. Pick an AI agent (Claude Code, Cursor, Copilot, …) and write its MCP config —
#    pinned to THIS project's cloud route by default (pass --no-pin for the bare URL)
godot-cli setup-mcp claude-code ./MyGodotProject

# 6. Open the Godot editor — builds the C# assembly first (so the addon loads on
#    the very first open) then auto-connects with the right GODOT_MCP_* env vars
godot-cli open ./MyGodotProject

# 7. Wait until the plugin answers the readiness probe
godot-cli wait-for-ready ./MyGodotProject

Family	Tools	What it does
ping	`ping`	Lightweight readiness probe — echoes a message back, or returns `pong`. Verifies the end-to-end MCP path (editor → SignalR → tool dispatch). System tool — reachable over the server's `/api/system-tools/` HTTP surface, not advertised to AI agents in `tools/list`.
rql	`rql-query`, `rql-mutate`, `rql-schema`	Query and change the live editor with RQL: `nodes`, `root`, `selection`, `scenes`, `files`, `classes`, `console`, `editor`, `project`, `settings`, `inputActions`, `autoloads`, `groups`, `layers` sources; `godot.find` / `godot.group` / `godot.resources` / `godot.resource` / `godot.callable`; node calls AddChild / InstantiateScene / Duplicate / Reparent / MoveChild / Free / Connect / Disconnect / AddToGroup / RemoveFromGroup; project settings, input map, autoloads, layer names, TileSets, Themes, ShaderMaterial parameters and MeshLibraries; editor calls NewScene / OpenScene / SaveScene / CreateResource / MoveResource / DeleteResource / Reimport. All-or-nothing and undoable. See docs/rql.md and the `godot-rql` skill.
script	`script-read`, `script-create`, `script-update`, `script-delete`, `script-attach-to-node`, `script-validate`, `script-build`, `script-execute`	CRUD on C# (`.cs`) and GDScript (`.gd`) files, attaching a script to a node, validating GDScript, building the project's C# (the result arrives after Godot's assembly reload), and running C# in the editor (Code-Exec).
screenshot	`screenshot-viewport`, `screenshot-camera`, `screenshot-isolated`	Capture the editor viewport, a specific camera, or an isolated node render, returned as a PNG image the LLM can inspect.
console	`console-get-logs`, `console-clear-logs`	In a running game: read and clear the log collector (`GD.Print`/`GD.PushWarning`/`GD.PushError`). In the editor, the RQL `console` source.
reflection	`reflection-method-find`, `reflection-method-call`	In a running game: find and call C# methods (static/instance, public/private) across every loaded assembly via ReflectorNet. In the editor, RQL `call` / `CallMethod` and `rql-schema`.
skills	`godot-skill-create`, `godot-skill-generate`	Author a new MCP tool as a C# file in the project, and regenerate the `SKILL.md` files from the tools the editor currently has registered. System tools — reachable over the server's `/api/system-tools/` HTTP surface (like `ping`), not advertised to AI agents in `tools/list`.
session	`session-close`	Save and quit an editor started by `godot-cli exec` / `open --headless` (`godot-cli close --owned-only`). System tool, and only for that CLI session (its lease nonce).
runtime-errors	`runtime-errors-get`, `runtime-errors-clear`	Poll errors raised inside the running game (NOT the editor) — GDScript runtime errors, `push_error`/`push_warning`, shader errors, and C# unhandled / unobserved-`Task` exceptions, with multi-frame GDScript backtraces on Godot 4.5+. OFF by default — opt in with `builder.WithRuntimeErrorCapture()`.

[Godot-MCP] plugin loaded

<ItemGroup>
  <PackageReference Include="com.IvanMurzak.ReflectorNet" Version="5.5.0" />
  <PackageReference Include="com.IvanMurzak.McpPlugin"   Version="8.13.1" />
</ItemGroup>

<ItemGroup>
  <PackageReference Include="com.IvanMurzak.Rql"         Version="0.3.0-dev.0f1bf94" Condition="'$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease'" />
  <PackageReference Include="com.IvanMurzak.CodeExec"        Version="0.4.0-dev.2b784e4" Condition="'$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease'" />
  <PackageReference Include="com.IvanMurzak.CodeExec.Roslyn" Version="0.4.0-dev.2b784e4" Condition="'$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease'" />
  <PackageReference Include="Microsoft.CodeAnalysis.CSharp"  Version="4.12.0" Condition="'$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease'" />
</ItemGroup>

<ItemGroup>
  <EmbeddedResource Include="addons/godot_mcp/extensions.catalog.json" LogicalName="Godot-MCP.extensions.catalog.json" />
</ItemGroup>

Package	Version	Role
`com.IvanMurzak.ReflectorNet`	`5.5.0`	Reflection / serialization core
`com.IvanMurzak.McpPlugin`	`8.13.1`	MCP plugin client (transitively pulls `McpPlugin.Common` + `ReflectorNet`; carries the shared `AgentConfig` module)
`com.IvanMurzak.Rql`	`0.3.0-dev.0f1bf94`	RQL, the editor tools' data layer (licensed separately under PolyForm Shield — see License)
`com.IvanMurzak.CodeExec`	`0.4.0-dev.2b784e4`	Code-Exec runtime behind `script-execute` (PolyForm Shield)
`com.IvanMurzak.CodeExec.Roslyn`	`0.4.0-dev.2b784e4`	Code-Exec's Roslyn adapter, shipped as source (PolyForm Shield)
`Microsoft.CodeAnalysis.CSharp`	`4.12.0`	Roslyn, the C# compiler `script-execute` runs (its dependencies match .NET 8)

Environment variable	Purpose	Default
`GODOT_MCP_CONNECTION_MODE`	Force the mode: `Cloud` or `Custom` (case-insensitive).	`Cloud`
`GODOT_MCP_CLOUD_URL`	Override the cloud base URL. A trailing `/mcp` is stripped if present; a non-http(s) value falls back to the default.	`https://ai-game.dev`
`GODOT_MCP_CREDENTIALS_DIR`	Absolute credential-store directory for isolated development/testing. Also accepted in the project's `.env`; process environment wins. Omit for the regular machine store.	Platform user profile's `.ai-game-dev`
`GODOT_MCP_TOKEN`	Bearer token, routed to the active mode's token. Surrounding quotes are trimmed.	(none)

Environment variable	Purpose	Default
`GODOT_MCP_CONNECTION_MODE`	Set to `Custom` to select this mode.	`Cloud`
`GODOT_MCP_HOST`	The custom server URL. Must be an absolute http(s) URL or it falls back to the default.	`http://localhost:8080`
`GODOT_MCP_TOKEN`	Bearer token (only needed if the server requires authorization).	(none)

export GODOT_MCP_CONNECTION_MODE=Custom
export GODOT_MCP_HOST=http://localhost:5300
# export GODOT_MCP_TOKEN=...   # only if the server enforces auth

# HTTP transport on port 8080
./gamedev-mcp-server --client-transport streamableHttp --port 8080

# stdio transport — for local MCP clients that launch the server directly
./gamedev-mcp-server --client-transport stdio

[AiToolType]
public partial class Tool_MyFeature
{
    [AiTool("my-custom-task", Title = "Do a custom task")]
    [Description("Explain to the LLM what this does and when to call it.")]
    public string CustomTask
    (
        [Description("Explain to the LLM what this parameter is.")]
        string inputData
    )
    {
        // ... work that does not touch the Godot API can run on this background thread ...

        return MainThread.Instance.Run(() =>
        {
            // ... touch EditorInterface / Node / Resource here, on the main thread ...
            return "[Success] Operation completed.";
        });
    }
}

using System.Reflection;
using com.IvanMurzak.Godot.MCP.Connection;   // GodotMcpConnectionMode
using com.IvanMurzak.Godot.MCP.Runtime;      // GodotMcpRuntime
using McpServerConsts = com.IvanMurzak.McpPlugin.Common.Consts.MCP.Server;   // AuthOption (none/oauth/token)
using Godot;

public partial class GameMcp : Node
{
    private GodotMcpRuntimeHandle? _mcp;

    public override async void _Ready()
    {
        // 1) Build the connection (default OFF — nothing connects yet).
        _mcp = GodotMcpRuntime.Initialize(builder =>
        {
            builder.WithConfig(config =>
            {
                config.ConnectionMode = GodotMcpConnectionMode.Custom;         // your own server
                config.Host           = "http://localhost:8080";               // prefer loopback
                config.AuthOption     = McpServerConsts.AuthOption.token;      // offline bearer-token auth
                config.Token          = "your-secret-token";
            });

            // 2) Opt YOUR tools / prompts / resources in. Zero of each by default — this is the only way
            //    they get registered, and each kind is independently optional.
            builder.WithToolsFromAssembly(Assembly.GetExecutingAssembly());     // [AiToolType] classes
            builder.WithPromptsFromAssembly(Assembly.GetExecutingAssembly());   // [AiPromptType] classes
            builder.WithResourcesFromAssembly(Assembly.GetExecutingAssembly()); // [AiResourceType] classes
            //   …or register specific families:
            //   builder.WithTools(typeof(GameMcpTools));
            //   builder.WithPrompts(typeof(GameMcpPrompts));
            //   builder.WithResources(typeof(GameMcpResources));
        }).Build();

        // 3) Connect — explicit, the security-required opt-in. Retries in the background while
        //    KeepConnected is true (the default).
        await _mcp.Connect();
    }

    public override async void _ExitTree()
    {
        // 4) Disconnect on shutdown (or whenever you want to stop exposing tools).
        if (_mcp is not null)
            await _mcp.Disconnect();
    }
}

Call	What it does
`GodotMcpRuntime.Initialize(configure)`	Begin configuring; returns a `GodotMcpRuntimeBuilder`. `configure` may be `null` for the zero-tool, env-configured default.
`builder.WithConfig(Action<GodotMcpConfig>)`	Set `Host` / `Token` / `ConnectionMode` / `AuthOption` in code. Multiple calls compose in order.
`builder.WithToolsFromAssembly(Assembly)`	Register every `[AiToolType]` class in an assembly (usually `Assembly.GetExecutingAssembly()`).
`builder.WithTools(params Type[])`	Register specific `[AiToolType]` classes when a whole-assembly scan is too broad.
`builder.WithPromptsFromAssembly(Assembly)`	Register every `[AiPromptType]` class in an assembly. Independent of tools/resources.
`builder.WithPrompts(params Type[])`	Register specific `[AiPromptType]` classes.
`builder.WithResourcesFromAssembly(Assembly)`	Register every `[AiResourceType]` class in an assembly. Independent of tools/prompts.
`builder.WithResources(params Type[])`	Register specific `[AiResourceType]` classes.
`builder.WithoutMainThreadDispatcher()`	Skip the automatic main-thread-dispatcher bootstrap (only if you install your own autoload dispatcher).
`builder.ConnectWhenRunFromEditor()`	Let `handle.Connect()` connect in a game started from the Godot editor (Play) too. OFF by default: see "Games run from the editor" below.
`builder.WithRuntimeErrorCapture()`	Capture errors raised in the running game (GDScript runtime errors, `push_error`/`push_warning`, shader errors via the Godot 4.5+ engine hook; C# unhandled / unobserved-`Task` exceptions with full stack traces) and register the `runtime-errors-` tool so an agent can poll them. OFF by default.* See "Capturing in-game runtime errors" below.
`builder.WithScriptExecute()`	Register `script-execute` in the game: the agent's C# is compiled with Roslyn and run on the game's main thread. OFF by default, needs the csproj opt-in, arbitrary code execution. See "Running C# in the game" below.
`builder.Build()`	Finalize; returns a default-OFF `GodotMcpRuntimeHandle`.
`handle.Connect()` / `handle.Disconnect()`	Open / close the connection. `handle.Dispose()` tears it down on shutdown.

_mcp = GodotMcpRuntime.Initialize(builder =>
{
    builder.WithConfig(cfg => { /* host / token … */ });
    builder.WithRuntimeErrorCapture();   // capture in-game runtime errors + expose the runtime-errors-* tool
}).Build();

await _mcp.Connect();

Tool	What it returns / does
`runtime-errors-get`	A bounded, newest-kept list of `{ sequence, message, type, source, file, line, function, stackTrace, frames, timestamp }`. Pass the previous result's `highestSequence` as `sinceSequence` to poll only new errors — the "did anything break since I last looked?" loop. Returns `available:false` when capture was never enabled (so an empty list is never mistaken for health).
`runtime-errors-clear`	Clears the captured buffer (the monotonic `sequence` counter is preserved, so a pre-clear `sinceSequence` poll still behaves).

<PropertyGroup>
  <GodotMcpCodeExecInGame>true</GodotMcpCodeExecInGame>
  <DefineConstants>$(DefineConstants);GODOT_MCP_CODE_EXEC_IN_GAME</DefineConstants>
</PropertyGroup>

_mcp = GodotMcpRuntime.Initialize(builder =>
{
    builder.WithConfig(cfg => { /* loopback host + token */ });
    builder.WithScriptExecute();
}).Build();

using System.ComponentModel;
using com.IvanMurzak.McpPlugin;              // [AiToolType], [AiTool]
using com.IvanMurzak.ReflectorNet.Utils;     // MainThread
using Godot;

[AiToolType]
public partial class GameMcpTools
{
    [AiTool("game-ping", Title = "Game Ping", ReadOnlyHint = true, IdempotentHint = true)]
    [Description("Runtime readiness probe. Echoes 'message' back, or returns 'pong-from-game' when omitted.")]
    public string GamePing(
        [Description("Optional message to echo back. When null/empty, returns 'pong-from-game'.")]
        string? message = null)
    {
        return string.IsNullOrEmpty(message) ? "pong-from-game" : message;
    }

    [AiTool("game-scene-tree-summary", Title = "Game Scene-Tree Summary", ReadOnlyHint = true)]
    [Description("Summary of the LIVE running game's SceneTree (current scene + root child node names).")]
    public SceneTreeSummary GameSceneTreeSummary()
    {
        // Touch the live SceneTree on the engine main thread — MainThread.Instance was installed by
        // GodotMcpRuntime.Initialize(...). Touching Node APIs off the main thread would fault.
        return MainThread.Instance.Run(() =>
        {
            var summary = new SceneTreeSummary();
            if (Engine.GetMainLoop() is not SceneTree tree || tree.Root == null)
            {
                summary.CurrentSceneName = "<no-scene-tree>";
                return summary;
            }

            summary.CurrentSceneName = tree.CurrentScene?.Name ?? "<none>";
            summary.RootChildCount   = tree.Root.GetChildCount();
            foreach (var child in tree.Root.GetChildren())
                summary.RootChildNames.Add(child.Name);
            return summary;
        });
    }
}

// Structured result (ReflectorNet-serialized — never ad-hoc string formatting for parseable output).
public sealed class SceneTreeSummary
{
    public string CurrentSceneName { get; set; } = string.Empty;
    public int RootChildCount { get; set; }
    public System.Collections.Generic.List<string> RootChildNames { get; set; } = new();
}

using System.ComponentModel;
using com.IvanMurzak.McpPlugin;               // [AiPromptType], [AiPrompt], [AiResourceType], [AiResource]
using com.IvanMurzak.McpPlugin.Common.Model;  // Role, ResponseResourceContent
using com.IvanMurzak.ReflectorNet.Utils;      // MainThread
using Godot;

// A PROMPT — a named, reusable instruction the LLM can request. Returns the prompt text; Role marks who
// the message is from. Set Enabled = false to ship a prompt registered-but-off until you flip it on.
[AiPromptType]
public partial class GameMcpPrompts
{
    [AiPrompt(Name = "explain-game-state", Role = Role.User)]
    [Description("Ask the assistant to summarize the current game state for the player.")]
    public string ExplainGameState()
    {
        return "Read the live SceneTree via the game tools and explain the current game state in one paragraph.";
    }
}

// A RESOURCE — addressable read-only content fetched by URI. Route is the URI template; the method
// returns ResponseResourceContent[]. Any Godot API access marshals onto the main thread, exactly like a tool.
[AiResourceType]
public partial class GameMcpResources
{
    [AiResource(
        Name = "Live SceneTree node names",
        Route = "game://scene-tree/nodes",
        MimeType = "application/json",
        Description = "The root child node names of the live running game's SceneTree.")]
    public ResponseResourceContent[] SceneTreeNodes(string uri)
    {
        return MainThread.Instance.Run(() =>
        {
            var names = new System.Collections.Generic.List<string>();
            if (Engine.GetMainLoop() is SceneTree tree && tree.Root != null)
            {
                foreach (var child in tree.Root.GetChildren())
                    names.Add(child.Name);
            }

            var json = System.Text.Json.JsonSerializer.Serialize(names);
            return new[] { ResponseResourceContent.CreateText(uri, json, "application/json") };
        });
    }
}

In code — builder.WithConfig(c => { c.Host = …; c.Token = …; }), as above.

Out-of-band — GODOT_MCP_* process environment variables or a project .env file (read live by GodotMcpConfig, so a build can be reconfigured without recompiling):

Environment variable	Values	Description
`GODOT_MCP_CONNECTION_MODE`	`Cloud` / `Custom`	Connection mode (a loopback host implies `Custom`).
`GODOT_MCP_CLOUD_URL`	URL	Override the Cloud base URL (default `https://ai-game.dev`).
`GODOT_MCP_HOST`	URL	Custom-mode server host (default `http://localhost:8080`).
`GODOT_MCP_AUTH_OPTION`	`none` / `oauth` / `token`	Custom-mode auth: anonymous / account (oauth) / offline bearer (`token`).
`GODOT_MCP_TOKEN`	string	The bearer token (routed to Cloud or Custom by the active mode).
`GODOT_MCP_LOG_LEVEL`	`Trace`…`None`	Log-verbosity threshold.
`GODOT_MCP_SERVER_PATH`	absolute path	Editor-only (dev / CI). Launch this existing `gamedev-mcp-server(.exe)` instead of the pinned release: skips the download and the version match, and disables orphaned-server cleanup while active. A value naming no existing file is ignored.

GODOT_MCP_SERVER_PATH is resolved by the editor plugin's server manager, not by GodotMcpConfig, so it affects only which locally-hosted server binary the editor starts, and it has no effect in a game build. It is read once per plugin assembly load and cached — a C# hot-reload re-reads it, but toggling the plugin off and on does not. It uses the same process-env → project .env precedence as the rows above. Orphan cleanup is disabled while it is set because that cleanup claims every server process running from the same directory, which an override binary is expected to share with other projects and tools. A value that names no existing file is ignored with a warning in the editor log. On Linux/macOS the file must already be executable — the chmod applied to a downloaded release is not applied to an override binary.

export GODOT_MCP_CONNECTION_MODE=Custom
export GODOT_MCP_HOST=http://localhost:8080
export GODOT_MCP_AUTH_OPTION=token
export GODOT_MCP_TOKEN=your-secret-token

dotnet restore Godot-MCP.sln
dotnet build  Godot-MCP.sln --configuration Debug --no-restore   # 0 errors required (CI gate)
dotnet test   Godot-MCP.Tests/Godot-MCP.Tests.csproj --configuration Debug --no-build

Godot Cli

Q: Wann wurde Godot Cli zuletzt geprüft?

Zuletzt geprüft: 2026-11-14. Cross-platform CLI tool for Godot-MCP (Skills & MCP). Resolves and launches the Godot editor with MCP connection env vars, runs MCP/system tools over HTTP, probes server health, configures AI agents (Claude Code, Cursor, VS Code, …), and enables/disables

GitHub ActionsDiesen Server beanspruchen

Cross-platform CLI tool for Godot-MCP (Skills & MCP). Resolves and launches the Godot editor with MCP connection env vars, runs MCP/system tools over HTTP, probes server health, configures AI agents (

Devops Game Development Developer Tools

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführenDiesen Server beanspruchen

GitHub

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführen

1{2  "mcpServers": {3    "godot-cli": {4      "command": "npx",5      "args": [6        "-y",7        "[email protected]"8      ]9    }10  }11}

.cursor/mcp.jsonMCP-Server

Transport: stdio
Status: Lokal

Diesen Server hinzufügen

Host a copy with our keys and logs.

Server-Details

Dokumentation

Quick Start

Contents

Tools Reference

Requirements

Installation

Step 1: Add the addon

Option A — Godot Asset Library (recommended)

Option B — GitHub Release zip

Option C — copy from source

Step 2: Add the NuGet packages + the extension catalog embed

Step 3: Install an AI agent

Connect

Cloud mode (default) — ai-game.dev

Custom mode — your own server

Godot MCP Server setup

Local server — let the addon download & run it for you

Run the server manually (advanced)

Customize Tools

C# assembly reloads

Runtime usage (in-game)

Games run from the editor

Capturing in-game runtime errors

Running C# in the game

Sample: a live game-state tool

Sample: a prompt and a resource

Where the server URL and token come from

Security: opt-in only, default OFF

Editor-side security notes (accepted posture)

How Godot MCP Architecture Works

What is MCP

What is an AI agent

What is the MCP Server

What is an MCP Tool

Building & contributing

License

Extension modules

Über Godot Cli

Tools

Fragen

Wie installiere ich Godot Cli?

Benötigt Godot Cli einen API-Schlüssel?

Welchen Transport verwendet Godot Cli?

Wann wurde Godot Cli zuletzt geprüft?

Godot `MCP Server` setup

What is `MCP`

What is an `AI agent`

What is the `MCP Server`

What is an `MCP Tool`