RpgMakerMVUltimate MCP vs Ludo AI Game Assets
A side-by-side look at the RpgMakerMVUltimate MCP and Ludo AI Game Assets MCP servers: transport, auth, tools, quality signals, and the config to install either one in Claude, Cursor, Windsurf or VS Code.
Verdict: choose RpgMakerMVUltimate MCP for gaming work as a local process; choose Ludo AI Game Assets for gaming over a hosted endpoint. You can also run both side by side in one mcpServers block.
Which MCP server should you choose?
Choose RpgMakerMVUltimate MCP when
- You need dedicated capabilities in the Gaming domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: No auth required.
- You have the keys it needs:
RPGMAKER_PROJECT_PATH. - You want tools like
query_database, create_database_entry, update_database_entry.
Choose Ludo AI Game Assets when
- You need dedicated capabilities in the Gaming domain.
- You prefer a remote HTTP/SSE transport.
- Its auth model fits you: API key required.
- You want tools like
validateApiKeyEndpoint, createImage, generateWithStyle.
Feature & specification comparison
Rows where the two servers differ are marked.
| Spec | ||
|---|---|---|
| Category | Gaming | Gaming |
| Quality signal | 68/100 · Great | 61/100 · Good |
| Install command | Confirmed | Confirmed |
| Transport | Local subprocess (stdio) | Remote HTTP/SSE |
| Auth | No auth required | API key required |
| Pricing | Free | Not declared |
| Required env vars | RPGMAKER_PROJECT_PATH | None listed |
| Verified owner | Community listing | Community listing |
| GitHub stars | 28 | 7 |
| Directory activity | 7 views 0 installs 0 upvotes | 1 views 0 installs 0 upvotes |
| Tools | 15 | 44 |
| Full listing | View RpgMakerMVUltimate MCP | View Ludo AI Game Assets |
Tools & capabilities
RpgMakerMVUltimate MCP tools 15
query_databaseRead-only: query any RPG Maker MV database (data/*.json). Three forms depending on arguments: no id/query lists every non-null entry of the entity; `id` fetches one entry (returns null, not an error, if it does not exist); `query` does a case-insensitive name search (items/weapons/armors/skills also match descriptions). Returns an array (list/search) or a single object/null (id). Use this to discover valid IDs before create/update/delete or before wiring references (class learnings, troop members, chest loot). For maps use query_map; for a digest of everything at once use get_project_context.create_database_entryCreate a new entry in an RPG Maker MV database with the next free ID; the data file is written immediately. Returns the complete created object including its new id. Two forms: with `entity` + `data` it creates a raw entry (omitted fields get engine defaults; data.name is expected); with `preset` it builds a ready-to-use entry from a recipe — damage_skill {name, mpCost, scope, formula, element?, animationId?}, healing_skill {name, mpCost, scope, formula}, buff_skill {name, mpCost, scope, paramId 0-7, turns}, state_skill {name, mpCost, scope, stateId, chance 0-1}, boss_enemy {name, battlerName?, specialSkillId?, params?}, encounter_troop {name, enemyIds[]}. Presets validate their required fields and fail with a validation error when missing. Class entries: data.params accepts 8 stat seeds [HP,MP,ATK,DEF,MAT,MDF,AGI,LUK] expanded to full level 1-99 curves automatically. Not supported for tilesets/animations (author those in the editor). Referenced IDs (classId, stateId, enemyIds...) are NOT validated — confirm them with query_database first.update_database_entryPartially update an existing database entry: only the keys in `fields` are overwritten (arrays like traits/learnings/actions are replaced wholesale, not merged); the data file is written immediately and there is no undo, so fetch current values with query_database first if you may revert. Returns the full entry after the update. Fails with an error if the ID does not exist. Special append forms that do not need `fields`: common_events + `appendCommand` inserts one event command before the list terminator; troops + `addEnemyId` adds a member at an auto-computed battle position. Troops and animations also support plain `fields` updates now (e.g. rename a troop, replace its members/pages, or relabel an animation). Class params in fields accept 8 seeds (expanded to full curves) or 8 arrays of 100 per-level values. Editing tilesets affects every map using them; malformed flags break passability project-wide.delete_database_entryDESTRUCTIVE: delete a database entry by nulling it out in its data file (written immediately; not undoable — re-create it if needed; IDs are never reused). References elsewhere are NOT cleaned up and will break at runtime: actors in the starting party, classes assigned to actors, skills in class learnings/enemy actions, items in chests/shops, enemies in troops, states in skill effects, troops in map encounters — check and update those first with query_database/update_database_entry. NEVER delete skill 1 (Attack), skill 2 (Guard) or state 1 (KO); the engine uses them directly. Supported entities: actors, classes, skills, items, weapons, armors, enemies, states, troops, animations. Returns the deleted object for reference; fails with an error if the ID does not exist.query_mapRead-only: inspect maps. `view` selects what you get: "infos" lists the map tree from MapInfos.json (ids, names, folder parentIds — no mapId needed); "full" returns one complete MapNNN.json (dimensions, 6-layer tile data, events — can be large); "events" lists a map's events (with `query`, filters by name, case-insensitive); "event" returns one event by eventId (null if absent); "validate" lints a map (invalid tile IDs per layer, missing page terminators, transfers to map 0, Self Switch OFF where ON was likely meant) returning {issueCount, issues[]}; "ascii" renders the map as a character grid with event markers and a legend — the cheapest way to "see" a layout and pick coordinates, entirely offline. Fails with an error if the map file does not exist. For player-visible images use analyze_image instead.generate_mapCreate a new map file (next free map ID, registered in MapInfos.json; both files written immediately). `mode` selects the generator: "blank" makes an empty map you paint later (edit_map fill_layer); "themed" generates a simple tile layout for a theme using the tileset's real tiles; "procedural" is the full generator — for themes with matching RTP reference templates (town, dungeon, interior, castle, world, etc.) it CLONES a hand-authored template from the 106 bundled maps (real 3D buildings, walls, furniture), auto-picking the closest size; for themes without templates (beach, swamp, etc.) it generates procedurally (Perlin terrain, BSP dungeons, cellular caves). Same seed + params = same map. Pass templateId to force a specific template, or useTemplate:false to force procedural. 21 themes incl. snow, volcano, sewer, space_interior; "batch" generates several procedural maps in one call from `batch` specs; "duplicate" copies an existing map (transfer events still point at their ORIGINAL destinations — review them); "template" instantiates one of the 106 bundled reference maps by templateId (list them with get_project_context detail "templates"); "semantic" is the tileset-independent generator — it lays out a MISSION (entrance, key, locked door, treasure, boss, exit, side rooms) as a graph and only then paints it, asking the tileset profile which tile plays each role, so the layout works on ANY tileset including DLC and third-party packs, and the key is always reachable before the door it opens. It returns `markers` naming the cell of every mission role, which is where to place events next. Run manage_system action "mine_templates" first so the profile comes from tiles this project actually uses; pass a mined `templateId` (like "mined-3") to re-materialise one of the project OWN maps onto a different tileset instead of generating a new mission. Returns {mapId, ...} — procedural also returns the seed; batch returns all mapIds keyed for edit_map "connect". Fails with an error on unknown theme/template or unwritable files.edit_mapModify existing maps; the affected map files / MapInfos.json are written immediately. `action` selects the edit: "fill_layer" overwrites an ENTIRE tile layer with one tile ID (destructive, not undoable; layers: 0-1 ground, 2-3 upper, 4 shadow bits 0-15, 5 region IDs 0-255; tileId 0 clears; find valid IDs with get_project_context detail "tileset"); "set_display_names" sets the player-visible displayName of several maps at once (entries whose map file is missing are reported in `skipped`, not errors); "organize_tree" re-parents maps in the editor tree (purely organizational, gameplay unaffected); "connect" creates a bidirectional pair of transfer events between two maps so the player can walk both ways; "set_encounters" sets the map's random-battle list so enemies appear while walking — `encounters` is [{troopId, weight?, regionSet?}] (weight default 5; regionSet [] = whole map; troopId must exist) plus optional `encounterStep`. WITHOUT encounters set, a map has no random battles. Returns a per-action summary. Fails with an error if a referenced map does not exist (except set_display_names, which skips). For event-level work use manage_map_event.manage_map_eventCreate, modify or remove events on a map; the map file is written immediately. action "create" without preset makes a low-level event at x/y (empty page unless `pages` given; add behavior later with add_command). action "create" WITH preset builds a complete, ready-to-play event: "npc" (2-page dialogue NPC: {name, dialogues[], characterName?, characterIndex?}), "chest" (one-time loot: {items: [{type: item|weapon|armor, id, amount}]} — IDs not validated, confirm with query_database), "teleport" (one-way walk-on transfer zone: {destMapId, destX, destY, trigger?} — destination not validated), "door" (action-button warp into another map, e.g. a house entrance: {destMapId, destX, destY, characterName?, characterIndex?, trigger?, lockedSwitchId?, lockedMessage?}; with lockedSwitchId it shows a "locked" message until that game switch is ON), "shop" ({goods: [[type 0=item/1=weapon/2=armor, id, priceType 0=standard/1=custom, price]]}), "inn" ({cost?} full-recovery flow with gold check), "boss" ({troopId} one-time battle, game over on loss), "puzzle_switch" ({switchX, switchY, doorX, doorY, gameSwitchId, switchName?, doorName?} creates TWO linked events). action "update" overwrites only `fields` on an event; action "convert" RE-PURPOSES an existing event in place — keeping its id, position, name and sprite but replacing its behaviour — via `kind`: "merchant" (a working shop; pass `options.goods` [[type,id,priceType,price]] or the friendly `options.items` [{type,id}], plus optional `options.greeting`), "inn" (`options.cost?` full-recovery flow with gold check), "sign" (`options.text` string or string[] read-only message); ideal for "turn this NPC into a merchant" without re-placing it; "delete" removes it permanently (DESTRUCTIVE); "add_command" appends one command before a page's terminator; "populate" scatters N events of a kind (npc/chest/boss) at random positions (walkability not checked — validate with query_map "ascii"). Returns the created/updated event(s) with ids. Fails with an error if the map (or event, for update/delete) does not exist.manage_systemRead or edit project-wide settings in data/System.json (writes are immediate). action "get" returns the requested `section`: "full" (everything — large), "switches" or "variables" (name arrays indexed by ID; unnamed entries are empty strings — use these to find free IDs), or "title". action "set_title" changes the game title shown on the title screen. "name_switch"/"name_variable" label a switch/variable by ID — documentation only, runtime values are untouched, but good names keep event logic readable. "set_starting_position" sets where new games begin {mapId, x, y} — NOT validated against existing maps, verify with query_map "infos" first; does not affect saved games. "create_plugin" authors a new plugin: it writes js/plugins/<name>.js with a correct @plugindesc/@author/@param/@help header (and a classic-MV Game_Interpreter.pluginCommand hook when `commands` are given) and registers it in js/plugins.js (array order = load order). Re-authoring the same `name` overwrites the file and replaces its manifest entry in place. Pair with analyze_project view "plugins" to inspect the project's existing plugins first. "scaffold_project" creates a NEW, editor-openable RPG Maker MV project by cloning NewData, adding `Game.rpgproject` when Steam omits it, and rewriting its title/start position; it refuses to overwrite an existing project and does not switch the active path. "playtest" launches the ACTIVE project through the bundled nwjs runtime. "open_editor" validates the active project, repairs a missing `Game.rpgproject`, and opens that descriptor in RPGMV.exe so the editor loads the project instead of an empty grey shell. Both locate the engine via `install` / RPGMAKER_MV_INSTALL / the default Steam path and are Windows-only. THE LIVE BRIDGE closes the loop between editing and seeing. "install_bridge_plugin" writes js/plugins/McpBridge.js (only active in playtest). "bridge_start" opens a loopback WebSocket and writes its authenticated handshake. "bridge_status" reports whether the game is connected. "bridge_telemetry" drains exceptions, logs, scene changes, player position and executing event commands, optionally filtered by `types`; pass `peek` to retain frames. "bridge_command" supports `reload_map`, `reload_database`, `get_state`, `teleport_player` and `ping`. "take_screenshot" captures the live game through the MCP bridge; `bridge_screenshot` remains as a compatibility alias. "bridge_stop" closes the socket and deletes the handshake file. "mine_templates" learns layouts and semantic tile roles from this project for later semantic generation. Returns the read section or updated values.take_screenshotCapture the current RPG Maker MV playtest frame through the authenticated MCP bridge and save it as a PNG under `.mcp-cache/screenshots/`. Returns `{path, bytes, mimeType, name}` so the image can be inspected or attached as QA evidence without shell commands. Requires `manage_system` actions `install_bridge_plugin`, `bridge_start`, and `playtest` first. Optional `name` becomes a safe filename prefix; each capture keeps a timestamp. `manage_system {action:"bridge_screenshot"}` remains available as a compatibility alias.record_videoStart or stop recording the live RPG Maker MV playtest canvas through the authenticated MCP bridge. `action:"start"` begins a silent WebM capture inside the game runtime; `action:"stop"` saves it under `.mcp-cache/recordings/` and returns `{path, bytes, mimeType, durationMs, name}`. This captures only the game canvas, not the desktop or credentials. Requires the bridge plugin, a running bridge, and a connected playtest. Optional `name`, `fps` (default 30), and `bitrateKbps` (default 2500) control the artifact.get_project_contextRead-only: pre-digested project knowledge — CALL THIS FIRST in a session. `detail` selects the depth: "full" (default) returns id+name lists for every database, switch/variable names, starting position, and available sprite filenames per img/ folder — everything needed to create content without inventing broken references; "summary" is a cheap health check (entry counts per data file); "assets" scans img/ and Tilesets.json into a complete index (sheet dimensions, autotile kinds, categorized usable tiles, all PNG names); "tileset" returns the categorized usable tile IDs of ONE tileset (ground/water/walls/roof/decoration) for edit_map "fill_layer" — guessing tile IDs produces glitched maps; "templates" lists the 106 bundled reference maps (id, category, theme) usable with generate_map mode "template", optionally filtered by category/theme. Returns one structured object (or array for templates). GOLDEN RULES for good results: (1) build whole maps with generate_map (it stamps real houses/trees and wires encounters) and add content with the manage_map_event presets — do NOT hand-paint tiles or place decorations one tile at a time; (2) never invent tile IDs or sprite/troop/skill IDs — take them from this tool; (3) for enemies to appear, create troops then set encounters (edit_map "set_encounters"), which generate_map does automatically for combat themes.- +3 more on the listing page
Ludo AI Game Assets tools 44
validateApiKeyEndpointValidates an API key. Returns 200 if valid, 403 if invalid.createImageGenerate game-art images from a text prompt alone, selecting an image_type (e.g. sprite) and optionally art_style, perspective, and aspect_ratio. The job result is an array of image results, each with a url; request n (1-8) to control how many variations come back. Because it generates purely from text it takes no source image, so there is no upload size limit to trip. Credits are held when the job is accepted and refunded if it fails or is cancelled; the charge scales with the number of images produced. Use createImage to make new images from scratch; use generateWithStyle to match a reference image's art style, editImage to modify an existing image, and removeBackground to cut out a subject. Pass an optional request_id to tag the results so you can retrieve them later via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.generateWithStyleGenerate new images that match the visual style of a reference image: supply a style_image (URL or base64) plus a text prompt describing what to create and an optional image_type (defaults to sprite). The job result is an array of image results, each with a url; request n (1-4) to control the number of variations. The style_image is uploaded and validated, and an image larger than 15MB is rejected with HTTP 400. Credits are held when the job is accepted and refunded if it fails or is cancelled; the charge scales with the number of images produced. Use this instead of createImage when style consistency with an existing asset matters; use editImage to alter the content of a specific image rather than borrow its style, and removeBackground to isolate a subject. Pass an optional request_id to tag the results so you can retrieve them later via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.editImageModify an existing image according to text instructions: supply a source image (URL or base64) and a prompt describing the changes (e.g. "add clouds", "warmer color scheme"), with an optional reference_image for extra style or content guidance. To change only one area, pass a mask (white = change, black = keep, the same size as the image): mask_mode "replace" (default) redraws that area from the prompt, "erase" removes what is there. Without a mask the whole image is re-rendered. Never ask for a transparent background in the prompt: it often comes back as a grey-and-white checkerboard painted into the pixels, which removeBackground cannot remove. A sprite keeps its transparency without being asked (see image_type). The job result is an array of image results, each with a url; request n (1-4) to control the number of edited variations. Provided images are uploaded and validated, and any image larger than 15MB is rejected with HTTP 400. Credits are held when the job is accepted and refunded if it fails or is cancelled; the charge scales with the number of images produced. Use editImage to transform a specific existing image; use createImage to generate from text alone, generateWithStyle to borrow a reference's art style, and removeBackground for the dedicated background-removal case. Pass an optional request_id to tag the results so you can retrieve them later via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result; 1 credit per result with a mask.animateSpriteAnimate a static sprite into a spritesheet driven by a motion text prompt (image-to-spritesheet): supply an initial_image (URL or base64) plus a motion_prompt like "walking" or "attack slash", and optionally a final_image to interpolate between a start and end frame. Describe the motion exactly and unambiguously, but do not over-describe it: an action the model already knows is one phrase, not a sequence of steps, and the character, art style, background and camera come from the image, not the prompt. For animations driven by up to three keyframes (including a middle frame), use animateSpriteKeyframes instead. The job result is a single sprite result: `spritesheet_url` (the sheet image), `video_url` (an mp4 of the animation - pass it as `video` to transferMotion or as `spritesheet_video_url` to createSpriteAudio; editSpritesheet takes `spritesheet_url`), `num_frames`/`num_cols`/`num_rows` (the grid layout), and, when requested, `gif_url`, `individual_frame_urls` and `spritesheet_with_background_url`. The hydra and hydra-plus models also return `audio_url`, a sound effect for the animation - there is no need to call createSpriteAudio afterwards; forge and forge-pixel produce no audio. The chosen model must support sprite animation and the duration must be valid for it; incompatible model/duration combinations return HTTP 400. Credits are held for the duration you requested when the job is accepted; the final charge is rate × seconds of video generated (legacy models keep their minimum charge), never more than for the duration you requested, and the difference (or everything, if the job fails or is cancelled) is refunded. The returned sheet is then trimmed to its best loop and can run slightly shorter than the video; that trim is not deducted. Choosing a tool: animateSprite (this one) when you can describe the motion in text; transferMotion when you want an exact motion copied from a reference video or one of the named presets from listAnimationPresets (e.g. a standard walk or attack cycle); generatePose first when the source image is not yet in the pose the animation should start from. Omit `model` to run on hydra (the default) - see the `model` field for the per-model rates. Pass an optional request_id to tag the result so you can locate it later via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: credits/s × seconds, per model: Hydra 3/s (shortest duration 3s, so 9 credits minimum), Hydra+ 4/s (shortest duration 3s, so 12 credits minimum), Forge 1.5/s, Forge Pixel 1.5/s, Blitz 1.9/s (min charge 4 credits) [LEGACY], Eagle 2.6/s (min charge 4 credits) [LEGACY], Eagle with Audio 3.1/s (min charge 4 credits) [LEGACY]; [LEGACY] models are scheduled for removal - do not use them for new work; see this endpoint's full pricing table in the API docs.animateSpriteKeyframesAnimate a sprite through up to three fixed keyframes - initial_image, middle_image and final_image (each a URL or base64) - producing a spritesheet that interpolates through the provided frames in order. At least one of initial_image or middle_image is required (a final_image alone has nothing to anchor the animation); any keyframe may be omitted. The motion_prompt is optional here - when omitted, the motion is derived purely from the keyframes. Runs on hydra (default; also returns `audio_url`), hydra-plus (hydra with finer detail, also returns `audio_url`), forge, or forge-pixel for pixel-art sprites - the models that support a middle keyframe; any other model returns HTTP 400. For just a start and end frame, animateSprite with `final_image` does the same job. The job result is the same sprite result as animateSprite (`spritesheet_url`, `video_url`, grid fields, optional GIF and frame URLs, `audio_url` on hydra and hydra-plus). Credits are held for the duration you requested when the job is accepted; the final charge is rate × seconds of video generated, never more than for the duration you requested, and the difference (or everything, if the job fails or is cancelled) is refunded. The returned sheet is then trimmed to its best loop and can run slightly shorter than the video; that trim is not deducted. Use animateSprite instead for the classic single-image + text-prompt animation. Pass an optional request_id to tag the result so you can locate it later via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: credits/s × seconds, per model: Hydra 3/s (shortest duration 3s, so 9 credits minimum), Hydra+ 4/s (shortest duration 3s, so 12 credits minimum), Forge 1.5/s, Forge Pixel 1.5/s; see this endpoint's full pricing table in the API docs.generatePoseRe-pose an existing sprite into a new target pose while preserving the character, taking a source image (URL or base64), a pose name (or "Other" with a free-text description), and an optional n (1-4) for how many variations to produce. Only works with sprite image types (not icons, screenshots, etc.). The job result is an array of pose results, each containing the generated image url, the pose and description used, and a suggested motion_prompt tuned for that pose. Credits are held when the job is accepted and refunded if it fails or is cancelled; the charge scales with the number of images generated. This is typically the first step before animating: call generatePose to set the character's pose, then feed the result (and its suggested motion_prompt) into animateSprite for the best animation quality; use rotateSprite instead when you want to change the camera angle rather than the pose. Pass an optional request_id to tag the results so you can locate them later via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.rotateSpriteRe-render an existing sprite from a different camera viewpoint while keeping the same character and pose, taking a source image (URL or base64), a required camera_rotation azimuth (one of 0, 45, 90, 135, 180, -135, -90, -45 degrees), an optional camera_elevation (0, 30, or 60 degrees; omit to keep the current elevation), and an optional n (1-4) for the number of variations. Only works with sprite image types (not icons, screenshots, etc.). The job result is an array of rotate-sprite results, each with the generated image url and the camera_rotation and camera_elevation that were applied. Credits are held when the job is accepted and refunded if it fails or is cancelled; the charge scales with the number of images generated. Use this to produce alternate view angles of a character; use generatePose instead to change the character's pose rather than the camera, and animateSprite or transferMotion to bring a sprite to life. Pass an optional request_id to tag the results so you can retrieve them later via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.transferMotionTransfer motion from a reference video or a named animation preset onto a static sprite image, producing an animated spritesheet that mimics the reference movement. Provide the sprite as image (URL or base64) plus either a video URL or a preset_id together with perspective and direction (all three from listAnimationPresets; if both video and preset_id are sent the video wins). The job result is the same sprite result as animateSprite: `spritesheet_url`, `video_url`, grid fields, optional GIF / frame / with-background URLs, and `audio_url` when the model is hydra. `duration` defaults to 1.5s where the chosen model offers it, otherwise to that model's shortest (hydra, the default, starts at 3s) - and a longer reference clip or preset is compressed to fit, so pass the preset's own `duration` (returned by listAnimationPresets) to keep its timing. It returns HTTP 400 if neither a video nor a complete preset_id/perspective/direction triple is supplied, if the named preset, perspective, or direction cannot be resolved, or if the model/duration combination is invalid. Credits are held for the duration you requested when the job is accepted; the final charge is rate × seconds of video generated (which follows the reference clip or preset; legacy models keep their minimum charge), never more than for the duration you requested, and the difference (or everything, if the job fails or is cancelled) is refunded. The returned sheet is then trimmed to its best loop and can run slightly shorter than the video; that trim is not deducted. Use this when you have an existing motion clip or preset to copy; prefer animateSprite to generate animation purely from a text prompt. Omit `model` to run on hydra (the default - most capable, and returns audio); pick forge for a cheaper run on simple motion, presets and matching poses; the `model` field lists rates. Pass an optional request_id to tag the result so you can retrieve it later via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: credits/s × seconds, per model: Hydra 3/s, Forge 2/s, Forge Pixel 2/s, Tango 4/s (min charge 4 credits) [LEGACY]; [LEGACY] models are scheduled for removal - do not use them for new work; see this endpoint's full pricing table in the API docs.getDocsBrowse or read Ludo's own documentation in full - how to choose a sprite animation mode, when to use Generate Before / Generate After, how margins behave, which model suits a job, and each generator's known limitations. To answer a specific question, call searchDocs first: it returns just the sections that match. Use getDocs to see what documentation exists, or to read a whole document or named sections. This is the same documentation the Ludo web app shows its users, so it occasionally describes buttons rather than parameters; the substance applies to the API and MCP surfaces just the same. To browse, call it with NO parameters to get a table of contents - every document with its id, label and section titles, and no bodies - then call it again with `doc` (and optionally `sections`) to read only what you need. Fetching a whole document can return tens of thousands of characters, so prefer naming the sections, using titles copied from the table of contents. Section titles match ignoring case, spacing and punctuation: when only some requested titles exist you receive those sections plus `unmatched_sections` and `available_sections`, and when none exist (or `doc` is unknown) the call returns 400 listing the valid values so you can retry once. This is a free discovery endpoint: it does not charge credits and does not queue a job.searchDocsSearch Ludo's own documentation with a plain-language question and get back only the few sections that answer it - the fastest way to learn how a feature is meant to be used before you generate with it (how to pick a sprite animation mode or model, how margins behave, what something costs, known limitations). Start here rather than reading whole documents. Each result carries `doc` and `section`, which you can pass straight to getDocs to re-read that section, and the section's full markdown `content`. Results are best first; weak matches are left out, so an empty `results` list means the documentation does not cover the question - rephrase it, or call getDocs with no parameters to browse the table of contents. This is the same documentation the Ludo web app shows its users, so it occasionally describes buttons rather than parameters; the substance applies to the API and MCP surfaces just the same. Returns up to `n` sections (default 3, max 10). If it answers 503 the search backend is briefly unavailable: call getDocs instead rather than retrying in a loop. This is a free discovery endpoint: it does not charge credits and does not queue a job.listAnimationPresetsList the available animation presets along with their perspectives and the eight supported compass directions (N, NE, E, SE, S, SW, W, NW). Synchronous GET with no request body: it returns an animations array (each with id, name, category, description, duration, and preview_url), a deduplicated perspectives array, and the directions list. This is a free discovery endpoint and does not charge credits. Use it to obtain the preset_id, perspective, and direction values that transferMotion needs, and to find motion preset names you can reference when animating; pair it with transferMotion (to apply a preset onto a sprite), animateSprite (text-prompt animation), or animate3DModelPreset (apply any preset by id to a rigged 3D model).- +32 more on the listing page
Ready-to-paste client configs
Paste either block (or both) into your client config, e.g. claude_desktop_config.json or ~/.cursor/mcp.json. We only show a config when the install command is confirmed.
RpgMakerMVUltimate MCP
{
"mcpServers": {
"diegolopez0208-rpgmakermvultimate-mcp": {
"command": "npx",
"args": [
"-y",
"rpgmaker-mv-mcp"
],
"env": {
"RPGMAKER_PROJECT_PATH": "YOUR_RPGMAKER_PROJECT_PATH_HERE"
}
}
}
}
Ludo AI Game Assets
{
"mcpServers": {
"ludo-ai-game-assets": {
"url": "https://mcp.ludo.ai/mcp"
}
}
}
Frequently asked questions
RpgMakerMVUltimate MCP is categorized under Gaming and uses a local stdio subprocess. Ludo AI Game Assets belongs to Gaming and uses a remote HTTP/SSE transport. Pick RpgMakerMVUltimate MCP for gaming work and Ludo AI Game Assets for gaming.
Copy the mcpServers block from the config section on this page into your client's config (for example claude_desktop_config.json or ~/.cursor/mcp.json), then fully restart the client.
RpgMakerMVUltimate MCP is listed as free. Auth: no auth required. Ludo AI Game Assets has no declared pricing — check the project's own site. Auth: api key required. If a server needs environment variables such as API keys, define them under the env key in your client's MCP config.
Yes. MCP clients support multiple servers: add diegolopez0208-rpgmakermvultimate-mcp and ludo-ai-game-assets as separate keys in the same mcpServers object, and your assistant will call tools from either one.
On AllMCPs, RpgMakerMVUltimate MCP has a quality signal of 68/100 (Great) with 7 views, 0 installs and 28 GitHub stars. Ludo AI Game Assets has 61/100 (Good) with 1 views, 0 installs and 7 GitHub stars.