Skip to main content
Glama
beat-mcp-bridge

beat-mcp-bridge

beat-mcp-bridge

Connects Claude to Beat, the Fountain screenplay editor, so Claude can read and rewrite your screenplay directly in the app — no copy/pasting new versions back and forth.

How it works

Beat's plugin API is JavaScript running inside the app, with no networking. So this is two halves talking through two small JSON files on disk:

Claude  <-->  MCP server (this repo)  <-->  request.json / response.json  <-->  Beat plugin (inside Beat)
  1. Claude calls an MCP tool (e.g. beat_replace_scene).

  2. The MCP server writes request.json into a shared "bridge" folder.

  3. The Claude Bridge Beat plugin (a resident Tools-menu plugin) polls that folder once a second, runs the operation against the live document, and writes response.json.

  4. The MCP server reads the result back to Claude.

Edits land in the open document immediately — you'll see the text change while Beat is on screen.

Related MCP server: fcp-mcp-server

Setup

1. Create the bridge folder

Both sides need to agree on one folder. Pick any empty folder, e.g.:

mkdir -p ~/ClaudeBeatBridge

2. Install the Beat plugin

Copy beat-plugin/Claude Bridge.beatPlugin into Beat's plugin folder:

  • In Beat: Tools → Plugin Library, click the folder icon at the bottom to reveal the local plugins folder in Finder.

  • Copy Claude Bridge.beatPlugin (the whole folder) into it.

  • Restart the Plugin Library or Beat so it picks up the new plugin.

  • Open a screenplay, then check Tools → Claude Bridge to enable it. The first time it runs it will prompt you for the bridge folder path — enter the same path from step 1 (e.g. /Users/you/ClaudeBeatBridge).

  • Leave it checked. It stays resident and keeps polling in the background.

3. Install the MCP server

cd beat_claude_mcp
npm install

4. Point Claude at it

