CreativeScope — Mobil… vs Godot MCP Runtime | AllMCPs
Side-by-Side Model Context Protocol Comparison
CreativeScope — Mobile Game Ad Creative Intelligence vs Godot MCP Runtime
In-depth architectural comparison of the CreativeScope — Mobile Game Ad Creative Intelligence and Godot MCP Runtime MCP servers. Compare execution transports, security boundaries, tool capabilities, quality scores, and ready-to-paste client installation snippets for Claude, Cursor, Windsurf, and VS Code.
At a Glance & Executive Verdict
CreativeScope — Mobile Game Ad Creative Intelligence
Gaming · Remote HTTP/SSE
Quality: 49/100 (Fair) | Auth: No auth required
Godot MCP Runtime
Gaming · Local stdio
Quality: 68/100 (Great) | Auth: No auth required
Verdict Summary: Choose CreativeScope — Mobile Game Ad Creative Intelligence if you need specialized Gaming tools running via a hosted cloud SSE transport. Choose Godot MCP Runtime if your workspace requires Gaming integration with local subprocess execution. Both servers can be configured concurrently in your client's mcpServers manifest.
Which MCP Server Should You Choose?
Choose CreativeScope — Mobile Game Ad Creative Intelligence when:
You need dedicated capabilities in the Gaming domain.
You prefer remote streaming HTTP/SSE transport architecture.
Your security boundary fits: No auth required (Free / Open Source).
Mobile-game ad creative intelligence across SDK ad networks: search, rankings, AI hook analysis.
MCP server for Godot 4.x with runtime control via injected UDP bridge: input simulation, screenshots, UI discovery, and live GDScript execution while the game is running.
CreativeScope — Mobile Game Ad Creative Intelligence Tools (12)
search_creatives
Search game ad creatives by natural language, platform, country, genre, format, and date range
get_creative_detail
Full detail for one creative: delivery data, tag insights, and raw AI analysis
find_similar_creatives
Find creatives in the same cluster as a given `creative_id
search_advertisers
Search advertisers, games, and studios
get_advertiser_profile
Profile for an advertiser or game
submit_reference_image_search
Start an async "find similar by reference image" job
get_reference_image_search_status
Poll a reference-image job's status
get_reference_image_search_results
Fetch results once a reference-image job completes
generate_weekly_creative_brief
Generate a weekly creative brief
get_creative_rankings
Rising / Evergreen creative rankings
get_game_rank_markets
App Store / Google Play chart presence by country, category, store, and rank type
get_game_rank_trend
Daily store-ranking series over a date range (best or exact mode)
Godot MCP Runtime Tools (39)
launch_editor
Open the Godot editor GUI for a project for the human user. Use only when the user explicitly asks to "open the editor"; for any agent-driven work, use the headless scene/node tools (add_node, set_node_properties, etc.) instead - the editor cannot be controlled programmatically. Returns plain-text confirmation after spawning the editor process. Errors if projectPath has no project.godot.
run_project
Spawn a Godot project as a child process with stdout/stderr captured. Required before take_screenshot, simulate_input, get_ui_elements, run_script, or get_debug_output. Set profiling: true at launch to enable the profiler tools. Use attach_project for one you launched yourself. Verifies MCP bridge readiness before returning success. Returns status with the assigned bridge port. Call stop_project when done. Errors if projectPath is not a Godot project or another session is already active.
attach_project
Inject the MCP bridge into a Godot process you launch yourself, then wait up to 20s for the bridge to start listening and up to 45s total once it has, so a large project's cold start is absorbed; a port that listens but answers no ping gives up sooner. Call BEFORE Godot launches - Godot reads autoloads only at process start, so a late call returns "bridge did not respond." Recommended pattern: kick off the Godot launch in parallel with this call so the wait absorbs startup. Prefer run_project unless MCP must not spawn Godot. Returns plain-text status with the resolved bridge port. Call detach_project or stop_project when done.
detach_project
Clear attached-mode runtime state and remove the injected McpBridge autoload. Does NOT stop the manually launched Godot process - that stays running. Use after attach_project when you are done driving the game from MCP. For spawned sessions (run_project), use stop_project instead. Mostly optional now: when the bridge disconnects (you closed Godot), the next runtime tool call probes once and ends the attached session itself, removing the autoload. Calling it afterwards still succeeds idempotently, wording the message to distinguish "an attached session existed and already ended" from "this server never attached to a project". Returns: message confirming detach plus externalProcessPreserved (always true here - that is the point of detach vs stop_project). Errors only when a spawned session is what is active; use stop_project for those.
Ready-to-Paste Client Configurations
Paste either (or both) of these JSON server blocks into your client config file (e.g. claude_desktop_config.json or ~/.cursor/mcp.json).
CreativeScope — Mobile Game Ad Creative Intelligence Configuration
CreativeScope — Mobile Game Ad Creative Intelligence is categorized under Gaming and uses a remote streaming HTTP/SSE transport. In contrast, Godot MCP Runtime belongs to Gaming using local stdio subprocess. Select CreativeScope — Mobile Game Ad Creative Intelligence when you need capabilities focused on gaming and Godot MCP Runtime when you require tools for gaming.
Get captured stdout/stderr from a spawned Godot project. Use whenever runtime tools fail unexpectedly - script errors, missing nodes, and crash backtraces all surface here. Still works after the process exits or crashes: the session clears itself on exit but the captured logs are retained until stop_project. Requires run_project (not attach_project; attached mode does not capture output). Returns: output/errors (last `limit` lines each, default 200), running (false after exit, null when attached), exitCode after exit, attached:true with empty arrays in attached mode.
stop_project
Stop the spawned Godot project and clean up bridge state. Call when done with runtime testing, even after a crash, and even if you closed the Godot window yourself: it frees the process slot and clears the flag blocking scene-editing tools. A process that exited on its own already removed the bridge autoload at that moment, and this still succeeds - it reports alreadyExited:true with the exit code and the logs captured before the exit, and leaves a finished profiler capture readable. Attached sessions detach without killing the external process. Returns: message, mode, externalProcessPreserved, alreadyExited, exitCode (already-exited case), and condensed finalOutput/finalErrors (capped at 200); get_debug_output has the full log. Errors only when there is no session and no exited process to report.
take_screenshot
Capture a PNG of the running viewport. responseMode: preview (default - saves full PNG, returns bounded inline preview at 960x540), full (full inline PNG; use for small text or pixel-level inspection), path_only (saved-path only, no inline image). Saved under .mcp/godot-runtime/screenshots/ (persists after stop_project). Returns: inline image block (full/preview modes), plus path and size of the saved PNG; previewPath/previewSize in preview mode; warnings for non-fatal runtime errors. Errors if no session or bridge times out (default 10000ms).
simulate_input
Simulate sequential input in a running project and report what each action did. Action `type`: key, mouse_button, mouse_motion, click_element, action, text, wait. For key/mouse_button/action, omit `pressed` to tap (press+release); set it to hold or release. click_element resolves by node path/name (see get_ui_elements), not visible text. Returns: results[] per action with ok, timing, signals fired, the Control hit, UI `changes` (appeared/disappeared/changed), `watch` samples, and `errors` from input handlers (spawned sessions only). Invalid batches inject nothing; a runtime failure stops the batch and skips the rest.
get_ui_elements
Walk the running scene tree and return all Control nodes with positions, sizes, types, and text content. Always call this before simulate_input click_element actions to discover valid element names and paths. Requires an active runtime session (run_project or attach_project). visibleOnly defaults true; pass false to include hidden Controls. filter narrows by class. Returns: elements[] with path/type/rect/visible plus optional text/disabled/tooltip.
run_script
Execute a custom GDScript in the live running project with full scene tree access. Requires an active runtime session. Script must extend RefCounted and define func execute(scene_tree: SceneTree) -> Variant. Return values are JSON-serialized (primitives, Vector2/3, Color, Dictionary, Array, and Node path strings). Use print() for debug output - it appears in get_debug_output, not in the result. In spawned mode, stderr runtime errors escalate to errors (when the script returns null) or surface as warnings. Returns: { success, result, warnings?, tip? } where result is the JSON-serialized return value of execute().
list_autoloads
List all registered autoloads in a project with paths and singleton status. Use first when diagnosing headless failures - broken autoloads crash all headless ops, so this tells you what is loaded. No Godot process required (reads project.godot directly). Returns: [{ name, path, singleton }].
add_autoload
Register a new autoload in a project. autoloadPath accepts "res://..." or a project-relative path (auto-prefixed). singleton defaults true (accessible globally by name). No Godot process required. Warning: autoloads initialize in headless mode - a broken script will crash every subsequent headless op; validate before adding. Returns plain-text confirmation with the registered name, path, and singleton flag. Errors if an autoload with the same name already exists; use update_autoload to modify.