Skip to content
Back to search

godot-mcp

A Model Context Protocol (MCP) server for interacting with the Godot game engine.

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/bradypp--godot-mcp/badge.svg)](/listings/bradypp--godot-mcp)

HTML

<a href="/listings/bradypp--godot-mcp"><img src="/api/listings/bradypp--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.

Clone and Build

# Clone the repository
git clone https://github.com/bradypp/godot-mcp.git
cd godot-mcp

# Install dependencies
npm install

# Build the project
npm run build

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 · 783 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
  2. [![](https://badge.mcpx.dev?type=server 'MCP Server')](https://modelcontextprotocol.io/introduction)
  3. [![Made with Godot](https://img.shields.io/badge/Made%20with-Godot-478CBF?style=flat&logo=godot%20engine&logoColor=white)](https://godotengine.org)
  4. [![](https://img.shields.io/badge/Node.js-339933?style=flat&logo=nodedotjs&logoColor=white 'Node.js')](https://nodejs.org/en/download/)
  5. [![](https://img.shields.io/badge/TypeScript-3178C6?style=flat&logo=typescript&logoColor=white 'TypeScript')](https://www.typescriptlang.org/)
  6. [![](https://img.shields.io/github/last-commit/bradypp/godot-mcp 'Last Commit')](https://github.com/bradypp/godot-mcp/commits/main)
  7. [![](https://img.shields.io/github/stars/bradypp/godot-mcp 'Stars')](https://github.com/bradypp/godot-mcp/stargazers)
  8. [![](https://img.shields.io/github/forks/bradypp/godot-mcp 'Forks')](https://github.com/bradypp/godot-mcp/network/members)
  9. [![](https://img.shields.io/badge/License-MIT-red.svg 'MIT License')](https://opensource.org/licenses/MIT)
  10. **A comprehensive Model Context Protocol (MCP) server for seamless AI assistant integration with the Godot game engine.**
  11. ## Table of Contents
  12. - [What is Godot MCP?](#what-is-godot-mcp)
  13. - [Features](#features)
  14. - [Requirements](#requirements)
  15. - [Installation](#installation)
  16. - [Configuration](#configuration)
  17. - [API Reference](#api-reference)
  18. - [Project Architecture](#project-architecture)
  19. - [Usage Examples](#usage-examples)
  20. - [Read-Only Mode](#read-only-mode)
  21. - [Troubleshooting](#troubleshooting)
  22. - [FAQ](#faq)
  23. - [Contributing](#contributing)
  24. - [License](#license)
  25. ## What is Godot MCP?
  26. Godot MCP bridges the gap between AI assistants and the Godot game engine by providing a standardized Model Context Protocol interface. This powerful integration enables AI assistants like Claude, Cursor, and Cline to directly interact with Godot projects through a comprehensive set of tools.
  27. ### Key Value Propositions
  28. - **Direct Godot Integration**: Launch editors, run projects, and capture debug output programmatically
  29. - **Scene Management**: Create, modify, and manage Godot scenes through AI commands
  30. - **Real-time Feedback**: AI assistants can see actual Godot output and errors for better assistance
  31. - **Cross-platform Compatibility**: Works seamlessly on Windows, macOS, and Linux
  32. - **Secure Operations**: Optional read-only mode for safe project analysis
  33. - **Zero Configuration**: Automatic Godot detection with manual override options
  34. ### How It Works
  35. The server acts as a middleware layer between your AI assistant and Godot, translating natural language commands into specific Godot operations. When you ask your AI to "create a player scene with a sprite," the MCP server:
  36. 1. Validates the request and project structure
  37. 2. Executes the appropriate Godot operations
  38. 3. Returns detailed success/error feedback
  39. 4. Enables the AI to understand and respond to the results
  40. This creates a powerful feedback loop where AI assistants can learn from actual Godot behavior, leading to more accurate code generation and debugging assistance.
  41. ## Features
  42. ### Core Project Management
  43. - **🚀 Launch Godot Editor**: Open the Godot editor for specific projects
  44. - **▶️ Run Godot Projects**: Execute projects in debug mode with real-time output capture
  45. - **🛑 Control Execution**: Start and stop Godot projects programmatically
  46. - **📊 Debug Output Capture**: Retrieve comprehensive console output and error messages
  47. - **ℹ️ System Information**: Get installed Godot version and project metadata
  48. - **📁 Project Discovery**: Find and list Godot projects in specified directories
  49. ### Advanced Scene Management
  50. - **🎬 Create New Scenes**: Generate scenes with specified root node types
  51. - **➕ Add Nodes**: Insert nodes into existing scenes with customizable properties
  52. - **✏️ Edit Node Properties**: Modify positions, scales, textures, and other node attributes
  53. - **🗑️ Remove Nodes**: Clean up scenes by removing unwanted nodes
  54. - **🖼️ Load Sprites**: Automatically load textures into Sprite2D nodes
  55. - **🧱 Export MeshLibrary**: Convert 3D scenes to MeshLibrary resources for GridMap
  56. - **💾 Save Scene Variants**: Create scene copies and manage scene versions
  57. ### Godot 4.4+ UID Management
  58. - **🔗 Get File UIDs**: Retrieve unique identifiers for project resources
  59. - **🔄 Update UID References**: Maintain proper resource links during project upgrades
  60. ### Security & Safety
  61. - **🔒 Read-Only Mode**: Restrict operations to analysis-only for secure environments
  62. - **✅ Path Validation**: Comprehensive project and file path verification
  63. - **🛡️ Error Handling**: Robust error reporting with actionable suggestions
  64. ## Requirements
  65. ### System Requirements
  66. - **Godot Engine**: Version 3.5+ or 4.0+ (latest stable recommended)
  67. - **Node.js & npm**
  68. ### AI Assistant Compatibility
  69. - **Cline & Roo Code**: Full support with auto-approval configuration
  70. - **Cursor & VS Code**: Supports both UI and project-specific configuration
  71. - **Claude Desktop**: Compatible with MCP server integration
  72. - **Other MCP-enabled tools**: Any tool supporting the Model Context Protocol
  73. ## Installation
  74. ### Clone and Build
  75. ```bash
  76. # Clone the repository
  77. git clone https://github.com/bradypp/godot-mcp.git
  78. cd godot-mcp
  79. # Install dependencies
  80. npm install
  81. # Build the project
  82. npm run build
  83. ```
  84. ## Configuration
  85. ### Option A: Cline Configuration
  86. Add to your Cline MCP settings file:
  87. ```json
  88. {
  89. "mcpServers": {
  90. "godot": {
  91. "command": "node",
  92. "args": ["/absolute/path/to/godot-mcp/build/index.js"],
  93. "env": {
  94. "DEBUG": "false",
  95. "READ_ONLY": "false",
  96. "GODOT_PATH": "/path/to/godot"
  97. },
  98. "disabled": false,
  99. "autoApprove": [
  100. "launch_editor",
  101. "run_project",
  102. "get_debug_output",
  103. "stop_project",
  104. "get_godot_version",
  105. "list_projects",
  106. "get_project_info",
  107. "create_scene",
  108. "add_node",
  109. "edit_node",
  110. "remove_node",
  111. "load_sprite",
  112. "export_mesh_library",
  113. "save_scene",
  114. "get_uid",
  115. "update_project_uids"
  116. ]
  117. }
  118. }
  119. }
  120. ```
  121. ### Option B: Cursor Configuration
  122. #### UI Configuration
  123. 1. Open **Cursor Settings** → **Features** → **MCP**
  124. 2. Click **+ Add New MCP Server**
  125. 3. Configure:
  126. - **Name**: `godot`
  127. - **Type**: `command`
  128. - **Command**: `node /absolute/path/to/godot-mcp/build/index.js`
  129. 4. Click **Add** and refresh the server list
  130. #### Project-Specific Configuration
  131. Create `.cursor/mcp.json` in your project root:
  132. ```json
  133. {
  134. "mcpServers": {
  135. "godot": {
  136. "command": "node",
  137. "args": ["/absolute/path/to/godot-mcp/build/index.js"],
  138. "env": {
  139. "DEBUG": "false",
  140. "GODOT_PATH": "/path/to/godot",
  141. "READ_ONLY_MODE": "false"
  142. }
  143. }
  144. }
  145. }
  146. ```
  147. ### Environment Variables
  148. | Variable | Description | Default | Example |
  149. | ---------------- | -------------------------------- | ------------- | ----------------- |
  150. | `GODOT_PATH` | Path to Godot executable | Auto-detected | `/usr/bin/godot4` |
  151. | `DEBUG` | Enable detailed logging | `false` | `true` |
  152. | `READ_ONLY_MODE` | Restrict to read-only operations | `false` | `true` |
  153. ## API Reference
  154. ### System Tools
  155. #### `get_godot_version`
  156. Get the installed Godot version information.
  157. **Parameters**: None
  158. **Example Response**:
  159. ```json
  160. {
  161. "version": "4.2.1.stable",
  162. "platform": "linux.x86_64"
  163. }
  164. ```
  165. ### Project Tools
  166. #### `launch_editor`
  167. Launch the Godot editor for a specific project.
  168. **Parameters**:
  169. - `projectPath` (string, required): Path to the Godot project directory
  170. **Example**:
  171. ```javascript
  172. {
  173. "projectPath": "/home/user/my-game"
  174. }
  175. ```
  176. #### `run_project`
  177. Execute a Godot project and capture output.
  178. **Parameters**:
  179. - `projectPath` (string, required): Path to the Godot project directory
  180. - `scene` (string, optional): Specific scene to run
  181. **Example**:
  182. ```javascript
  183. {
  184. "projectPath": "/home/user/my-game",
  185. "scene": "scenes/MainMenu.tscn"
  186. }
  187. ```
  188. #### `list_projects`
  189. Find Godot projects in a specified directory.
  190. **Parameters**:
  191. - `directory` (string, required): Directory to search for projects
  192. - `recursive` (boolean, optional): Whether to search recursively (default: false)
  193. #### `get_project_info`
  194. Retrieve detailed metadata about a Godot project.
  195. **Parameters**:
  196. - `projectPath` (string, required): Path to the Godot project directory
  197. **Example Response**:
  198. ```json
  199. {
  200. "name": "My Awesome Game",
  201. "path": "/home/user/my-awesome-game",
  202. "godotVersion": "4.2.1.stable.official",
  203. "structure": {
  204. "scenes": 12,
  205. "scripts": 8,
  206. "assets": 45,
  207. "other": 3
  208. }
  209. }
  210. ```
  211. ### Scene Management Tools
  212. #### `create_scene`
  213. Create a new scene in a Godot project.
  214. **Parameters**:
  215. - `projectPath` (string, required): Path to the Godot project directory
  216. - `scenePath` (string, required): Path for the new scene file (relative to project)
  217. - `rootNodeType` (string, optional): Type of the root node (default: "Node2D")
  218. **Example**:
  219. ```javascript
  220. {
  221. "projectPath": "/home/user/my-game",
  222. "scenePath": "scenes/Player.tscn",
  223. "rootNodeType": "CharacterBody2D"
  224. }
  225. ```
  226. #### `add_node`
  227. Add a node to an existing scene.
  228. **Parameters**:
  229. - `projectPath` (string, required): Path to the Godot project directory
  230. - `scenePath` (string, required): Path to the scene file (relative to project)
  231. - `nodeType` (string, required): Type of node to add (e.g., "Sprite2D", "CollisionShape2D")
  232. - `nodeName` (string, required): Name for the new node
  233. - `parentNodePath` (string, optional): Path to parent node (defaults to root)
  234. - `properties` (object, optional): Additional properties to set
  235. **Example**:
  236. ```javascript
  237. {
  238. "projectPath": "/home/user/my-game",
  239. "scenePath": "scenes/Player.tscn",
  240. "nodeType": "Sprite2D",
  241. "nodeName": "PlayerSprite",
  242. "properties": {
  243. "position": { "x": 100, "y": 50 },
  244. "scale": { "x": 2.0, "y": 2.0 }
  245. }
  246. }
  247. ```
  248. #### `edit_node`
  249. Edit properties of an existing node in a scene.
  250. **Parameters**:
  251. - `projectPath` (string, required): Path to the Godot project directory
  252. - `scenePath` (string, required): Path to the scene file (relative to project)
  253. - `nodePath` (string, required): Path to the node to edit
  254. - `properties` (object, required): Properties to update
  255. **Example**:
  256. ```javascript
  257. {
  258. "projectPath": "/home/user/my-game",
  259. "scenePath": "scenes/Player.tscn",
  260. "nodePath": "PlayerSprite",
  261. "properties": {
  262. "position": { "x": 200, "y": 100 },
  263. "modulate": { "r": 1.0, "g": 0.5, "b": 0.5, "a": 1.0 }
  264. }
  265. }
  266. ```
  267. #### `remove_node`
  268. Remove a node from a scene.
  269. **Parameters**:
  270. - `projectPath` (string, required): Path to the Godot project directory
  271. - `scenePath` (string, required): Path to the scene file (relative to project)
  272. - `nodePath` (string, required): Path to the node to remove
  273. #### `load_sprite`
  274. Load a texture into a Sprite2D node.
  275. **Parameters**:
  276. - `projectPath` (string, required): Path to the Godot project directory
  277. - `scenePath` (string, required): Path to the scene file (relative to project)
  278. - `nodePath` (string, required): Path to the Sprite2D node
  279. - `texturePath` (string, required): Path to the texture file (relative to project)
  280. #### `save_scene`
  281. Save a scene, optionally as a new variant.
  282. **Parameters**:
  283. - `projectPath` (string, required): Path to the Godot project directory
  284. - `scenePath` (string, required): Path to the scene file (relative to project)
  285. - `newPath` (string, optional): New path to save as variant
  286. ### Debug Tools
  287. #### `get_debug_output`
  288. Retrieve current debug output and errors from running projects.
  289. **Parameters**: None
  290. #### `stop_project`
  291. Stop any currently running Godot project.
  292. **Parameters**: None
  293. ### UID Tools (Godot 4.4+)
  294. #### `get_uid`
  295. Get the UID for a specific file in a Godot project.
  296. **Parameters**:
  297. - `projectPath` (string, required): Path to the Godot project directory
  298. - `filePath` (string, required): Path to the file (relative to project)
  299. #### `update_project_uids`
  300. Update UID references in a project by resaving resources.
  301. **Parameters**:
  302. - `projectPath` (string, required): Path to the Godot project directory
  303. ## Project Architecture
  304. ### Core Components
  305. The Godot MCP server follows a modular architecture designed for maintainability and extensibility:
  306. ```
  307. src/
  308. ├── config/ # Configuration management
  309. ├── core/ # Core functionality
  310. │ ├── GodotExecutor.ts # Godot command execution
  311. │ ├── PathManager.ts # Path detection and validation
  312. │ ├── ProcessManager.ts # Process lifecycle management
  313. │ └── ParameterNormalizer.ts # Input parameter handling
  314. ├── server/ # MCP server implementation
  315. │ ├── GodotMCPServer.ts # Main server class
  316. │ └── types.ts # Type definitions
  317. ├── tools/ # Tool implementations
  318. │ ├── BaseToolHandler.ts # Shared tool functionality
  319. │ ├── ToolRegistry.ts # Tool registration and filtering
  320. │ ├── debug/ # Debug-related tools
  321. │ ├── project/ # Project management tools
  322. │ ├── scene/ # Scene manipulation tools
  323. │ ├── system/ # System information tools
  324. │ └── uid/ # UID management tools
  325. ├── utils/ # Utility functions
  326. └── scripts/ # Godot operation scripts
  327. ```
  328. ### Key Design Principles
  329. 1. **Modular Tool System**: Each tool is self-contained with its own definition and handler
  330. 2. **Centralized Configuration**: Environment variables and settings managed in one location
  331. 3. **Robust Error Handling**: Comprehensive error reporting with actionable suggestions
  332. 4. **Security First**: Read-only mode and input validation protect against misuse
  333. 5. **Cross-platform Support**: Platform-agnostic design with OS-specific handling where needed
  334. ### Tool Registration System
  335. Tools are registered in the [`ToolRegistry`](src/tools/ToolRegistry.ts:47) with metadata indicating their capabilities:
  336. ```typescript
  337. export interface ToolRegistration {
  338. definition: ToolDefinition;
  339. handler: (args: any) => Promise<ToolResponse>;
  340. readOnly: boolean;
  341. }
  342. ```
  343. The registry automatically filters tools based on the current mode (read-only vs. full access) and provides a unified interface for tool discovery and execution.
  344. ### Bundled Operations Architecture
  345. Complex Godot operations use a centralized GDScript approach:
  346. 1. **Single Script File**: All operations consolidated in [`godot_operations.gd`](src/scripts/godot_operations.gd:1)
  347. 2. **JSON Parameter Passing**: Operations receive structured parameters
  348. 3. **No Temporary Files**: Eliminates file system overhead and cleanup complexity
  349. 4. **Consistent Error Handling**: Standardized error reporting across all operations
  350. This architecture provides better performance, maintainability, and reliability compared to generating temporary scripts for each operation.
  351. ## Usage Examples
  352. ### Basic Project Workflow
  353. ```text
  354. "Launch the Godot editor for my project at /path/to/my-game"
  355. "Run my Godot project and show me any errors"
  356. "Get information about my project structure and settings"
  357. ```
  358. ### Scene Creation and Management
  359. ```text
  360. "Create a new Player scene with a CharacterBody2D root node"
  361. "Add a Sprite2D node called 'PlayerSprite' to my Player scene"
  362. "Load the character texture 'textures/player.png' into the PlayerSprite node"
  363. "Set the Player's position to (100, 50) and scale to 2x"
  364. "Create a CollisionShape2D node as a child of the Player root"
  365. ```
  366. ### Advanced Workflows
  367. ```text
  368. "Create a complete UI scene with buttons for Start Game, Settings, and Quit"
  369. "Export my 3D level models as a MeshLibrary for use with GridMap"
  370. "Analyze my project structure and suggest performance improvements"
  371. "Debug this GDScript error and help me fix the character controller"
  372. "Create a save system scene with file I/O nodes and data management"
  373. ```
  374. ## Read-Only Mode
  375. Read-only mode provides a secure way to analyze Godot projects without making any modifications. This is ideal for CI/CD pipelines, code reviews, educational environments, and shared development scenarios.
  376. ### Enabling Read-Only Mode
  377. Set the `READ_ONLY_MODE` environment variable to `"true"`:
  378. ```json
  379. {
  380. "mcpServers": {
  381. "godot": {
  382. "command": "node",
  383. "args": ["/absolute/path/to/godot-mcp/build/index.js"],
  384. "env": {
  385. "READ_ONLY_MODE": "true"
  386. }
  387. }
  388. }
  389. }
  390. ```
  391. ### Available vs. Restricted Tools
  392. #### ✅ Available in Read-Only Mode
  393. **System Tools**:
  394. - `get_godot_version`: Get Godot version information
  395. **Project Tools**:
  396. - `launch_editor`: Launch Godot editor
  397. - `run_project`: Run projects to analyze behavior
  398. - `list_projects`: Discover projects in directories
  399. - `get_project_info`: Retrieve project metadata
  400. **Debug Tools**:
  401. - `get_debug_output`: Capture console output
  402. - `stop_project`: Stop running projects
  403. **UID Tools**:
  404. - `get_uid`: Get file UIDs (Godot 4.4+)
  405. #### ❌ Restricted in Read-Only Mode
  406. **Scene Modification Tools**:
  407. - `create_scene`: Create new scenes
  408. - `add_node`: Add nodes to scenes
  409. - `edit_node`: Modify node properties
  410. - `remove_node`: Remove nodes from scenes
  411. - `load_sprite`: Load textures into nodes
  412. - `export_mesh_library`: Export MeshLibrary resources
  413. - `save_scene`: Save scene modifications
  414. **UID Modification Tools**:
  415. - `update_project_uids`: Update UID references
  416. ### Use Cases
  417. - **🔄 CI/CD Pipelines**: Automated project analysis without risk of modification
  418. - **👥 Code Reviews**: Safe project inspection for team collaboration
  419. - **📊 Documentation**: Extract project information for automated documentation
  420. - **🔍 Debugging**: Analyze project behavior without modification risk
  421. ## Troubleshooting
  422. ### Common Issues and Solutions
  423. #### Godot Not Found
  424. **Error**: `Could not find a valid Godot executable path`
  425. **Solutions**:
  426. 1. **Set GODOT_PATH environment variable**:
  427. ```bash
  428. export GODOT_PATH="/path/to/godot"
  429. # or for Windows:
  430. set GODOT_PATH="C:\Program Files\Godot\godot.exe"
  431. ```
  432. 2. **Verify Godot installation**:
  433. ```bash
  434. # Test if Godot is accessible
  435. godot --version
  436. # or try:
  437. godot4 --version
  438. ```
  439. 3. **Common Godot paths**:
  440. - **Windows**: `C:\Program Files\Godot\godot.exe`
  441. - **macOS**: `/Applications/Godot.app/Contents/MacOS/Godot`
  442. - **Linux**: `/usr/bin/godot4` or `/usr/local/bin/godot`
  443. #### Connection Issues
  444. **Error**: MCP server not responding or tools not available
  445. **Solutions**:
  446. 1. **Restart your AI assistant** after configuration changes
  447. 2. **Check server logs** by enabling debug mode: `"DEBUG": "true"`
  448. 3. **Verify configuration path** is absolute and correct
  449. 4. **Test server manually**:
  450. ```bash
  451. node /path/to/godot-mcp/build/index.js
  452. ```
  453. #### Invalid Project Path
  454. **Error**: `Invalid project path` or `project.godot not found`
  455. **Solutions**:
  456. 1. **Ensure path contains project.godot**:
  457. ```bash
  458. ls /path/to/project/project.godot
  459. ```
  460. 2. **Use absolute paths** when possible
  461. 3. **Check file permissions** on the project directory
  462. #### Build Issues
  463. **Error**: Build fails or dependencies missing
  464. **Solutions**:
  465. 1. **Clean and rebuild**:
  466. ```bash
  467. npm run clean
  468. npm install
  469. npm run build
  470. ```
  471. 2. **Clear npm cache**:
  472. ```bash
  473. npm cache clean --force
  474. ```
  475. ### Getting Help
  476. If you encounter issues not covered here:
  477. 1. **Check debug logs** with `DEBUG=true`
  478. 2. **Search existing issues** on GitHub
  479. 3. **Create a detailed issue report** with:
  480. - Operating system and version
  481. - Node.js and Godot versions
  482. - Complete error messages
  483. - Configuration used
  484. - Steps to reproduce
  485. ## FAQ
  486. ### General Questions
  487. **Q: What versions of Godot are supported?**
  488. A: Godot 3.5+ and all Godot 4.x versions. Some features (like UID management) require Godot 4.4+.
  489. **Q: Can I use this with Godot 3.x projects?**
  490. A: Yes, most features work with Godot 3.5+. Scene management and project operations are fully supported.
  491. **Q: Is this safe to use on production projects?**
  492. A: Yes, especially with read-only mode enabled. The server includes comprehensive validation and error handling.
  493. ### Technical Questions
  494. **Q: How does the server detect my Godot installation?**
  495. A: The server checks common installation paths for each platform. You can override detection with the `GODOT_PATH` environment variable.
  496. **Q: Can I run multiple instances of the server?**
  497. A: Yes, each instance operates independently. Useful for working with multiple projects simultaneously.
  498. **Q: What happens if Godot crashes during an operation?**
  499. A: The server detects process failures and returns appropriate error messages with suggestions for resolution.
  500. **Q: Are temporary files created during operations?**
  501. A: No, the server uses a bundled GDScript approach that avoids temporary file creation for better performance and security.
  502. ### AI Assistant Integration
  503. **Q: Which AI assistants work with this server?**
  504. A: Any AI assistant supporting the Model Context Protocol, including Cline, Roo Code, Cursor, VS Code, Claude Desktop, and others.
  505. **Q: Can I customize which tools are available?**
  506. A: Yes, through the autoApprove configuration or by modifying the tool registry for custom builds.
  507. **Q: How do I know if the integration is working?**
  508. A: The AI assistant should be able to list available tools and execute them. Enable debug mode to see detailed operation logs.
  509. ### Development Questions
  510. **Q: Can I add custom tools to the server?**
  511. A: Yes, the modular architecture makes it easy to add new tools. See [`CONTRIBUTING.md`](CONTRIBUTING.md) for development guidelines.
  512. **Q: How do I contribute to the project?**
  513. A: Fork the repository, make your changes, and submit a pull request. Please follow the existing code style and include tests.
  514. **Q: Is the server extensible for other game engines?**
  515. A: The MCP architecture is engine-agnostic, but this implementation is specifically designed for Godot. Similar servers could be created for other engines.
  516. ## Contributing
  517. We welcome contributions to improve Godot MCP! Please see our [`CONTRIBUTING.md`](CONTRIBUTING.md) guide for:
  518. - Development setup instructions
  519. - Code style guidelines
  520. - Testing procedures
  521. - Pull request process
  522. - Issue reporting guidelines
  523. ### Quick Start for Contributors
  524. ```bash
  525. # Fork and clone the repository
  526. git clone https://github.com/your-username/godot-mcp.git
  527. cd godot-mcp
  528. # Install dependencies
  529. npm install
  530. # Start development mode
  531. npm run dev
  532. # Run tests
  533. npm test
  534. # Build for production
  535. npm run build
  536. ```
  537. ## License
  538. This project is licensed under the MIT License - see the [`LICENSE`](LICENSE) file for details.
  539. ## Credits
  540. This project was originally forked from [Coding-Solo/godot-mcp](https://github.com/Coding-Solo/godot-mcp).
  541. ## Support
  542. - **🐛 Bug Reports**: [GitHub Issues](https://github.com/bradypp/godot-mcp/issues)
  543. - **💡 Feature Requests**: [GitHub Discussions](https://github.com/bradypp/godot-mcp/discussions)
  544. - **📖 Documentation**: This README and inline code documentation
  545. - **💬 Community**: Join discussions about Godot MCP and AI-assisted development
  546. ---
  547. **Built with ❤️ for the Godot and AI development communities**

Ratings and comments

Sign in to rate this skill.

Sign in

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