Add to your MCP client config (e.g. Claude Desktop's claude_desktop_config.json, or claude mcp add for Claude Code), setting BEAT_BRIDGE_DIR to the folder from step 1:

{
  "mcpServers": {
    "beat": {
      "command": "node",
      "args": ["/absolute/path/to/beat_claude_mcp/index.js"],
      "env": {
        "BEAT_BRIDGE_DIR": "/Users/you/ClaudeBeatBridge"
      }
    }
  }
}

Restart the client. Ask Claude to beat_ping — it should report Beat is reachable and how many documents are open.

Tools

Tool

Purpose

beat_ping

Health check — is Beat/the plugin reachable?

beat_list_documents

List open screenplays, with the docIndex used below

beat_get_text

Full Fountain text of a document

beat_set_text

Replace the whole document (full rewrite)

beat_get_outline

Scenes + sections + synopses, with sceneIndex

beat_get_scenes

Just the scenes

beat_get_scene_text

Text of one scene

beat_replace_scene

Rewrite one scene in place, leaving the rest untouched

beat_insert_text

Insert text at a character offset

beat_append_text

Append text (e.g. a new scene) at the end

beat_inspect_documents

Debug: dump raw document fields if titles look wrong

For most editing sessions, prefer beat_get_outline + beat_replace_scene over beat_set_text — targeted scene rewrites are faster to apply and much safer to review than swapping the entire document.

Notes / limitations

  • Every open Beat document is targetable via docIndex from beat_list_documents, but Beat's plugin docs don't pin down the exact property names for a document's file path across versions — if beat_list_documents shows unhelpful titles, run beat_inspect_documents and adjust the candidates list in beat-plugin/Claude Bridge.beatPlugin/plugin.js (describeDocument function) to match what your Beat version exposes.

  • The bridge polls once a second, so there's up to ~1s of latency per call plus the 250ms the MCP server itself polls at — fine for editing, not built for high-frequency use.

  • No file, network, or shell access beyond the one bridge folder — the plugin only ever reads/writes request.json and response.json there.

  • Standard undo/redo in Beat still works on Claude's edits, since they go through the same text-replacement APIs as a human typing.

Available Tools

11 tools
beat_append_textAppend text to the endA

Append text (e.g. a new scene) to the end of a Beat document.

Inputs: text (required), docIndex.

beat_get_outlineGet outline (scenes, sections, synopses)A

Get the full outline of a Beat document: scene headings, sections and synopsis lines, in order, with the sceneIndex needed by beat_get_scene_text / beat_replace_scene.

Inputs: docIndex.

beat_get_scenesGet scene listA

Get just the scenes (no sections/synopses) of a Beat document, with sceneIndex, heading text, and position.

Inputs: docIndex.

beat_get_scene_textGet one scene's textA

Get the full text of a single scene by its sceneIndex (from beat_get_scenes).

Inputs: sceneIndex (required), docIndex.

beat_get_textGet full screenplay textA

Get the complete Fountain text of a Beat document.

Inputs: docIndex.

beat_insert_textInsert text at a character indexB

Insert text at a specific character index in a Beat document (indexes come from beat_get_outline/beat_get_scenes).

Inputs: text (required), index (required), docIndex.

beat_inspect_documents[Debug] Dump raw document objectsA

Debug helper: dumps whatever fields the installed Beat version exposes on its document objects. Only needed if beat_list_documents titles/paths look wrong.

Inputs: no named parameters.

beat_list_documentsList open Beat documentsA

List every screenplay currently open in Beat, with the docIndex to use for other tools.

Inputs: no named parameters.

beat_pingCheck Beat connectionA

Check whether Beat is running and reachable, and list its open documents. Call this first.

Inputs: no named parameters.

beat_replace_sceneRewrite one sceneA

Replace a single scene's text in place (heading through the line before the next scene), identified by sceneIndex from beat_get_scenes. The rest of the script is untouched.

Inputs: text (required), sceneIndex (required), docIndex.

beat_set_textRewrite the whole screenplayA

Replace the ENTIRE text of a Beat document with new Fountain text. Use this for full rewrites; prefer beat_replace_scene for targeted edits so you don't disturb the rest of the script.

Inputs: text (required), docIndex.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 11 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes: read vs write, whole-document vs single-scene. The overlap between beat_get_outline and beat_get_scenes (both return sceneIndex) is real but descriptions clarify the difference (outline includes sections/synopses). beat_ping and beat_list_documents both list open documents, but ping is framed as an initial health check.

    Naming Consistency4/5

    The beat_ prefix is applied uniformly and the verb_noun pattern dominates (replace_scene, insert_text, get_outline, set_text). Minor deviations: beat_ping lacks a noun, and the get_/list_ mix for retrieval is slightly inconsistent but follows a conventional distinction.

    Tool Count5/5

    11 tools is well-scoped for a screenplay bridge: 6 read/inspection tools and 5 write/edit tools cover the domain without redundancy or bloat. Each tool earns its place for the stated purpose of interacting with Beat documents.

    Completeness4/5

    The surface covers the full text lifecycle: read (full, outline, scenes, single scene) and write (full replace, scene replace, insert, append). Notable gaps are the lack of an explicit scene deletion tool (workable via replace with empty text) and no document lifecycle operations, but these appear outside the bridge's scope.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML, covering cut detection, silence removal, markers from transcripts and beats, role assignment, rough cuts, keyframes and speed ramps, cross-NLE export, and pushes straight into a running Final Cut Pro. Every write is journaled with its SHA-256 and can be undone, so edits stay non-destructive and reviewable.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML — trimming and splitting clips, removing silence, placing markers from transcripts or beats, assigning roles, building rough cuts, and inspecting timeline health. Writes are journaled and reversible, and finished edits can be exported to other NLEs or pushed directly into a running Final Cut Pro.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML, including cut detection, marker placement, role assignment, silence removal, transcript- and beat-based editing, rough cuts, keyframes, speed ramps, and cross-NLE export. Every write is journaled with its SHA-256 and can be undone, and edits can be pushed directly into a running Final Cut Pro without a manual re-import.
      -