Skip to content
Back to search

Godot-MCP

An MCP for Godot that lets you create and edit games in the Godot game engine with tools like Claude

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ee0pdt--godot-mcp/badge.svg)](/listings/ee0pdt--godot-mcp)

HTML

<a href="/listings/ee0pdt--godot-mcp"><img src="/api/listings/ee0pdt--godot-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Clone the Repository

git clone https://github.com/ee0pdt/godot-mcp.git
cd godot-mcp

2. Set Up the MCP Server

cd server
npm install
npm run build
# Return to project root
cd ..

3. Set Up Claude Desktop

1. Edit or create the Claude Desktop config file:

   # For macOS
   nano ~/Library/Application\ Support/Claude/claude_desktop_config.json

2. Add the following configuration (or use the included `claude_desktop_config.json` as a reference):

   {
	 "mcpServers": {
	   "godot-mcp": {
		 "command": "node",
		 "args": [
		   "PATH_TO_YOUR_PROJECT/server/dist/index.js"
		 ],
		 "env": {
		   "MCP_TRANSPORT": "stdio"
		 }
	   }
	 }
   }

> **Note**: Replace `PATH_TO_YOUR_PROJECT` with the absolute path to where you have this repository stored.

3. Restart Claude Desktop

4. Open the Example Project in Godot

1. Open Godot Engine 2. Select "Import" and navigate to the cloned repository 3. Open the `project.godot` file 4. The MCP plugin is already enabled in this example project

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 177 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Godot MCP (Model Context Protocol)
  2. A comprehensive integration between Godot Engine and AI assistants using the Model Context Protocol (MCP). This plugin allows AI assistants to interact with your Godot projects, providing powerful capabilities for code assistance, scene manipulation, and project management.
  3. ## Features
  4. - **Full Godot Project Access**: AI assistants can access and modify scripts, scenes, nodes, and project resources
  5. - **Two-way Communication**: Send project data to AI and apply suggested changes directly in the editor
  6. - **Command Categories**:
  7. - **Node Commands**: Create, modify, and manage nodes in your scenes
  8. - **Script Commands**: Edit, analyze, and create GDScript files
  9. - **Scene Commands**: Manipulate scenes and their structure
  10. - **Project Commands**: Access project settings and resources
  11. - **Editor Commands**: Control various editor functionality
  12. ## Quick Setup
  13. ### 1. Clone the Repository
  14. ```bash
  15. git clone https://github.com/ee0pdt/godot-mcp.git
  16. cd godot-mcp
  17. ```
  18. ### 2. Set Up the MCP Server
  19. ```bash
  20. cd server
  21. npm install
  22. npm run build
  23. # Return to project root
  24. cd ..
  25. ```
  26. ### 3. Set Up Claude Desktop
  27. 1. Edit or create the Claude Desktop config file:
  28. ```bash
  29. # For macOS
  30. nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
  31. ```
  32. 2. Add the following configuration (or use the included `claude_desktop_config.json` as a reference):
  33. ```json
  34. {
  35. "mcpServers": {
  36. "godot-mcp": {
  37. "command": "node",
  38. "args": [
  39. "PATH_TO_YOUR_PROJECT/server/dist/index.js"
  40. ],
  41. "env": {
  42. "MCP_TRANSPORT": "stdio"
  43. }
  44. }
  45. }
  46. }
  47. ```
  48. > **Note**: Replace `PATH_TO_YOUR_PROJECT` with the absolute path to where you have this repository stored.
  49. 3. Restart Claude Desktop
  50. ### 4. Open the Example Project in Godot
  51. 1. Open Godot Engine
  52. 2. Select "Import" and navigate to the cloned repository
  53. 3. Open the `project.godot` file
  54. 4. The MCP plugin is already enabled in this example project
  55. ## Using MCP with Claude
  56. After setup, you can work with your Godot project directly from Claude using natural language. Here are some examples:
  57. ### Example Prompts
  58. ```
  59. @mcp godot-mcp read godot://script/current
  60. I need help optimizing my player movement code. Can you suggest improvements?
  61. ```
  62. ```
  63. @mcp godot-mcp run get-scene-tree
  64. Add a cube in the middle of the scene and then make a camera that is looking at the cube.
  65. ```
  66. ```
  67. @mcp godot-mcp read godot://scene/current
  68. Create an enemy AI that patrols between waypoints and attacks the player when in range.
  69. ```
  70. ### Natural Language Tasks Claude Can Perform
  71. - "Create a main menu with play, options, and quit buttons"
  72. - "Add collision detection to the player character"
  73. - "Implement a day/night cycle system"
  74. - "Refactor this code to use signals instead of direct references"
  75. - "Debug why my player character falls through the floor sometimes"
  76. ## Available Resources and Commands
  77. ### Resource Endpoints:
  78. - `godot://script/current` - The currently open script
  79. - `godot://scene/current` - The currently open scene
  80. - `godot://project/info` - Project metadata and settings
  81. ### Command Categories:
  82. #### Node Commands
  83. - `get-scene-tree` - Returns the scene tree structure
  84. - `get-node-properties` - Gets properties of a specific node
  85. - `create-node` - Creates a new node
  86. - `delete-node` - Deletes a node
  87. - `modify-node` - Updates node properties
  88. #### Script Commands
  89. - `list-project-scripts` - Lists all scripts in the project
  90. - `read-script` - Reads a specific script
  91. - `modify-script` - Updates script content
  92. - `create-script` - Creates a new script
  93. - `analyze-script` - Provides analysis of a script
  94. #### Scene Commands
  95. - `list-project-scenes` - Lists all scenes in the project
  96. - `read-scene` - Reads scene structure
  97. - `create-scene` - Creates a new scene
  98. - `save-scene` - Saves current scene
  99. #### Project Commands
  100. - `get-project-settings` - Gets project settings
  101. - `list-project-resources` - Lists project resources
  102. #### Editor Commands
  103. - `get-editor-state` - Gets current editor state
  104. - `run-project` - Runs the project
  105. - `stop-project` - Stops the running project
  106. ## Troubleshooting
  107. ### Connection Issues
  108. - Ensure the plugin is enabled in Godot's Project Settings
  109. - Check the Godot console for any error messages
  110. - Verify the server is running when Claude Desktop launches it
  111. ### Plugin Not Working
  112. - Reload Godot project after any configuration changes
  113. - Check for error messages in the Godot console
  114. - Make sure all paths in your Claude Desktop config are absolute and correct
  115. ## Adding the Plugin to Your Own Godot Project
  116. If you want to use the MCP plugin in your own Godot project:
  117. 1. Copy the `addons/godot_mcp` folder to your Godot project's `addons` directory
  118. 2. Open your project in Godot
  119. 3. Go to Project > Project Settings > Plugins
  120. 4. Enable the "Godot MCP" plugin
  121. ## Contributing
  122. Contributions are welcome! Please feel free to submit a Pull Request.
  123. ## Documentation
  124. For more detailed information, check the documentation in the `docs` folder:
  125. - [Getting Started](docs/getting-started.md)
  126. - [Installation Guide](docs/installation-guide.md)
  127. - [Command Reference](docs/command-reference.md)
  128. - [Architecture](docs/architecture.md)
  129. ## License
  130. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.