# gopeak [Health: Active]

**Category:** 🎮 Gaming  
**Repository:** https://github.com/HaD0Yun/godot-mcp  
**GitHub Stars:** 272  
**npm Downloads (last month):** 780  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/gopeak

## Description
GoPeak — The most comprehensive MCP server for Godot Engine. 95+ tools, LSP, DAP, screenshots.

## Tools
Capabilities this server exposes over MCP:

- **tool-catalog** — [compact alias of tool_catalog] Discover available tools including hidden legacy tools. Use query to search by capability keywords. Results include group categorization (core/dynamic). Matching dynamic groups are auto-activated and become available immediately. Core groups (always visible): core_meta, core_project, core_editor, core_scene, core_script, core_class, core_signal, core_resource, core_export, core_runtime, core_visualizer, core_diagnostics. Dynamic groups (on-demand): scene_advanced, uid, import_export, autoload, signal, runtime, resource, animation, plugin, input, tilemap, audio, navigation, theme_ui, asset_store, testing, dx_tools, intent_tracking, class_advanced, lsp, dap, version_gate.
- **project-list** — [compact alias of list_projects] Scans a directory for Godot projects (folders containing project.godot). Use to discover projects before using other tools. Returns array of {path, name}.
- **project-info** — [compact alias of get_project_info] Returns metadata about a Godot project including name, version, main scene, autoloads, and directory structure. Use to understand project before modifying. Requires valid project.godot.
- **project-search** — [compact alias of search_project] Searches for text or regex patterns across project files. Use to find function usages, variable references, or TODOs. Returns file paths and line numbers.
- **project-setting-get** — [compact alias of get_project_setting] Reads a value from project.godot settings. Use to check game name, window size, physics settings, etc.
- **project-setting-set** — [compact alias of set_project_setting] Writes a value to project.godot settings. Use to configure game name, window size, physics, etc.
- **editor-launch** — [compact alias of launch_editor] Opens the Godot editor GUI for a project. Use when visual inspection or manual editing of scenes/scripts is needed. Opens a new window on the host system. Requires: project directory with project.godot file.
- **editor-run** — [compact alias of run_project] Launches a Godot project in a new window and captures output. Use to test gameplay or verify script behavior. Runs until stop_project is called. Use get_debug_output to retrieve logs.
- **editor-stop** — [compact alias of stop_project] Terminates the currently running Godot project process. Use to stop a project started with run_project. No effect if no project is running.
- **editor-debug-output** — [compact alias of get_debug_output] Retrieves console output and errors from the currently running Godot project. Use after run_project to check logs, errors, and print statements. Returns empty if no project is running.
- **editor-status** — [compact alias of get_editor_status] Returns the connection status of the Godot Editor Plugin bridge. Use to check if the editor is connected before using scene/resource tools that require the editor plugin.
- **editor-version** — [compact alias of get_godot_version] Returns the installed Godot engine version string. Use to check compatibility (e.g., Godot 4.4+ features like UID). Returns version like "4.3.stable" or "4.4.dev".
- **scene-create** — [compact alias of create_scene] Creates a new Godot scene file (.tscn) with a specified root node type. Use to start building new game levels, UI screens, or reusable components. The scene is saved automatically after creation.
- **scene-save** — [compact alias of save_scene] Saves changes to a scene file or creates a variant at a new path. Most scene modification tools save automatically, but use this for explicit saves or creating variants.
- **scene-nodes** — [compact alias of list_scene_nodes] Returns complete scene tree structure with all nodes, types, and hierarchy. Use to understand scene organization before modifying. Returns nested tree with node paths.
- **scene-node-add** — [compact alias of add_node] Adds ANY node type to an existing scene. This is the universal node creation tool — replaces all specialized create_* node tools. Supports ALL ClassDB node types (Camera3D, DirectionalLight3D, AudioStreamPlayer, HTTPRequest, RayCast3D, etc.). Set any property via the properties parameter with type conversion support (Vector2, Vector3, Color, etc.). Use query_classes to discover available node types. Use query_class_info to discover available properties for a type.
- **scene-node-properties** — [compact alias of get_node_properties] Returns all properties of a specific node in a scene. Use to inspect current values before modifying. Returns property names, values, and types.
- **scene-node-set** — [compact alias of set_node_properties] Sets multiple properties on a node in a scene. Prerequisite: scene and node must exist (use create_scene and add_node first). Use to modify position, scale, rotation, or any node-specific properties. Scene is saved automatically unless saveScene=false.
- **scene-node-delete** — [compact alias of delete_node] Removes a node and all its children from a scene. Use to clean up unused nodes. Cannot delete root node. Scene is saved automatically unless saveScene=false.
- **script-create** — [compact alias of create_script] Creates a new GDScript (.gd) file with optional templates. Use to generate scripts for game logic. Templates: "singleton" (autoload), "state_machine" (FSM), "component" (modular), "resource" (custom Resource).
- **script-modify** — [compact alias of modify_script] Adds functions, variables, or signals to an existing GDScript. Use to extend scripts without manual editing. Supports @export, @onready annotations and type hints.
- **script-info** — [compact alias of get_script_info] Analyzes a GDScript and returns its structure: functions, variables, signals, class_name, extends. Use before modify_script to understand existing code.
- **class-query** — [compact alias of query_classes] Query available Godot classes from ClassDB with filtering. Use to discover node types, resource types, or any class before using add_node/create_resource. Categories: node, node2d, node3d, control, resource, physics, physics2d, audio, visual, animation.
- **class-info** — [compact alias of query_class_info] Get detailed information about a specific Godot class: methods, properties, signals, enums. Use to discover available properties before calling add_node/create_resource/set_node_properties, or to find methods before call_runtime_method.
- **signal-connect** — [compact alias of connect_signal] Creates a signal connection between nodes in a scene. Prerequisite: source and target nodes must exist. Use to wire up button clicks, collision events, custom signals. Saved to scene file.
- **resource-dependencies** — [compact alias of get_dependencies] Analyzes resource dependencies and detects circular references. Use to understand what a scene/script depends on before refactoring.
- **export-presets** — [compact alias of list_export_presets] Lists all export presets defined in export_presets.cfg. Use before export_project to see available targets (Windows, Linux, Android, etc.).
- **export-run** — [compact alias of export_project] Exports the project to a distributable format. Use to build final game executables. Requires export templates installed.
- **runtime-status** — [compact alias of get_runtime_status] Checks if a Godot game instance is running and connected for live debugging. Use before other runtime tools.
- **visualizer-map** — [compact alias of map_project] Crawl the entire Godot project and build an interactive visual map of all scripts showing their structure (variables, functions, signals), connections (extends, preloads, signal connections), and descriptions. Opens an interactive browser-based visualization at localhost:6505.
- **lsp-diagnostics** — [compact alias of lsp_get_diagnostics] Get GDScript diagnostics from Godot Language Server for a script file.
- **dap-output** — [compact alias of dap_get_output] Get captured Godot DAP console output lines
- **tool-groups** — [compact alias of manage_tool_groups] Manage tool groups. Actions: list (show all core + dynamic groups), activate (enable a dynamic group), deactivate (disable a dynamic group), reset (disable all dynamic), status (show current state). Core groups (always visible, 33 tools): core_meta, core_project, core_editor, core_scene, core_script, core_class, core_signal, core_resource, core_export, core_runtime, core_visualizer, core_diagnostics. Dynamic groups (on-demand, 78 tools): scene_advanced, uid, import_export, autoload, signal, runtime, resource, animation, plugin, input, tilemap, audio, navigation, theme_ui, asset_store, testing, dx_tools, intent_tracking, class_advanced, lsp, dap, version_gate.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "gopeak": {
    "command": "npx",
    "args": ["-y","gopeak"],
    "env": {
      "GODOT_PATH": "",
      "GOPEAK_TOOL_PROFILE": "",
      "MCP_TOOL_PROFILE": ""
    }
  }
}
```

**Requires environment variables:** `GODOT_PATH`, `GOPEAK_TOOL_PROFILE`, `MCP_TOOL_PROFILE` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What the gopeak MCP server does

The gopeak MCP server gives an MCP-compatible AI client access to Godot 4.x project workflows. It can help an agent find projects, inspect project information, create or edit scenes, modify scripts and resources, run a project, read debug output, and investigate errors. The repository describes a broad tool surface covering project work, scene and resource operations, runtime inspection, testing, asset workflows, LSP, and DAP.

This makes gopeak relevant to the Developer Tools category, especially for developers who want an assistant to work against a real project rather than only generate detached code. Example workflows include creating a `CharacterBody2D` scene, running the game, checking its output, and addressing the highest-priority error.

## How it works

GoPeak is launched as a Node.js process and communicates with an MCP client over the configured server connection. The quick-start command is `npx -y gopeak`; a global npm installation is also supported. Godot 4.x and Node.js 18 or newer are listed as requirements.

The default `compact` profile exposes a trusted core and activates additional tool groups when needed. A client or agent can search the catalog with `tool.catalog`, activate a group with `tool.groups`, and reset active groups when the work is complete. The server sends `notifications/tools/list_changed` after tool availability changes, allowing clients such as Claude Code and Claude Desktop to refresh their tool list. Clients that do not refresh automatically may need to reconnect or trigger another tools-list request.

The `full` profile exposes the complete legacy tool list, while `legacy` preserves the same exposed behavior for older configurations. Tool-list responses use cursor-based pagination rather than returning every tool in one response.

## Setup and configuration

Run the gopeak MCP server with:

```bash
npx -y gopeak
```

Alternatively, install it globally with `npm install -g gopeak` and start it using `gopeak`. Add the process to an MCP client configuration and set `GODOT_PATH` to the Godot executable or installation path used by the client. `GOPEAK_TOOL_PROFILE` selects the exposure profile; `compact` is the default. `MCP_TOOL_PROFILE` is available as a fallback alias.

The optional `gopeak setup` command configures update-notification shell hooks. It only changes supported bash or zsh rc files when explicitly run; npm installation does not install those hooks automatically.

## Tools and capabilities

Available capability groups include:

- Project discovery, project health checks, scaffolding, error logs, and usage searches.
- Scene, node, script, resource, animation, navigation, audio, UI theme, input, and TileMap workflows.
- Runtime inspection, screenshots, viewport capture, and input injection when the required runtime support is available.
- GDScript completions, hover information, and symbols through LSP on port 6005.
- Breakpoints, stepping, and stack traces through DAP on port 6006.
- ClassDB and inheritance inspection, import/export operations, autoloads, signals, plugins, and version checks.
- Optional searches and downloads for external CC0 assets when network and provider access are available.

Scene tools accept common vector forms such as coordinate objects or arrays. Explicitly tagged Godot values using a `type` field are recommended when cross-tool consistency matters.

## Limitations and notes

The gopeak MCP server does not make every group available without conditions. Runtime and testing features may need a runtime addon or editor support; LSP and DAP require their corresponding Godot services; editor-plugin operations need plugin availability; and several scene, resource, import, animation, and project-setting operations are marked for audit or fixture verification. Asset-store operations depend on network and provider availability.

Godot version behavior also matters. For example, TileMap functionality must account for Godot 4.3 and later `TileMapLayer` behavior. If an MCP client caches tools aggressively, dynamically activated groups may not appear until the client reconnects or performs a fresh tools-list round-trip. The repository also identifies English as its canonical README source, with localized documents potentially lagging behind it.

_Full upstream README: https://allmcps.com/mcp/gopeak/readme_