# Installation

Install the Godot MCP addon with the AI Game Dev app, godot-cli, the Godot Asset Library or a release zip, with the exact NuGet packages for your .csproj.

_Last updated: 2026-11-04_

This page shows every way to add Godot MCP to a Godot C# project and what each one does for you. If you just want it working, use the desktop app or `godot-cli`: both install the addon, patch your `.csproj` and enable the plugin in one step. The manual paths (Asset Library, release zip) need two extra steps that are easy to miss.

## Requirements

| Requirement | Details |
| --- | --- |
| Godot | Godot 4.3 or newer, **.NET (mono) edition**. The addon is built against `Godot.NET.Sdk` 4.3.0 as its minimum; the project's CI boots it on 4.3, 4.4, 4.5, 4.6 and 4.7. |
| .NET | The .NET 8 SDK (`net8.0`). |
| Project | A Godot project with a C# `.csproj` at its root. |
| `godot-cli` (optional) | Node.js `^20.19.0` or `>=22.12.0`. |
| Operating system | Windows, macOS or Linux. |

**Warning**

The standard Godot download (GDScript only) cannot compile the addon. Download the .NET build of Godot. If your project has no `.csproj` yet, create one from Godot (Project, Tools, C#, Create C# solution) or scaffold a new project with `godot-cli create-project --dotnet`.

## Option 1: the AI Game Dev desktop app

The [AI Game Dev app](https://ai-game.dev/docs/wiki/app) can install Godot MCP into a project you select, then open the editor already connected to your account. It ships its own copy of the installer, so you do not need Node.js or npm. The app always installs the newest released addon and does the same three things as `godot-cli install-plugin`: it puts the addon files in `addons/godot_mcp/`, adds the NuGet packages and the extension catalog to your `.csproj`, and enables the plugin in `project.godot`.

Download the app from the [download page](https://ai-game.dev/download). How to install it and pick a project is on [App installation](https://ai-game.dev/docs/wiki/app/installation); the app's command line is described on [App CLI](https://ai-game.dev/docs/wiki/app/cli).

## Option 2: godot-cli (terminal)

`godot-cli` is the npm package for Godot MCP. Its `install-plugin` command is a full installer and is safe to run again: a second run changes nothing.

```bash
npm install -g godot-cli
godot-cli install-plugin ./MyGodotProject
```

What `install-plugin` does, in order:

1. Downloads `godot-mcp-addon-<version>.zip` from the Godot-MCP GitHub release (HTTPS, github.com only) and puts it in `res://addons/godot_mcp/`. The version defaults to the CLI's own version.
2. Adds the NuGet `PackageReference`s the installed addon needs to your `.csproj`, taking the versions from the addon itself, and fixes stale versions.
3. Adds the extension catalog `<EmbeddedResource>` and sets `<EnableDynamicLoading>true</EnableDynamicLoading>`.
4. Enables the plugin in the `[editor_plugins]` section of `project.godot`.

Useful variants:

```bash
# A specific addon release
godot-cli install-plugin --version 0.34.0 ./MyGodotProject

# Offline or development install from a local copy of the addon
godot-cli install-plugin --source ./Godot-MCP/addons/godot_mcp ./MyGodotProject

# No project yet: scaffold a Godot C# project first
godot-cli create-project --dotnet ./MyGodotProject
```

You can also run it without a global install: `npx godot-cli install-plugin ./MyGodotProject`. All flags are listed in the [godot-cli reference](https://ai-game.dev/docs/wiki/godot/cli).

## Option 3: Godot Asset Library

1. In the Godot editor, open the **AssetLib** tab at the top.
2. Search for **Godot-MCP** and open the asset.
3. Click **Download**, then **Install**. Godot unpacks the addon into `res://addons/godot_mcp/`.
4. Add the NuGet packages and the catalog line to your `.csproj` (see below).
5. Enable the plugin (see below).

The Asset Library entry always points at a tagged release, so you get a known-good snapshot. It contains only the addon files: steps 4 and 5 are still yours to do.

## Option 4: GitHub release zip or source copy

Download `godot-mcp-addon-<version>.zip` from the [Godot-MCP releases](https://github.com/IvanMurzak/Godot-MCP/releases/latest) page and extract it into the project root. The archive already contains `addons/godot_mcp/`, so the files land in `res://addons/godot_mcp/`. You can also copy the `addons/godot_mcp/` folder from a clone of the repository. Then do the two manual steps below.

## Manual step: NuGet packages and the extension catalog

Godot compiles every `.cs` file in your project into one assembly, so your `.csproj` must reference the same NuGet packages the addon uses, or the addon will not compile. Add this to your `.csproj` (these are the versions for addon 0.34.0):

```xml
<ItemGroup>
  <PackageReference Include="com.IvanMurzak.ReflectorNet" Version="5.5.1" />
  <PackageReference Include="com.IvanMurzak.McpPlugin" Version="8.14.0" />
</ItemGroup>

<!-- Editor-only: exported games ship no RQL and no Roslyn. -->
<ItemGroup>
  <PackageReference Include="com.IvanMurzak.Rql" Version="0.3.0" Condition="'$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease'" />
  <PackageReference Include="com.IvanMurzak.CodeExec" Version="0.4.0" Condition="'$(GodotMcpCodeExecInGame)' == 'true' or ('$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease')" />
  <PackageReference Include="com.IvanMurzak.CodeExec.Roslyn" Version="0.4.0" Condition="'$(GodotMcpCodeExecInGame)' == 'true' or ('$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease')" />
  <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" Condition="'$(GodotMcpCodeExecInGame)' == 'true' or ('$(Configuration)' != 'ExportDebug' and '$(Configuration)' != 'ExportRelease')" />
</ItemGroup>

<!-- Without this line the dock's Extensions list is empty. -->
<ItemGroup>
  <EmbeddedResource Include="addons/godot_mcp/extensions.catalog.json" LogicalName="Godot-MCP.extensions.catalog.json" />
</ItemGroup>
```

| Package | Version (addon 0.34.0) | Role |
| --- | --- | --- |
| `com.IvanMurzak.ReflectorNet` | 5.5.1 | Reflection and serialization core |
| `com.IvanMurzak.McpPlugin` | 8.14.0 | MCP client that connects the editor to the server |
| `com.IvanMurzak.Rql` | 0.3.0 | RQL, the query language behind the editor tools (editor only) |
| `com.IvanMurzak.CodeExec` | 0.4.0 | Runs C# snippets for `script-execute` (editor only unless you opt in) |
| `com.IvanMurzak.CodeExec.Roslyn` | 0.4.0 | Roslyn adapter for Code-Exec |
| `Microsoft.CodeAnalysis.CSharp` | 4.12.0 | The Roslyn C# compiler |

The versions must match the addon you installed. Each release lists them in its README, and the release zip carries them in `addons/godot_mcp/nuget-deps.json`; `godot-cli install-plugin` reads that file, which is why it never gets them wrong. The development branch already moves `com.IvanMurzak.McpPlugin` forward (8.18.0), so check again when you update.

Also keep `<EnableDynamicLoading>true</EnableDynamicLoading>` in the `<PropertyGroup>` of your `.csproj`. Godot's own C# template has it. Without it, a game started with Play cannot create any C# script.

You do not need to copy DLLs. Run `dotnet restore` (or build from Godot) and the addon finds the packages in your NuGet cache at editor time.

## Manual step: enable the plugin

Open **Project, Project Settings, Plugins** and enable **Godot-MCP**. Build the C# project (the Build button in the editor, or `godot-cli build`). On a successful load the Output panel prints:

```text
[Godot-MCP] plugin loaded
```

The **AI Game Developer** dock appears in the upper-right dock area. Continue with [Getting started](https://ai-game.dev/docs/wiki/godot/getting-started).

## Updating and removing

- Update with the same tool you installed with: rerun `godot-cli install-plugin` (optionally with `--version`), use the app, or install the new release from the Asset Library and update the NuGet versions by hand.
- Update the CLI itself with `godot-cli update`.
- `godot-cli remove-plugin ./MyGodotProject` disables the addon in `project.godot`. It does not delete `addons/godot_mcp/` or the `.csproj` entries; remove those by hand if you want them gone.

## Exported games

The RQL, Code-Exec and Roslyn packages carry a `Condition` that leaves them out of `ExportDebug` and `ExportRelease` builds, so your exported game does not ship them. The addon's editor tools are compiled only in the editor and never reach a game build. Exposing tools from a running game is opt-in and described on [Custom tools](https://ai-game.dev/docs/wiki/godot/custom-tools).

---

Source (HTML): https://ai-game.dev/docs/wiki/godot/installation