Skip to main content
Glama
Cyan Eclipse Cadence MCP

Cyan Eclipse Cadence MCP

Official

Cyan Eclipse Cadence MCP

Free and open source under the MIT License. Cyan Eclipse Cadence MCP is a local stdio Model Context Protocol server for inspecting Cadence performance scripts, the voice catalogue stored in a Cadence checkout, stored render and acceptance records, and the server's hash-chained call receipts. It also records render proposals. It works with any MCP-compatible host; no account, API key, credential, or paid service is required.

The MCP surface is deliberately non-executing: it has no render-start or render-apply tool, invokes no speech-synthesis engine, makes no network calls, and cannot spend money or third-party synthesis credits. A proposal is only a local JSON record for later review.

Run the MCP server

Requirements: Python 3.10 or newer and this repository. The server uses only the Python standard library.

git clone https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/cyan-eclipse-cadence.git
cd cyan-eclipse-cadence
python3 server.py

Generic MCP host configuration:

{
  "mcpServers": {
    "cyan-eclipse-cadence": {
      "command": "python3",
      "args": ["/absolute/path/to/cyan-eclipse-cadence/server.py"],
      "env": {
        "CADENCE_MCP_STATE_DIR": "/absolute/path/to/writable/cadence-state"
      }
    }
  }
}

CADENCE_MCP_STATE_DIR is recommended because successful calls append content-minimal hash receipts and proposals are written as JSON files. Set CADENCE_MCP_HOME to another Cadence checkout when the server should inspect that checkout's stored scripts and acceptance records instead of its own.

Related MCP server: dsh-schema-migration-proof

MCP tools

Tool

Purpose

cadence_scripts_list

Discover stored scripts and their hashes and segment counts

cadence_scripts_read

Read one script and compile its performance score

cadence_voices_list

Read the voice catalogue stored in the checkout

cadence_renders_list

List stored render and acceptance records

cadence_renders_read

Read one stored render or acceptance record in full

cadence_receipts_verify

Recompute and verify the facade receipt hash chain

cadence_render_propose

Write a local, non-executing render proposal

The repository includes a sample script and acceptance record so the tools can be tried immediately. The server's reads are computed from the checkout's own Cadence compiler, synthesis-adapter constants, and acceptance files rather than from a second copied dataset.

What Cadence is

Cadence performs rhetorical performance compilation with an acoustic acceptance gate: it compiles a reel script the way a compiler compiles code — parsing the script into rhetorical acts (hook · evidence · turn · payoff) and breath-groups, then compiling each span into a performance score using a versioned, inspectable rule set derived from Cyan Eclipse Technologies LLC's library corpus (each of the 14 rules in rules/rules-v1.yaml names its treatise, author, year and chapter). The score carries, per span: one peak word with a graded stress tier, a contour class assigned by clause function (antithesis mirroring, series penultimate rise, question contours), a pause class with a situation-set duration from a three-class taxonomy (the flat 0.120 s join of the legacy pipeline appears nowhere), a register per act, a per-act tempo bounded to ±12%, and the Delsarte inverse-intensity rule at climax (quieter, not louder).

