Skip to main content
Glama
Cavalry MCP Bridge

Cavalry MCP Bridge

# Cavalry Motion App MCP Bridge

A Model Context Protocol (MCP) server that connects AI assistants (like Claude Desktop, Antigravity, Cursor, and ChatGPT) directly to Cavalry, the procedural 2D motion graphics and animation application by Scene Group.


Features

  • Procedural Layer Creation: Create shapes, text, duplicators, grids, noise generators, color palettes, math nodes, deformers, and particle emitters via natural language.

  • Dynamic Node Graph Connections: Connect outputs and inputs between nodes (e.g. wire a noise generator to a shape's scale or rotation).

  • Attribute Control & Keyframing: Inspect and update any property, scrub the timeline, and add animated keyframes.

  • Scene Introspection: Query active composition metadata, layer hierarchies, and selected nodes.

  • Render Pipeline: Add compositions to the Render Queue and trigger batch renders.

  • Raw Script Execution: Execute arbitrary JavaScript against Cavalry’s native api.* module.


Related MCP server: cavalry-mcp

Architecture

┌─────────────────────────┐          stdio (MCP)         ┌─────────────────────────────────┐
│ AI Assistant / LLM      │ ◄──────────────────────────► │ Cavalry MCP Server              │
│ (Claude, Antigravity)   │                              │ (TypeScript / Node.js)          │
└─────────────────────────┘                              └────────────────┬────────────────┘
                                                                          │
                                                             HTTP POST    │ (http://127.0.0.1:8080)
                                                                          ▼
                                                         ┌─────────────────────────────────┐
                                                         │ In-Cavalry Script Bridge        │
                                                         │ (MCPBridge.js in Scripts menu)  │
                                                         │ ───► api.create(...)            │
                                                         │ ───► api.set(...)               │
                                                         │ ───► api.connect(...)           │
                                                         └─────────────────────────────────┘

Quick Start

1. Install Dependencies & Build

From this project directory:

npm install
npm run build

2. Install Bridge Script into Cavalry

Run the installer to copy MCPBridge.js to your Cavalry scripts folder:

npm run install-bridge

On Windows, this copies MCPBridge.js to %APPDATA%\Cavalry\Scripts\.

3. Start the Bridge in Cavalry

  1. Launch Cavalry.

  2. Go to the top menu: Scripts → MCPBridge.

  3. A small panel will open showing Status: Online (Port 8080). Keep this open while using the MCP server.

(Alternatively, if you already have the Stallion extension active, it also listens on port 8080 and works seamlessly with this MCP server).

4. Test the Connection

Verify that the MCP server can communicate with Cavalry:

npm run test-connection

MCP Client Configuration

Claude Desktop

Add the following to your claude_desktop_config.json (located at %APPDATA%\Claude\claude_desktop_config.json on Windows or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "cavalry": {
      "command": "node",
      "args": [
        "C:/Users/david/Documents/ANTIGRAVITY APP/CALVARY MCP/dist/index.js"
      ],
      "env": {
        "CAVALRY_BRIDGE_PORT": "8080"
      }
    }
  }
}

Antigravity / Cursor / Custom Client

Add to your settings or .cursor/mcp.json:

{
  "mcpServers": {
    "cavalry": {
      "command": "node",
      "args": ["C:/Users/david/Documents/ANTIGRAVITY APP/CALVARY MCP/dist/index.js"]
    }
  }
}

Available MCP Tools

Tool

Description

cavalry_run_script

Run arbitrary JavaScript code in Cavalry using api.*.

cavalry_eval_expression

Evaluate a single expression and return its value.

cavalry_get_scene_info

Query active composition name, frame count, FPS, and layer count.

cavalry_get_comp_layers

List all layer IDs in the current composition.

cavalry_get_selected_layers

Get the IDs of currently selected layers.

cavalry_create_layer

Create a new layer/node (basicShape, textShape, duplicator, etc.).

cavalry_set_attributes

Set one or more attribute values on a layer.

cavalry_get_attributes

Query an attribute value on a layer.

cavalry_delete_layer

Delete a layer/node from the scene.

cavalry_connect_attributes

Connect source attribute to target attribute in dependency graph.

cavalry_disconnect_attributes

Disconnect an attribute connection.

cavalry_set_frame

Scrub the playhead to a specific frame.

cavalry_get_frame

Get the current frame number.

cavalry_set_keyframe

Add a keyframe with value at a specified frame.

cavalry_playback_control

Play, stop, or rewind the timeline.

cavalry_add_to_render_queue

Add the composition to the Render Manager.

cavalry_render_queue

Start rendering items in the queue.


Example Prompts for AI Assistants

1. Animated Noise Grid

"Create a 12x12 grid of rounded squares in Cavalry, attach a noise modifier to their rotation and scale, and set the fill color to electric blue."

2. Kinetic Typography

"Create kinetic text with the headline 'ANTIGRAVITY' in Cavalry. Set the font size to 120, center it, and add a bouncy spring oscillation to the Y position."

3. Radial Burst Animation

"Build a radial burst animation with 24 lines radiating outwards from the center, driven by a step duplicator and keyed to expand from frame 0 to frame 45."


License

MIT

Available Tools

18 tools
cavalry_add_to_render_queueB

Adds the active composition to the Cavalry Render Queue with specified format or destination.

Inputs: format, outputPath.

cavalry_connect_attributesA

Connects an attribute or output of a source node to an input attribute of a target node in Cavalry's procedural dependency graph.

Inputs: sourceId (required), targetId (required), sourceAttr (required), targetAttr (required).

cavalry_create_layerA

Creates a new layer or procedural node in the active Cavalry scene (e.g. 'basicShape', 'textShape', 'duplicator', 'gridDistribution', 'noise', 'colorArray', 'nullLayer', 'particleEmitter', 'deformer').

Inputs: name (required), type (required), attributes.

cavalry_create_primitiveB

Creates a geometric primitive shape in Cavalry (e.g. 'ellipse', 'rectangle', 'star', 'superEllipse', 'polygon', 'ring', 'arrow', 'line') with optional initial attributes like 'material.materialColor', 'scale.x', 'scale.y', 'position.x', 'position.y'.

Inputs: name (required), generator (required), attributes.

cavalry_delete_layerC

Deletes a layer or node from the scene.

Inputs: layerId (required).

cavalry_disconnect_attributesB

Breaks a connection to a specific attribute on a target node in Cavalry.

Inputs: targetId (required), targetAttr (required), sourceId, sourceAttr.

cavalry_eval_expressionB

Evaluates a single JavaScript expression inside Cavalry and returns its value.

Inputs: expression (required).

cavalry_get_attributesB

Retrieves the value of a specific attribute or array of attributes from a layer.

Inputs: layerId (required), attributePath (required).

cavalry_get_comp_layersB

Returns an array of layer and node IDs present in the active composition.

Inputs: topLevelOnly.

cavalry_get_frameA

Returns the current playhead frame number in the active composition.

Inputs: no named parameters.

cavalry_get_scene_infoA

Retrieves metadata about the active Cavalry composition, including current frame, total duration, frame rate, and layer hierarchy.

Inputs: no named parameters.

cavalry_get_selected_layersB

Returns an array of IDs of the currently selected layers in the Cavalry viewport / scene tree.

Inputs: no named parameters.

cavalry_playback_controlA

Controls timeline playback (play, stop, or rewind) in the active viewport.

Inputs: action (required).

cavalry_render_queueA

Triggers rendering of the items in the Render Manager / Render Queue.

Inputs: no named parameters.

cavalry_run_scriptA

Executes a multiline JavaScript automation script inside Cavalry using the api.* module. Use this for complex procedural generation, node network creation, and batch updates.

Inputs: code (required).

cavalry_set_attributesB

Sets one or more attribute values on an existing layer in Cavalry (e.g. 'material.materialColor', 'position.x', 'scale.x', 'rotation.z', 'opacity').

Inputs: layerId (required), attributes (required).

cavalry_set_frameA

Moves the timeline playhead to a specific frame number in the active composition.

Inputs: frame (required).

cavalry_set_keyframeA

Sets an animation keyframe for attributes on a layer at a given frame number using Cavalry's official api.keyframe(layerId, frame, { attr: value }) API.

Inputs: frame (required), layerId (required), attributes (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 18 tools

    Disambiguation4/5

    Most tools target clearly distinct operations: creation, attribute access, graph connections, timeline, playback, and rendering. However, `eval_expression` and `run_script` overlap in JS execution, and `render_queue` vs `add_to_render_queue` could cause minor confusion despite different purposes.

    Naming Consistency4/5

    All tools share the `cavalry_` prefix and mostly follow a verb_noun pattern such as `get_scene_info`, `create_layer`, and `set_attributes`. Minor deviations like `playback_control` and `add_to_render_queue` break the strict pattern but do not harm readability.

    Tool Count3/5

    Eighteen tools is on the heavier side and the count falls in the 16-25 borderline range. The breadth is understandable for a motion-graphics automation bridge, but a few tools could be consolidated, such as merging `get_comp_layers` and `get_selected_layers` or `render_queue` and `add_to_render_queue`.

    Completeness4/5

    The toolset covers the main workflows: scene inspection, layer creation, attribute manipulation, graph connections, animation keyframing, timeline control, and rendering. Obvious gaps like composition management or render queue status checking are missing, but the core lifecycle is well represented for the stated purpose.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables AI assistants to operate Adobe After Effects with the dexterity of an editor: reading projects, creating and rigging layers, setting real velocity curves, animating text, building native SVG-based shapes, applying effects, expressions, masks, and viewing render snapshots to verify results.
      17
      18 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables Claude to inspect and edit Cavalry scenes by reading layers and connections, executing JavaScript, connecting nodes, changing Duplicator distributions, and rendering frames for visual feedback.
      MIT