Skip to main content
Glama

# spine-mcp

CI License: MIT Python 3.10+

A Model Context Protocol server for Esoteric Software Spine 2D skeletal animation. It lets an AI assistant (Claude, Cursor, …) create, edit, validate and animate Spine skeletons without the editor running, and drives the official Spine CLI for import and export when the editor is installed.

Türkçe: README.tr.md

  • 26 tools: bones, slots, attachments (region, mesh, point, bounding box, path), skins, events, IK / transform / path / physics constraints, keyframes on every Spine 4.x timeline, and rename/delete with reference cleanup.

  • Writes exactly what the runtimes read. Output follows SkeletonJson from the official runtimes (value keys, inherit, drawOrder, light/dark, absolute per-channel bezier curves, and the 4.3 constraints list or the 4.2 per-type lists depending on the file's version).

  • Checked against the official runtime. The test suite loads generated files with @esotericsoftware/spine-core 4.3 and checks real poses (IK, constraint mixes, path positions, easing curves).

  • Easy curves: pass "ease-in-out" or a CSS-style normalized [cx1, cy1, cx2, cy2]; it is converted to Spine's absolute bezier values and keeps its shape when keys are added later.

  • Safe edits: every write keeps a <file>.bak backup and returns validation problems.

  • One dependency: the official mcp Python SDK (1.x and 2.x supported).

Unofficial project. Spine is a trademark of Esoteric Software LLC. This project is not affiliated with or endorsed by Esoteric Software. You need your own Spine license to use the Spine editor and CLI features.


Contents

Related MCP server: Spine Motion MCP

How it works

The Spine editor's own .spine project files are a binary, undocumented format. spine-mcp edits the documented Spine skeleton JSON instead, and uses the Spine CLI to move between the two:

spine_create_project("hero.json")  →  add bones, slots, attachments, constraints, animations
spine_validate("hero.json")
spine_import_data(project="hero.spine", data_file="hero.json")   # a project the editor can open
spine_export(project="hero.spine", output="export/", pack=true)  # runtime JSON/binary + atlas

Have only a .spine file? Export it to JSON first (spine_export(format="json")). Editing tools detect binary files and say so.

Installation

Requires Python 3.10+. The Spine editor is optional (needed only for spine_export, spine_import_data and spine_cli_info).

Option A: run straight from GitHub with uvx (no clone)

With uv installed, MCP clients can start the server directly:

command: uvx
args:    ["--from", "git+https://github.com/UmutFarukDilli/spine-mcp", "spine-mcp"]

Option B: clone and install

git clone https://github.com/UmutFarukDilli/spine-mcp.git
cd spine-mcp
python -m venv .venv
# Windows
.venv\Scripts\python -m pip install -e .
# macOS / Linux
.venv/bin/python -m pip install -e .

The server command is then the venv's Python with -m spine_mcp:

OS

command

Windows

C:\path\to\spine-mcp\.venv\Scripts\python.exe

macOS / Linux

/path/to/spine-mcp/.venv/bin/python

Installing the package (pip install -e .) matters: MCP clients start the server from another working directory, so python -m spine_mcp must work from anywhere. Check with:

/path/to/spine-mcp/.venv/bin/python -c "import spine_mcp; print(spine_mcp.__version__)"

Spine CLI (optional)

The server finds the editor's CLI automatically (Spine.com / SpineTrial.com on Windows, Spine.app on macOS, Spine.sh on Linux, or anything on PATH). Point it at a specific install with the SPINE_CLI_PATH environment variable. Run the spine_doctor tool to see what it found.

Connecting to Claude and other clients

All clients use the same three values; examples below use Option B on Windows. Adjust the paths (or use the uvx command from Option A).

{
  "mcpServers": {
    "spine": {
      "command": "C:\\path\\to\\spine-mcp\\.venv\\Scripts\\python.exe",
      "args": ["-m", "spine_mcp"],
      "env": { "SPINE_CLI_PATH": "C:\\Program Files\\Spine\\Spine.com" }
    }
  }
}

env is optional.

Claude Code (CLI, or the Code tab of the Claude desktop app)

claude mcp add spine --scope user -- /path/to/spine-mcp/.venv/bin/python -m spine_mcp
# with a Spine CLI path:
claude mcp add spine --scope user -e SPINE_CLI_PATH="/Applications/Spine.app/Contents/MacOS/Spine" -- /path/to/spine-mcp/.venv/bin/python -m spine_mcp

Without the CLI, add the "spine" entry to mcpServers in ~/.claude.json (user scope, with "type": "stdio"), or to a project's .mcp.json to share it with that project.

Claude Desktop (chat)

Settings → Developer → Edit Config opens claude_desktop_config.json. Add the mcpServers block above at the top level, leaving the other settings as they are. Usual locations:

OS

File

Windows

%APPDATA%\Claude\claude_desktop_config.json (Microsoft Store build: %LOCALAPPDATA%\Claude-Data\claude_<id>\claude_desktop_config.json)

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Cursor and others

Cursor reads the same block from .cursor/mcp.json. Any other MCP client: use the command, args and env above (stdio transport).

After adding it

Config is read at startup: quit the app completely and reopen it (start a new session in Claude Code). Then ask, for example, "run spine_doctor".

Problem

Fix

Tools do not show up

Restart the app fully; check the JSON for missing commas or unescaped \

No module named 'spine_mcp'

Run pip install -e . with the venv's Python

Test the server by hand

Run the command yourself; it should wait silently for input (Ctrl+C to quit)

Tools

Discovery and validation

Tool

Description

spine_doctor

Python/MCP versions, detected Spine CLIs and their versions, hints

spine_list_projects

Binary .spine projects and Spine JSON files under a folder (version and counts)

spine_inspect

Version, bone tree, slots, skins, constraints, animations, events

spine_validate

Errors and warnings: duplicate names, missing parents, broken attachments and meshes, timelines with unknown targets, unsorted keys, out-of-range curves, fields the runtime ignores, 4.2/4.3 constraint layout

Creating

Tool

Description

spine_create_project

New Spine 4.x skeleton JSON with a root bone

spine_add_bone

Bone (parent, length, x/y, rotation, scale, shear, inherit)

spine_add_slot

Slot (bone, setup attachment, color, dark color, blend, draw-order index)

spine_add_attachment

region, mesh (grid with hull), point, boundingbox, path (smooth curve through anchor points)

spine_add_skin

Skin (outfit/variant), optionally copied from another skin

spine_add_event

Event with int/float/string/audio/volume/balance

Constraints

Written in the file's format: the 4.3 typed constraints list (order = list position) or the 4.2 ik / transform / path / physics lists (with order).

Tool

Description

spine_add_ik_constraint

1- or 2-bone IK (mix, bend direction, softness, stretch, compress)

spine_add_transform_constraint

Bones copy a source bone's rotate/x/y/scaleX/scaleY/shearY with per-property mix and offset, local, additive; on 4.3, mapping links different properties (e.g. source rotation → target x)

spine_add_path_constraint

Places bones along a path attachment (position/spacing/rotate modes, mixes)

spine_add_physics_constraint

Spring physics for hair, tails and cloth (x/y/rotate/scaleX/shearX response, inertia, strength, damping, mass, wind, gravity)

Animating

Tool

Description

spine_add_animation

Empty animation

spine_set_keyframes

Keys for rotate, translate, translatex/y, scale, scalex/y, shear, shearx/y, inherit, attachment, rgba, rgb, rgba2, rgb2, alpha, event, drawOrder, ik, transform, path.position/spacing/mix, physics.inertia/strength/damping/mass/wind/gravity/mix/reset

spine_delete_keyframes

Remove keys at given times, or a whole timeline

spine_duplicate_animation

Copy an animation (e.g. walk → walk-fast)

spine_delete_animation

Remove an animation

Curve presets: linear, stepped, ease, ease-in, ease-out, ease-in-out, smooth, or a normalized [cx1, cy1, cx2, cy2]. In transform and path.mix keys, mixes you leave out keep the constraint's setup value (runtimes would otherwise treat them as 1 and switch on unused properties).

Fixing

Tool

Description

spine_update_bone

Change the setup pose; new_name renames everywhere, parent moves the subtree (cycles are refused)

spine_update_slot

Bone, attachment, colors, blend, draw-order position, new_name

spine_delete

Delete a bone (cascade), slot, attachment, event, constraint, animation or skin, and clean up references

spine_upgrade

Convert files written by spine-mcp 0.1 to correct 4.x fields (editing tools do this automatically)

Spine CLI (editor required)

Tool

Description

spine_export

JSON or binary export, optional atlas packing, animation clean-up, dry_run

spine_import_data

Import JSON/binary skeleton data into a .spine project

spine_cli_info

Spine -i project output (editor version, warnings)

Example

A conversation like "make a character with a waving arm" turns into calls such as:

spine_create_project(project="hero.json", name="hero", width=512, height=512)
spine_add_bone(project="hero.json", name="hip", parent="root", y=120)
spine_add_bone(project="hero.json", name="torso", parent="hip", length=80, rotation=90)
spine_add_slot(project="hero.json", name="torso", bone="torso")
spine_add_attachment(project="hero.json", slot="torso", name="torso", kind="region", width=64, height=120)
spine_set_keyframes(project="hero.json", animation="idle", timeline="rotate", target="torso",
                    curve="ease-in-out",
                    keys=[{"time": 0, "value": 0}, {"time": 1, "value": 8}, {"time": 2, "value": 0}])
spine_validate(project="hero.json")

examples/demo.json is a complete character (13 bones, 10 slots, idle / walk / wave animations, events, placeholder images in examples/images/), built by examples/make_demo.py (needs Pillow).

Development and tests

pip install -e ".[test]"
pytest
  • tests/test_project.py: the document model (curves, constraints, upgrade, rename/delete)

  • tests/test_validation.py: validation rules

  • tests/test_cli.py: CLI detection and command building

  • tests/test_stdio.py: end-to-end MCP calls over real stdio JSON-RPC

  • tests/test_runtime.py: loads and poses generated files with the official Spine runtime (needs Node.js 18+ and npm ci in tools/; skipped otherwise)

cd tools && npm ci && cd ..
node tools/verify_runtime.mjs examples/demo.json                          # load + play every animation
node tools/sample_pose.mjs examples/demo.json walk 0,0.5 leg-front,hip    # bone world values

CI runs the suite on Windows, macOS and Linux with Python 3.10 and 3.13, plus mcp<2. See CONTRIBUTING.md.

@esotericsoftware/spine-core is only a development dependency for these checks; it is not bundled with or required by the server. It is covered by the Spine Runtimes License.

Limitations

  • No editor GUI automation. The Spine CLI only exports, imports, packs and reports info; spine-mcp adds JSON editing on top of it.

  • Binary .spine projects cannot be edited directly (see How it works). Spine 3.x JSON is refused for editing; spine_validate warns about it.

  • 4.3 slider constraints are read and validated, but no tool creates them yet.

  • The 4.2 constraint layout was checked by hand with spine-core 4.2; automated runtime tests use 4.3.

  • CLI features need a licensed Spine editor. The Spine Trial does not export, so spine_export times out with it; the generated command can be checked with dry_run=true.

  • Mesh attachments are generated as regular grids; pass uvs / vertices / triangles / hull for custom meshes, or refine them in the editor.

  • CLI exports must match your runtime version (a Spine rule).

License

MIT

Available Tools

26 tools
spine_add_animationB

Create an empty animation. Add keyframes afterwards with spine_set_keyframes.

Inputs: name (required), project (required). Returns: result

spine_add_attachmentA

Attach something to a slot inside a skin (registration + optional setup assignment).

Kinds:

  • region - textured rectangle centered on x/y; needs width/height. image_path is the region name inside the images folder/atlas, without extension (defaults to the attachment name; a .png suffix is stripped).

  • mesh - textured mesh; a regular grid centered on x/y is generated from width/height/cols/rows unless explicit uvs/vertices/triangles are given (then list the outline vertices first and pass hull = their count).

  • point - single point with rotation (projectile/particle spawn).

  • boundingbox - polygon for hit detection; needs vertices (x,y pairs).

  • path - curve for spine_add_path_constraint; vertices are the anchor points (x,y pairs, in the slot bone's space). Smooth handles and the curve lengths are generated. closed makes a loop; constant_speed (default) keeps bones evenly spaced along it.

Args: assign: Also set this attachment as the slot's setup-pose attachment. skin: Skin to put the attachment in (created if missing).

Inputs: name (required), slot (required), project (required), x, +19 more. Returns: result

spine_add_boneC

Add a setup-pose bone. The bone is inserted after its parent's subtree so that "parents always come first" stays valid. Returns the resulting bone tree.

Args: inherit: normal, onlyTranslation, noRotationOrReflection, noScale or noScaleOrReflection. transform: Deprecated alias of inherit (the pre-4.2 field name). skin: Only active while a skin that contains it is active. color: Optional bone color as RRGGBB or RRGGBBAA.

Inputs: name (required), project (required), x, y, +11 more. Returns: result

spine_add_eventC

Define a named event (setup-pose values) that animations can trigger.

Args: int_value: Integer payload. float_value: Float payload. string: String payload. audio: Audio path played by the event. volume: Audio volume (default 1). balance: Stereo balance, -1..1 (default 0).

Inputs: name (required), project (required), audio, string, +4 more. Returns: result

spine_add_ik_constraintA

Add an IK constraint: 1 bone points at the target, 2 bones (parent, direct child) bend like a limb so the child's tip reaches the target. Animate it with timeline "ik".

Args: bones: [bone] or [upper, lower], e.g. ["thigh", "shin"]. target: Bone to reach (must not be one of bones or their children), e.g. "foot-target". mix: 0..1 influence. bend_positive: Bend direction of a 2-bone chain. softness: Distance before full extension where the chain starts to slow down. compress / stretch / uniform: Scale the bone(s) to reach the target. order: Constraint order (default: after existing constraints).

Inputs: name (required), bones (required), target (required), project (required), +7 more. Returns: result

spine_add_path_constraintA

Add a path constraint: bones are placed along the path attachment shown in slot (add one first with spine_add_attachment kind="path"). Animate "path.position" to move them along it.

Args: position_mode: percent (position 0..1 of the path length) or fixed (in pixels). spacing_mode: length, fixed, percent or proportional (distance between the bones). rotate_mode: tangent, chain or chainScale. rotation: Rotation offset in degrees. position: Setup position along the path. spacing: Setup spacing between bones. mix_rotate / mix_x / mix_y: 0..1 influence (mix_y defaults to mix_x).

Inputs: name (required), slot (required), bones (required), project (required), +10 more. Returns: result

spine_add_physics_constraintA

Add a physics constraint (Spine 4.2+): the bone reacts like a spring when the skeleton moves - hair, tails, ears, cloth. At least one of x, y, rotate, scale_x, shear_x must be > 0. Animate it with "physics.wind", "physics.gravity", "physics.reset", ...

Args: x / y / rotate / scale_x / shear_x: 0..1 how much the bone reacts in each channel. inertia: 0..1, how much movement is kept from the parent (default 0.5). strength: Spring stiffness (default 100). damping: 0..1, how quickly motion settles (default 0.85). mass: > 0 (default 1). wind / gravity: Constant forces (default 0). mix: 0..1 overall influence. limit: Maximum speed (default 5000). fps: Simulation rate (default 60).

Inputs: bone (required), name (required), project (required), x, +14 more. Returns: result

spine_add_skinB

Create a skin (e.g. an outfit). Use copy_from to start from another skin's attachments, then add or replace attachments with spine_add_attachment(skin=name).

Inputs: name (required), project (required), copy_from. Returns: result

spine_add_slotA

Add a draw-order slot attached to an existing bone.

Slots are drawn in list order (later slots on top). Use index to insert at a specific draw position instead of appending.

Args: attachment: Name of the setup-pose attachment (must exist in a skin). color: RRGGBB or RRGGBBAA setup color. dark: 6-digit dark color for two-color tinting. blend: normal, additive, multiply or screen.

Inputs: bone (required), name (required), project (required), dark, +4 more. Returns: result

spine_add_transform_constraintA

Add a transform constraint: bones copy the source bone's rotation, position, scale and/or shear (e.g. a cape following the torso, wheels sharing rotation). Animate it with timeline "transform". Written in the file's format (4.3 "constraints" list or 4.2 "transform").

Args: properties: What to copy, any of rotate, x, y, scaleX, scaleY, shearY (default all). mix: 0..1 influence per property, e.g. {"rotate": 1, "x": 0.5} (default 1). offsets: Constant offsets per property, e.g. {"rotate": 90, "x": 10}. local: Use local instead of world transforms. additive: Add to the bones' own transform instead of replacing it (4.2: "relative"). clamp: (4.3) Clamp converted values to the mapping's max. mapping: (4.3) Raw property map for cross-property links, e.g. {"rotate": {"to": {"x": {"scale": 2}}}} turns the source's rotation into x movement. Overrides properties. order: Update order among constraints (default: last).

Inputs: name (required), bones (required), source (required), project (required), +8 more. Returns: result

spine_cli_infoB

Ask the Spine CLI for project information (-i project). Shows the editor version, animation counts and warnings for files the offline parser may not understand.

Inputs: project (required), timeout. Returns: result

spine_create_projectA

Create a new Spine 4.x skeleton JSON file containing a single "root" bone.

Args: project: Target path ending in .json (the editor's .spine format is binary; convert the JSON into a real project with spine_import_data). name: Skeleton name (defaults to the file name). width: Skeleton bounds width reported in the skeleton section. height: Skeleton bounds height reported in the skeleton section. spine_version: Version string written to skeleton.spine (default 4.3.00 or $SPINE_VERSION). images: Image folder stored in skeleton.images. audio: Audio folder stored in skeleton.audio. overwrite: Replace an existing file.

Inputs: project (required), name, audio, width, +4 more. Returns: result

spine_deleteB

Delete a bone, slot, attachment, event, constraint, animation or skin and clean up everything that refers to it (timelines, draw order keys, constraints, skin entries).

Args: kind: bone, slot, attachment, event, constraint, animation or skin. slot: Required for kind="attachment". skin: Skin of the attachment (kind="attachment"). cascade: For bones: also delete child bones and their slots (otherwise refused if any exist).

Inputs: kind (required), name (required), project (required), skin, +2 more. Returns: result

spine_delete_animationB

Remove an animation (e.g. before regenerating it). Other animations are untouched.

Inputs: name (required), project (required). Returns: result

spine_delete_keyframesA

Remove keys from one timeline: the keys at times (seconds), or the whole timeline when times is omitted. Curves of the remaining keys keep their shape.

Args: timeline: Same names as spine_set_keyframes (rotate, translate, attachment, event, drawOrder, ik...). target: Bone, slot or IK constraint name (empty for event/drawOrder).

Inputs: project (required), timeline (required), animation (required), times, +1 more. Returns: result

spine_doctorA

Check the environment: Python/MCP SDK versions, detected Spine CLI paths and versions.

Call this first when export or import fails, or to discover whether the Spine editor is installed and usable from the command line.

Inputs: no named parameters. Returns: result

spine_duplicate_animationB

Copy an animation under a new name (e.g. "walk" -> "walk-fast" before retiming it).

Inputs: name (required), source (required), project (required). Returns: result

spine_exportA

Export a .spine project through the Spine CLI (Spine -i project -o output -e json).

The editor must be installed; the executable is auto-detected or taken from SPINE_CLI_PATH. The first run of the Trial launcher can download the editor and therefore be slow - raise timeout if needed.

Args: output: Output folder (files are named after the skeleton). format: "json" or "binary". pack: Also pack a texture atlas (json+pack / binary+pack). clean: Animation clean-up before export (-m); does not modify the project. settings: Path to a saved export-settings JSON; overrides format/pack. timeout: Seconds to wait for the CLI. dry_run: Only return the command that would be executed.

Inputs: output (required), project (required), pack, clean, +4 more. Returns: result

spine_import_dataC

Import a Spine JSON/binary file (or another project) into a .spine project via the CLI (Spine -i data -o project -r [name]). The project is created if missing.

Inputs: project (required), data_file (required), scale, timeout, +1 more. Returns: result

spine_inspectA

Read a .spine/.json file and return its structure: version, bone tree, slots, skins, attachment counts by type, animations with durations and events.

Args: project: Path to a .spine project or exported Spine JSON. detail: "summary" (default) or "full" to include every animation track.

Inputs: project (required), detail. Returns: result

spine_list_projectsA

Find Spine files under a directory: binary .spine editor projects (type "project") and Spine skeleton JSON (type "json", with version and counts). Other JSON is skipped.

Args: root: Directory to scan (absolute or relative to the server working directory). include_json: Also look at .json files (default true). limit: Maximum number of results (1-2000).

Inputs: root, limit, include_json. Returns: result

spine_set_keyframesA

Add or replace keyframes of one timeline (the animation is created if missing).

Timelines and their key fields (written in the Spine 4.x JSON format):

  • rotate (bone) keys: {"time": 0, "value": 15} ("angle" is accepted too)

  • translate (bone) keys: {"time": 0, "x": 10, "y": -4}

  • scale (bone) keys: {"time": 0, "x": 1, "y": 1}

  • shear (bone) keys: {"time": 0, "x": 0, "y": 0}

  • translatex/translatey/scalex/scaley/shearx/sheary (bone) keys: {"time": 0, "value": 3}

  • inherit (bone) keys: {"time": 0, "inherit": "noScale"}

  • attachment(slot) keys: {"time": 0, "name": "eyes-closed"} (null clears)

  • rgba / rgb (slot) keys: {"time": 0, "color": "FFFFFFFF"} (RRGGBB for rgb)

  • rgba2 / rgb2 (slot) keys: {"time": 0, "light": "FFFFFFFF", "dark": "000000"}

  • alpha (slot) keys: {"time": 0, "value": 0.5}

  • event keys: {"time": 0.2, "name": "footstep", "int": 1}

  • drawOrder keys: {"time": 0, "offsets": [{"slot": "arm", "offset": 1}]}

  • ik (constraint) keys: {"time": 0, "mix": 1, "softness": 0, "bendPositive": false}

  • transform (constraint) keys: {"time": 0, "mixRotate": 1, "mixX": 0.5, ...} (mixRotate/mixX/mixY/mixScaleX/mixScaleY/mixShearY; omitted mixes keep the setup value)

  • path.position / path.spacing (constraint) keys: {"time": 0, "value": 0.25}

  • path.mix (constraint) keys: {"time": 0, "mixRotate": 1, "mixX": 1, "mixY": 1}

  • physics.inertia/strength/damping/mass/wind/gravity/mix keys: {"time": 0, "value": 30}

  • physics.reset keys: {"time": 0.5} (physics target "" = every physics constraint)

Curves: every key accepts "curve": "linear" (default), "stepped", a preset ("ease", "ease-in", "ease-out", "ease-in-out", "smooth") or [cx1, cy1, cx2, cy2] normalized to the interval up to the next key (0..1, like CSS cubic-bezier). They are converted to Spine's absolute bezier values automatically and keep their shape when keys are added later. The curve argument is the default for keys that do not specify one.

Args: target: Bone name for bone timelines, slot name for slot timelines, constraint name for ik/transform/path/physics. Ignored for event/drawOrder. mode: upsert (default: merge, new keys win at equal times), append (merge, error on equal times) or replace (the whole timeline).

Inputs: keys (required), project (required), timeline (required), animation (required), +3 more. Returns: result

spine_update_boneA

Change an existing bone's setup pose. Only the arguments you pass are changed.

new_name renames the bone everywhere (children, slots, constraints, skins, animations). parent re-parents it (with its whole subtree; cycles are refused). Pass color="" to clear it.

Inputs: name (required), project (required), x, y, +11 more. Returns: result

spine_update_slotA

Change an existing slot. Only the arguments you pass are changed.

Args: new_name: Rename the slot everywhere (skins, animations, draw order keys, path constraints). bone: Move the slot to another bone. attachment: Setup-pose attachment; "" clears it (the slot starts empty). color: RRGGBB(AA) setup color; "" resets to white. dark: RRGGBB dark color for two-color tinting; "" removes it. blend: normal, additive, multiply or screen. index: New draw-order position (0 = drawn first / at the back).

Inputs: name (required), project (required), bone, dark, +5 more. Returns: result

spine_upgradeA

Fix a document written by spine-mcp 0.1: rotate "angle" -> "value", alpha -> "value", "draworder" -> "drawOrder", bone "transform" -> "inherit" and normalized curves -> absolute Spine 4.x curves. Every editing tool does this automatically; use this to fix a file as is.

Inputs: project (required). Returns: result

spine_validateA

Validate a Spine JSON project offline: duplicate names, missing parents, bones listed after their parent, unknown slot bones, malformed attachments, timelines pointing at missing bones/slots/events, unsorted keyframes and curves.

Returns {"ok": bool, "errors": [...], "warnings": [...], "stats": {...}}.

Inputs: project (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 26 tools

    Disambiguation4/5

    Each tool targets a distinct resource+action (add_bone vs update_bone vs add_slot vs set_keyframes), and the descriptions do a good job of separating near-neighbours like spine_inspect (offline parser) and spine_cli_info (editor CLI). There is some genuine redundancy: spine_delete_animation is a strict subset of spine_delete(kind="animation"), and spine_delete_keyframes overlaps with spine_set_keyframes(mode="replace"), but these are convenience shortcuts rather than true ambiguity.

    Naming Consistency4/5

    All names share a spine_ prefix and snake_case, with a clear verb_noun convention (add_bone, update_slot, set_keyframes, delete_animation, create_project, list_projects). A handful of tools drop the verb (spine_inspect, spine_doctor, spine_upgrade, spine_cli_info), which is a minor deviation but still readable and consistent in style.

    Tool Count3/5

    26 tools sits at the heavy end of the rubric for a single-purpose server. The domain is genuinely broad (bones, slots, attachments, keyframes, four constraint types, skins, export/import), but the four spine_add_*_constraint tools plus spine_add_attachment's kind-switch suggest the surface could be consolidated.

    Completeness4/5

    Lifecycle coverage is strong: create/inspect/validate/export/import plus add/update/delete for bones and slots, add/set/delete for keyframes and animations, and delete for every entity kind. The main gaps are the absence of update tools for constraints, events, and attachments (and no animation rename), which force a delete-and-re-add workaround.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables authoring, preview, and export of Spine 2D skeletal animations via natural language from Claude Code or any MCP client, with a web dashboard and tools for keyframing, templates, and GIF preview.
      8
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI clients to directly control Spine 3.8.75 animation workflows through 55 MCP tools, including reading projects, editing keyframes, manipulating skeletons, constraints, meshes, atlases, and rendering previews.
      27 npm
      28
      MIT
    • F
      license
      A
      quality
      B
      maintenance
      Enables converting layered PSD or PhotoshopToSpine exports into validated Spine 2D rigs, animations, atlases, previews, runtime JSON, and optionally editable .spine projects. It provides MCP tools and an OpenAI/Codex workflow for rigging, animation generation, validation, preview auditing, and batch processing.
      14
      -