MCP server scope

  • Rule set v1 as cited YAML (rules/rules-v1.yaml, 14 rules, R1–R14).

  • Performance compiler for the house segment script format (## SCRIPT section, [Sn] segments, optional persona header).

  • Stored render and acceptance-record inspection.

  • Hash-chained, content-minimal receipts for successful facade calls.

  • Local render proposals that start and apply nothing.

  • Stdlib-only Python; stdlib unittest test suites.

Not exposed by the MCP server

  • Speech synthesis or any render execution.

  • Voice selection or voice changes.

  • Network calls, accounts, credentials, or paid services.

  • Automatic script rewriting (the compiler flags; a human rewrites).

  • Any UI beyond the MCP server, CLI, and score JSON.

CLI usage

python3 -m cadence compile <script.md> --out <score.json>
python3 -m unittest discover -s tests

Score JSON contract:

{
  "script_id": "ep18-script",
  "source_sha256": "<sha256 of the source script file>",
  "persona": {"speaker": "...", "to": "...", "want": "..."},
  "rule_set": "rules-v1",
  "spans": [
    {
      "span_id": "sp001",
      "segment": "S1",
      "act": "hook",
      "text_raw": "...",
      "text_encoded": "...",
      "peak": {"word": "...", "tier": 1},
      "contour": "fall",
      "pause_after": {"class": "act-boundary", "seconds": 0.9},
      "tempo": 1.0,
      "register": "medium",
      "intensity": "normal"
    }
  ]
}

persona is null when the script carries no persona header line (> Persona: speaker | to | want). Span = one breath-group. act ∈ hook|evidence|turn|payoff · contour ∈ fall|rise|hold-rise|fall-rise|level · pause class ∈ breath|emphasis|act-boundary|none · tempo ∈ [0.88, 1.12] · intensity ∈ normal|reduced|climax-quiet.

Available Tools

7 tools
cadence_receipts_verifyVerify the Cadence facade receipt chainA

Recompute this MCP facade's hash-chained call receipts and report whether the chain verifies, the first diverging sequence when it does not, the receipt count checked, and the chain head. Use to audit whether recorded facade calls remain internally consistent; use cadence_renders_read when the target is a stored render record rather than the facade receipt chain. Behaviour: the verdict describes the chain before this call's own successful-call receipt is appended; the server has no network, authentication, or credential surface, and verification changes no record other than that normal receipt append. Returns an object with ok, diverging_seq, count, head, receipt_id, and receipt_head.

Inputs: no named parameters. Returns: ok, head, count, receipt_id, +2 more

cadence_render_proposeRecord a non-executing Cadence render proposalA

Create a local render proposal for one stored script, returning proposal_id, script_id, the stored voice, the optional note, applied: false, started: false, state: proposed, and the disposition text. Use when a render should be recorded for later human or production-pipeline review; do not use it to produce audio, because no render-start or render-apply tool exists on this server. An unknown script_id returns an error. Behaviour: each successful call writes one new proposal JSON file in the facade state area and appends a content-minimal hash receipt; it makes no network call, uses no credentials, invokes no synthesis engine, and is not idempotent because repeated calls create separate proposals. Returns the proposal plus receipt_id and receipt_head.

Inputs: script_id (required), note. Returns: kind, note, state, voice, +7 more

cadence_renders_listList stored Cadence render recordsA

List Cadence's stored render and acceptance records with record_id, episode, take, voice, duration_s, state, and in_band_pct. Use this first to discover a valid record_id for cadence_renders_read. These are historical stored records, not live render status; this tool cannot start, retry, or inspect an in-progress synthesis. Behaviour: local file reads only, with no network, authentication, credentials, or audio playback; a successful call appends a content-minimal hash receipt. Returns an object with renders, receipt_id, and receipt_head, with null fields where a record does not carry a value.

Inputs: no named parameters. Returns: renders, receipt_id, receipt_head

cadence_renders_readRead one stored Cadence render recordA

Read one stored render or acceptance record in full by exact record_id, returning its episode, take, audio reference, voice, duration, basis, gate counts and percentage, state, source file, and stored receipt hash when the record is a sealed receipt. Use after cadence_renders_list when full evidence is needed; use cadence_receipts_verify for the facade's own call-receipt chain rather than a render record's stored receipt. An unknown record_id returns an error. Behaviour: local file read only; no synthesis, network, authentication, credentials, or external service; a successful call appends a content-minimal hash receipt. Returns the record plus receipt_id and receipt_head.

Inputs: record_id (required). Returns: take, audio, basis, state, +11 more

cadence_scripts_listList Cadence performance scriptsA

List the performance scripts stored in this Cadence checkout, with each script's identifier, repository-relative path, SHA-256 of its file bytes, and segment count. Use this first to discover a valid script_id for cadence_scripts_read or cadence_render_propose. This tool does not compile a score or start a render; use cadence_scripts_read when persona, segment text, and compiled-score evidence are needed. Behaviour: local stdio only, with no network, authentication, credentials, or external service; a successful call appends a content-minimal hash receipt (argument and result hashes only) to the facade receipt chain. Returns an object with scripts, receipt_id, and receipt_head.

Inputs: no named parameters. Returns: scripts, receipt_id, receipt_head

cadence_scripts_readRead and compile one Cadence scriptA

Read one stored performance script and compile its performance score with Cadence's own compiler, returning the script identifier, path, file SHA-256, persona when present, segment texts, segment count, rule set, compiled span count, and canonical score SHA-256. Use when the actual script and compiler evidence are needed; use cadence_scripts_list for discovery only and cadence_render_propose only to record a non-executing render proposal. An unknown identifier returns an error and creates no proposal. Behaviour: local and deterministic for unchanged files; no synthesis, network, authentication, or credential use; a successful call appends a content-minimal hash receipt. Returns the script object plus receipt_id and receipt_head.

Inputs: script_id (required). Returns: path, sha256, persona, rule_set, +7 more

cadence_voices_listList the stored Cadence voice catalogueA

List the voice catalogue exactly as stored in this Cadence checkout's synthesis-adapter constants, returning voice_id, engine, adapter, timeout_secs, and an explanatory note for each entry. Use to identify the stored voice before reading scripts or proposing a render; use cadence_renders_list to find which voice a stored render record used. This tool cannot add, select, change, or certify a voice and it does not synthesize audio. Behaviour: local stdio only, with no network, authentication, credentials, or external service; a successful call appends a content-minimal hash receipt. Returns an object with voices, receipt_id, and receipt_head.

Inputs: no named parameters. Returns: voices, receipt_id, receipt_head

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool targets a distinct resource+action pair (scripts list/read, renders list/read, voices list, receipts verify, render propose), and the descriptions explicitly cross-reference sibling tools to steer selection (e.g. renders_read vs receipts_verify, scripts_list vs scripts_read). No two tools can be plausibly confused for one another.

    Naming Consistency4/5

    All names follow a predictable cadence_<resource>_<verb> pattern with snake_case throughout. The only blemish is singular/plural drift on the same resource: cadence_render_propose versus cadence_renders_list and cadence_renders_read.

    Tool Count5/5

    Seven tools is well within the ideal 3-15 band and each one maps to a concrete operation on a small local domain. Nothing feels padded or redundant for a read-only audit/proposal facade.

    Completeness3/5

    Scripts and renders both have list+read pairs and receipts have verification, but proposals only have a create path — there is no way to list or re-read a proposal after creation, and no receipt listing. The absence of synthesis/start/apply tools is explicitly declared as out of scope, so the gap is moderate rather than severe.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Lets users inspect and verify content-addressed schema migration evidence offline, checking idempotence, reversible rollback, required invariants, and explicit lossy-field disclosure without executing migrations or accessing data.
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables autonomous agents to inspect and audit unfamiliar x402 endpoints before spending USDC, using bounded read-only probes to surface payment challenges, pricing, network, receiver, and operational signals without signing or spending funds.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Enables compatible AI coding agents to inspect authorized software artifacts, analyze JavaScript/TypeScript and native binaries, optionally perform Ghidra decompilation, and produce verifiable evidence-linked technical reports.
      11
      MIT