Godot Forge is an MCP server for Godot 4 that provides AI coding assistants with accurate GDScript support, project analysis, testing, and documentation tools. It auto-detects your Godot binary and project directory, works cross-platform (macOS, Windows, Linux), and is compatible with all MCP-supporting IDEs.
Run Tests (godot_run_tests): Execute GUT or GdUnit4 test suites headlessly with structured pass/fail results (file paths, line numbers). Supports filtering by script, method, or inner class.
Search API Docs (godot_search_docs): Search Godot 4.x API documentation and automatically map deprecated Godot 3 APIs to their Godot 4 equivalents (e.g., KinematicBody → CharacterBody3D, yield → await).
Analyze Scripts (godot_analyze_script): Detect 10 common GDScript pitfalls including Godot 3→4 API misuse, giant scripts, type inference bugs, tight coupling, signal re-entrancy, autoload misuse, missing disconnects, _init() timing issues, and Python-isms.
Analyze Scenes (godot_analyze_scene): Parse .tscn/.tres files to detect antipatterns like deep nesting (>8 levels), oversized scenes (>100 nodes), missing script references, and format errors.
Get LSP Diagnostics (godot_get_diagnostics): Retrieve real compiler errors and warnings from Godot's built-in language server for a file or the entire project (requires Godot editor to be running).
Get Project Info (godot_get_project_info): Retrieve a project overview including name, Godot version, scenes, scripts, autoloads, addons, and directory tree, with summary or full detail levels.
Run Project (godot_run_project): Launch or stop a Godot project and capture debug output (stdout/stderr with timestamps), optionally targeting a specific scene.
Take Screenshots (godot_screenshot): Capture a base64-encoded PNG screenshot of the running game viewport, optionally launching a specific scene.
AI coding assistants are structurally bad at GDScript. Models trained on data skewed towards Godot 3 hallucinate deprecated APIs (yield instead of await, KinematicBody instead of CharacterBody3D, export var instead of @export var). Godot Forge fixes this.
8 tools. Zero config. Works with every MCP-compatible IDE.
npx -y godot-forgeThat's it. Godot Forge auto-detects your Godot binary (Steam, Homebrew, direct download) and finds your project.godot automatically.
claude mcp add godot-forge -- npx -y godot-forgeAdd to .cursor/mcp.json:
{
"mcpServers": {
"godot-forge": {
"command": "npx",
"args": ["-y", "godot-forge"]
}
}
}Add to .vscode/mcp.json:
{
"servers": {
"godot-forge": {
"command": "npx",
"args": ["-y", "godot-forge"]
}
}
}Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"godot-forge": {
"command": "npx",
"args": ["-y", "godot-forge"]
}
}
}Add to settings.json:
{
"context_servers": {
"godot-forge": {
"command": {
"path": "npx",
"args": ["-y", "godot-forge"]
}
}
}
}Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%/Claude/claude_desktop_config.json (Windows):
{
"mcpServers": {
"godot-forge": {
"command": "npx",
"args": ["-y", "godot-forge"]
}
}
}See IDE Setup Guide for configuration snippets for all supported IDEs.
Related MCP server: godot-devtool
Tool | Description | Needs Godot | Needs Editor |
| Run GUT/GdUnit4 tests, get structured pass/fail results | Yes | No |
| Search Godot 4 API docs with 3→4 migration mapping | No | No |
| Detect 10 GDScript pitfalls (deprecated API, coupling, re-entrancy) | No | No |
| Parse .tscn/.tres, detect antipatterns and format errors | No | No |
| Project structure overview with progressive disclosure | No | No |
| LSP diagnostics from Godot's language server | No | Yes |
| Launch/stop project, capture debug output | Yes | No |
| Capture viewport screenshot as base64 PNG | Yes | No |
6 of 8 tools work without Godot installed. Only test running, project launching, and screenshots need the binary.
Auto-detects GUT and GdUnit4. Returns structured JSON with pass/fail counts, failure details with file paths and line numbers. Supports filtering by script, method, or inner class.
Ask your AI: "Run the water profile tests"
→ { total: 5, passed: 5, failed: 0, duration_ms: 462 }The #1 reason AI writes broken GDScript. When your AI queries a deprecated API, it gets the correct Godot 4 equivalent instantly (30+ mappings covering classes, methods, syntax, and constants).
Query: "KinematicBody" → "Renamed to CharacterBody3D in Godot 4"
Query: "yield" → "yield(obj, 'signal') → await obj.signal"
Query: "instance()" → "instance() → instantiate()"Every pitfall detected from real game development:
# | Pitfall | What It Catches |
1 | Godot 3→4 API |
|
2 | Giant scripts | Over 300 lines. Should be split |
3 |
| Type inference on |
4 | Tight coupling | Excessive |
5 | Signal re-entrancy | Signal emitted between state changes |
6 | Autoload misuse | Too many autoloads, |
7 | Missing disconnect |
|
8 |
| Node tree access before node is in tree |
9 | Python-isms | List comprehensions, |
10 | .tres type field | Custom class name instead of |
Parses .tscn and .tres files. Detects deep nesting (>8 levels), oversized scenes (>100 nodes), missing script references, preload() in .tres, integer resource IDs, and more.
Connects to Godot's built-in language server (runs automatically when the editor is open). Returns real compiler errors and warnings (no guesswork).
Requires the Godot editor to be running with your project open. All other tools work without the editor.
Captures the game viewport as a PNG image. Loads the project's main scene (or a specified scene), waits for rendering, and returns the screenshot as base64 for the AI to see.
Auto-detected in this order:
GODOT_PATH environment variable
godot / godot4 in PATH
Steam installation (macOS, Windows, Linux)
Platform defaults (/Applications/Godot.app, Homebrew, Scoop, Flatpak, Snap, etc.)
Override manually:
export GODOT_PATH="/path/to/godot"See Godot Detection for the full list of searched paths.
Auto-detected by walking up from the current directory to find project.godot. Override:
npx godot-forge --project /path/to/godot/projectNode.js 18+: for npx execution
Godot 4.x: auto-detected (optional for 6 of 8 tools)
Any MCP-compatible IDE: Claude Code, Cursor, VS Code, Windsurf, Zed, and more
Outcomes, not operations: Each tool delivers a complete result, not raw API wrapping
8 curated tools: No 93-tool context bloat (why this matters)
Progressive disclosure: Summaries first, details on demand
spawn() not exec(): No command injection, no Windows quoting bugs
Actionable errors: Every error includes a suggestion the AI can act on
Cross-platform: macOS, Windows, Linux. Steam and non-Steam installs.
Contributions are welcome! See CONTRIBUTING.md for guidelines.
Bug reports: Open an issue
Feature requests: Start a discussion
Pull requests: Fork, branch, test, PR
git clone https://github.com/gregario/godot-forge.git
cd godot-forge
npm install
npm run build
npm test # 74 tests across 12 test files# Point your IDE at the local build
claude mcp add godot-forge-dev -- node /path/to/godot-forge/dist/index.jsSee ROADMAP.md for planned features.
Phase 2: Input simulation, runtime scene tree inspection, performance profiling, shader validation, export/CI pipeline.
Parse .tscn scene files or .tres resource files and return structured analysis. Detects antipatterns (deep nesting, oversized scenes, missing scripts) and format errors (preload in .tres, custom class names in type field, integer resource IDs).
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to .tscn or .tres file (e.g., res://scenes/main.tscn) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior. The description adds value by specifying what analysis it performs (antipatterns, format errors). It does not mention authentication or side effects, but these are covered by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero wasted words. The purpose is front-loaded ('Parse .tscn... and return structured analysis') followed by specific detections.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description could mention return structure (e.g., 'returns JSON with issues found'). However, it adequately covers behavior for a simple read-only analysis tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema description for 'path' is clear ('Path to .tscn or .tres file...'). The tool description adds no further parameter semantics beyond restating file types, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool parses .tscn/.tres files and returns structured analysis, detecting specific antipatterns and errors. It distinctly differs from sibling tools like godot_analyze_script (which targets scripts) and godot_get_diagnostics (likely broader diagnostics).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for analyzing scene/resource files, but does not explicitly state when not to use it or compare to alternatives. However, the sibling names provide clear differentiation, so the context is directionally sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyse GDScript files for all 10 battle-tested pitfalls: Godot 3→4 API misuse, giant scripts, := on Variant, tight coupling, signal re-entrancy, autoload misuse, missing signal disconnect, _init() timing, Python-isms, and static func on autoloads.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path to .gd file (e.g., res://scripts/player.gd) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly and idempotent behavior. The description adds value by enumerating the exact checks performed, going beyond what annotations provide. No contradictions are present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the purpose and lists all pitfalls. Every part is informative with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what the tool does but does not mention the output format or return value. Given no output schema, this is a gap that could affect an agent's understanding of the result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'path' is well-described in the input schema (coverage 100%). The description does not add additional semantics beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes GDScript files for exactly 10 specified pitfalls, using a specific verb ('Analyse') and resource (GDScript files). It distinguishes itself from sibling tools like godot_analyze_scene by focusing on script-level issues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description lists all 10 pitfalls, giving clear context on when to use the tool (e.g., when suspecting Godot 3→4 API misuse or other listed issues). It does not explicitly mention when not to use it or compare with alternatives, but the specific scope provides strong guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get LSP diagnostics (errors, warnings) from Godot's built-in language server. Requires Godot editor to be running with the project open.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | File path to get diagnostics for (e.g., scripts/player.gd). Omit for project-wide. | |
| port | No | LSP port (default: 6005) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate read-only and idempotent. Description adds the runtime requirement of having the editor open and project loaded, which is beyond annotation scope. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, no unnecessary words. Front-loaded with the core action and critical requirement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Describes what the tool does and a key prerequisite. Lacks explanation of return value format (e.g., list of diagnostics), but given the name and context, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with good descriptions. Description does not add extra meaning beyond schema; it mentions 'errors, warnings' but not parameter-specific. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'get', resource 'LSP diagnostics', and context 'from Godot's built-in language server'. It distinguishes from siblings like godot_analyze_scene by specifying diagnostics retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a critical prerequisite ('Requires Godot editor to be running with the project open'), giving clear when-to-use guidance. Does not explicitly compare to alternatives, but the prerequisite is essential and well-stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return project structure overview: project name, Godot version, scenes, scripts, autoloads, addons, and directory tree. Uses progressive disclosure — summary by default, full details on request.
| Name | Required | Description | Default |
|---|---|---|---|
| detail | No | Level of detail: 'summary' (default) for counts and top-level dirs, 'full' for complete file listings |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations by explaining progressive disclosure (summary by default, full on request) and listing the data fields returned. Annotations already indicate read-only and idempotent, so the description enriches but does not contradict.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first specifies the tool's output, second explains the progressive disclosure. No fluff, and the key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one optional parameter and no output schema, the description covers purpose, behavior, and data scope adequately. It could mention the return format (e.g., JSON), but the listed items and progressive disclosure provide sufficient context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage for the single parameter 'detail' is 100%, with a clear description and enum. The description reinforces that 'summary' is default and 'full' provides more detail, but adds no new semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a project structure overview listing specific components (name, version, scenes, scripts, etc.). While it is specific and uses a verb, it does not explicitly differentiate from sibling tools like godot_analyze_scene or godot_get_diagnostics, though the purpose is distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for obtaining project info, but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Launch, stop, or get debug output from a running Godot project. Captures stdout/stderr with timestamps.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform | |
| scene | No | Scene to launch directly (e.g., res://scenes/main.tscn) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes capturing stdout/stderr with timestamps, adding value beyond annotations. However, it doesn't address side effects like starting multiple instances or security implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence covering the core actions and output capture without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the basic functionality but omits details about tool behavior under edge cases (e.g., stopping a non-running project, output format) and no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description adds no significant meaning beyond the schema. The parameters are self-explanatory from the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool launches, stops, or gets debug output from a running Godot project, which distinguishes it from sibling tools like analysis or diagnostics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for project lifecycle management but does not explicitly state when to use this tool versus alternatives or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run GUT or GdUnit4 tests headlessly and return structured pass/fail results. Auto-detects the test framework. Returns total/passed/failed counts with failure details including file paths and line numbers.
| Name | Required | Description | Default |
|---|---|---|---|
| script_path | No | Filter to specific test script (e.g., res://tests/test_inventory.gd) | |
| method | No | Filter to specific test method name | |
| inner_class | No | Filter to specific inner test class | |
| framework | No | Force specific framework (auto-detected if omitted) | |
| timeout | No | Timeout in seconds (default: 60) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses headless execution, auto-detection of framework, and return of structured pass/fail counts with failure details. These go beyond the annotations (idempotentHint=true). No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the action and output. Every word adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema, the description sufficiently explains the return format (counts and failure details). All parameters are documented in schema. The tool fits well among siblings without missing context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with clear parameter descriptions. The tool description adds the auto-detection behavior but does not enhance parameter meaning beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs GUT or GdUnit4 tests headlessly and returns structured results. It auto-detects the framework, which is a specific differentiator from siblings like godot_run_project. The verb 'Run' and resource 'tests' are precise.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes it clear this tool is for running tests, not for other operations like running the project or analyzing scenes. However, it does not explicitly mention when not to use it or point to alternatives, which would earn a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Capture a viewport screenshot from the running Godot project. Returns base64-encoded PNG image. Requires a display server (not headless mode).
| Name | Required | Description | Default |
|---|---|---|---|
| scene | No | Scene to capture (e.g., res://scenes/main.tscn). If omitted, captures the project's main scene. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior. The description adds valuable behavioral context (display server requirement and return format) beyond annotations. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no redundant information. Front-loaded with the core action and return type, followed by a critical usage note. Every sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a simple tool with one optional parameter, the description covers the essential behavior, return format, and key constraint. No output schema exists, but the description explains the output format. Minor gap: doesn't mention potential errors or performance impacts.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema sufficiently explains the optional 'scene' parameter. The description doesn't add extra meaning beyond 'If omitted, captures main scene', so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's verb (Capture), resource (viewport screenshot), and return format (base64-encoded PNG). It distinguishes from sibling analysis tools by specifying 'screenshot' functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes an important precondition: 'Requires a display server (not headless mode)', which guides when not to use. However, it doesn't explicitly compare to alternatives or state when to choose this tool over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search Godot 4.x API documentation. Returns class overviews, method details, or fuzzy search results. Automatically detects Godot 3 API queries and suggests Godot 4 equivalents — the #1 source of AI-generated GDScript bugs.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Class name (e.g., 'CharacterBody2D'), method (e.g., 'CharacterBody2D.move_and_slide'), or search term |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark it as read-only and idempotent. The description adds valuable behavioral context: automatic detection of Godot 3 queries and suggestion of Godot 4 equivalents, plus a warning about AI-generated bugs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff. First sentence immediately states purpose and capabilities. Second sentence adds crucial warning. Perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description mentions return types (overviews, method details, fuzzy results) but does not specify structure (e.g., Markdown, JSON). Sufficient for most agents.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of the single parameter. Description does not add parameter details beyond what schema provides, though it implies outputs related to query.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches Godot 4.x API documentation and distinguishes itself from sibling tools (analysis, run, etc.) by focusing on documentation search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explains what to search for (classes, methods, terms) and warns about Godot 3 queries, but does not explicitly state when not to use it or name alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0godot_analyze_scenegodot_analyze_scriptgodot_get_diagnosticsgodot_get_project_infogodot_run_projectgodot_run_testsgodot_screenshotgodot_search_docsEach tool has a distinct and well-defined purpose with no overlap. For example, godot_analyze_scene and godot_analyze_script target different file types and antipatterns, while godot_run_project and godot_run_tests handle project execution versus testing separately. The descriptions clearly differentiate the tools, making misselection unlikely.
All tools follow a consistent 'godot_verb_noun' naming pattern, using snake_case throughout. This predictable structure (e.g., godot_analyze_scene, godot_run_tests) enhances readability and makes it easy for agents to infer tool functions from their names.
With 8 tools, the server is well-scoped for Godot project development and analysis. Each tool serves a specific, non-trivial function (e.g., analysis, diagnostics, execution, testing), and none feel redundant or missing, fitting the domain appropriately without being overwhelming.
The toolset covers core workflows for Godot development, including analysis, diagnostics, project management, execution, testing, and documentation. Minor gaps exist, such as no direct tools for editing or creating scenes/scripts, but agents can work around this by using analysis tools to inform manual changes, and the surface is otherwise comprehensive.
A TypeScript MCP server for Home Assistant, enabling programmatic management of entities, automati…
Lean 4 MCP server: compile, prove theorems, and formalize math with Mathlib.
A MCP server built for developers enabling Git based project management with project and personal…
The official Svelte MCP server providing docs and autofixing tools for Svelte development
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/gregario/godot-forge'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
