Skip to main content
Glama
Dorico Maestro

Dorico Maestro

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Compose together inside Steinberg Dorico. Always connect_to_dorico() first. Reads are selection-only, use get_status for state. 'kOK' means accepted, not necessarily effective: verify. Discover the full command set via the dorico://commands resource, run anything with run_command. See docs/protocol.md.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}
experimental
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
connect_to_doricoA

Connect to Dorico Remote Control and return application status.

Call this before anything else here: every other tool that talks to Dorico
needs the session this opens. It is safe to call again on an open connection.

Returns:
    Result dictionary with the connection outcome and the first status snapshot.

Note:
    On the first connection Dorico shows an authorization prompt inside the
    application, and nothing proceeds until a person accepts it. The token is
    then kept on disk (session_token_path in the answer) and later runs connect
    without asking. A token Dorico no longer knows, because the client was
    removed in its Remote preferences, is deleted after a short wait and the
    prompt appears again. On Windows with an MSIX-packaged client the token
    really lives under %LOCALAPPDATA%\Packages\<app>\LocalCache\Roaming.

    Use get_status afterwards to re-read the state without reconnecting.
get_statusA

Return Dorico's current pushed application status snapshot.

The state of the application rather than of the music: which mode is active,
whether note input is running, whether anything is selected, whether an undo is
available.

Returns:
    Result dictionary carrying the merged status snapshot.

Note:
    Dorico pushes status as deltas and this is the accumulated snapshot of them,
    so it costs nothing to read and needs no command to be sent.

    This is also how to check whether a command that answered kOK actually took
    effect, since kOK only says the UI queue accepted it (docs/protocol.md,
    'Command Acceptance vs Effect'). For the properties of the selected notes
    rather than the state of the application, use read_selection.
read_selectionA

Read rhythmic and notation properties of the active selection.

Reports duration, dots, articulations, accidental and event type for whatever a
person has selected in Dorico. Nothing here can change the selection, so make it
in Dorico or move the caret with goto_bar first.

Returns:
    Result dictionary with has_selection, and the properties when it is true.
    An empty selection answers has_selection=False rather than an error.

Note:
    Pitch and bar or beat position are not exposed by Dorico's Remote API, so
    they are absent here and no amount of selecting will produce them. To read
    pitches, export the flow with export_musicxml and read it with read_score,
    or read a saved project with read_project_info.
add_notesA

Input notes at the caret.

After ``goto_bar`` note input is running: the notes land where it stopped,
note input stays on, and the next call continues after them. Without a
running note input this enters it at the selection (or the viewport) and
leaves it afterwards. For a longer passage, ``write_score`` with a ScoreSpec
positions each staff itself (a chord is one event with >=2 pitches).

Returns:
    Result dictionary with the notes and duration entered, the note input mode
    they landed in, whether an undo is available, and displaces_existing.

Note:
    Read displaces_existing before treating this as an addition. Dorico has an
    overwrite note input mode, and in it these notes replace the music already
    at the caret instead of pushing it along. The mode belongs to the
    application rather than to this call, so it is reported back and not chosen
    here. get_status reads it beforehand.

    Uses :class:`NoteInputSession`: note input it opened is exited even on
    error, and note input that was already running is left on. Success
    indicates command acceptance (kOK). Verify note placement via
    get_status, playback, or score inspection. Do not read can_undo as
    that verification: entering note input alone already sets it.
add_restA

Input one rest at the caret.

One rest at the current caret position, which then advances by that duration.
It switches rest input on, presses the rest key and switches rest input off
again, so rest mode is left as it was found. After ``goto_bar`` note input
stays on and the next call continues; otherwise it is entered and exited here.

Returns:
    Result dictionary with success, the duration entered, the undo flag and the
    resulting mode.

Note:
    Success means Dorico accepted the command (kOK), not that the rest is where
    it was wanted (docs/protocol.md, 'Command Acceptance vs Effect'). Check with
    get_status or by inspecting the score.

    For a passage, put rest events in a ScoreSpec and use write_score. Use
    goto_bar first to choose where a single rest lands.
    Do not read can_undo as evidence: entering note input alone already sets it.
transposeA

Transpose currently selected notes up or down in the score.

Directly modifies the score by altering the pitches of the current selection
in place. Relative and repeatable: calling it twice moves the selection twice
as far, with no absolute target pitch.

Returns:
    Result dictionary with the command outcome and the catalog row
    registry_status.

Note:
    When to use: Shift existing selected notes by semitone, diatonic step,
    or octave intervals.
    When NOT to use: Do not use to enter new music (use write_score or
    add_notes). Do not use to change key signatures (use set_key_signature).

    Operates strictly on the active selection (reads are selection-only). If
    nothing is selected, Dorico ignores the command and no notes are modified;
    make a selection first or place the caret via goto_bar.

    Parameters: direction sets shift orientation ('up'/'down'). chromatic
    shifts by exact semitone when True or diatonically when False. octave=True
    overrides chromatic and shifts by a full octave.

    Maps to NoteEdit.Pitch{Up,Down}[Chromatic|Octave]. Read registry_status in
    the returned result and verify the change in the score or via playback.
set_time_signatureA

Report that a time signature cannot be set here, and what to use instead.

This writes nothing and always reports failure, which is the honest answer
rather than a silent no-op: Dorico takes a time signature only through an
interactive popover, and the Remote API cannot type into one.

Returns:
    Result dictionary explaining the limitation and naming the alternatives.

Note:
    Two ways round it. For a person at the keyboard, open_popover(kind='time')
    opens the popover for them to type into. For an unattended write, put the
    time signature in a ScoreSpec and use write_score(method='musicxml') or
    export_musicxml, both of which set it through the file rather than the UI.
set_key_signatureA

Report that a key signature cannot be set here, and what to use instead.

This writes nothing and always reports failure, for the same reason as
set_time_signature: Dorico takes a key signature only through an interactive
popover, and the Remote API cannot type into one.

Returns:
    Result dictionary explaining the limitation and naming the alternatives.

Note:
    For a person at the keyboard, open_popover(kind='key') opens the popover for
    them to type into. For an unattended write, put the key in a ScoreSpec and
    use write_score(method='musicxml') or export_musicxml, which set it through
    the file rather than the UI.
navigateA

Scroll the score viewport to the start or end of the flow.

Moves what is on screen through View.MoveViewportTo*, and nothing else: the
caret stays where it was and no music changes.

Returns:
    Result dictionary reporting the scroll, or the redirect for target='bar'.

Note:
    Use goto_bar instead to put the caret somewhere, which is what note entry
    needs. This tool would scroll past the bar and leave the caret behind. A
    target of 'bar' says so rather than doing half the job.
switch_modeA

Switch which of Dorico's five workspace modes is on screen.

Changes the window and nothing in the music: no notes, no playback position and
no selection move as a result.

Returns:
    Result dictionary reporting whether the switch was accepted.

Note:
    Note entry needs write mode, so switch there before add_notes, add_rest,
    goto_bar or write_score if the project might be in another one. get_status
    reports which mode is active without changing it.

    This is not navigation. To scroll the score use navigate, and to move the
    caret use goto_bar.
playbackA

Start, stop or rewind Dorico playback.

Transport only: no note, dynamic or layout changes as a result.

Returns:
    Result dictionary reporting whether the transport command was accepted.

Note:
    Playback is the one way to hear whether a write landed, since kOK proves
    only that the command was accepted (docs/protocol.md, 'Command Acceptance
    vs Effect'). It makes sound, which matters if a person is in the room.

    Use navigate to scroll the score without playing, and goto_bar to move the
    caret. Neither of those moves the playhead.
saveA

Save the open project over its file and wait until the file is complete.

Returns:
    Result dictionary with ``file`` (path, bytes, ``complete``) once Dorico has
    finished writing and the file reads as a whole zip.

Note:
    Dorico answers kOK before it writes: a 22 MB project was measured still being
    written seconds later, and a copy taken then was a broken zip. So this waits
    for Dorico's own finishing line in its application log, takes the path from
    the log, and tests the zip. ``Notify=true`` sends no completion message
    (Dorico Elements 6.2.40).

    A project that has never been saved opens a Save As dialog here; use
    project_file(action='save_as') for that. This overwrites the .dorico file in
    place, and Dorico may also copy the previous version into its backup folder.
project_fileA

Open, save as, close or revert a Dorico project, and report when it is done.

Returns:
    Result dictionary with the command, whether Dorico finished it, and for
    save_as the written file, for open the flows of the project now active.

Note:
    Measured in Dorico Elements 6.2.40: save_as writes without a dialog and the
    open project becomes the new file; close with an ``openScoreID`` closes
    without a dialog. Revert asks for confirmation in a dialog that a person must
    answer in Dorico, and afterwards the project has a new ``openScoreID``.
    After a close, Dorico answers queries with ``kNoScore`` until a person
    focuses another project window.

    Closing without saving and reverting discard work, so both need
    ``confirm=True``. Opening a native project file was seen in Dorico's log
    but not yet measured over the API.
playback_stateA

Report whether the project can play, and which expression maps are in use.

Returns:
    Result dictionary with ``activated_for_playback``, ``in_playback``, the
    edition, the expression maps in the project's library (id and name), and
    the maps used by the selected instruments when something is selected.

Note:
    A project that is not activated for playback plays nothing, and Dorico's
    routing menus do nothing until it is: call activate_playback first.

    The Remote API has no query for VST slots, loaded plugins or channel
    routing, so they are not here. ``selection_expression_maps`` comes from
    ``getplaybacktechniques`` and is empty without a selection; select an
    instrument's music first to read its map (Dorico Elements 6.2.40).
activate_playbackA

Activate the open project for playback, leaving an active project as it is.

Returns:
    Result dictionary with ``activated_for_playback`` read back afterwards.

Note:
    ``Play.ActivateProject`` toggles: sent to a project that is already active it
    deactivates it (Dorico Elements 6.2.40). This reads the state first and sends
    the command only when the project is not active.
list_pluginsA

List the VST3 plugins Dorico's audio engine knows, with the id loading needs.

Returns:
    Result dictionary with ``plugins`` (name, vendor, class_id, categories) and
    the cache file they were read from.

Note:
    Read from the audio engine's VST3 cache file, not from Dorico, so a plugin
    installed after the engine last scanned is missing until Dorico restarts.
playback_setupA

Change VST slots, an instrument's routing, or an expression map.

Returns:
    Result dictionary with the command sent, whether Dorico finished it, and
    whether a playback change was signalled; ``route`` also reports the
    endpoint and, where Dorico logs it, a verified MIDI thru change.

Note:
    Measured in Dorico Elements 6.2.40 on a test project. The project must be
    activated for playback, or a load is refused with ``kCommandNotAllowed``.
    Endpoint = 1024 × (slot − 1) + channel − 1, so slot 2 channel 1 is 1024; a slot
    that was replaced can leave instruments elsewhere, which read_playback_setup shows.

    Loading into a slot that holds a plugin replaces it, and the instruments
    routed to it lose their routing silently: route them again. Dorico logs
    "slot is already occupied by the same plugin" even for a load that worked,
    so that line is no failure signal. Removing a slot needs ``confirm=True``.

    ``apply_template`` rebuilds the whole setup from a playback template: it
    reloads the template's sounds and resets routing and expression maps, so it
    needs ``confirm=True``.

    An instrument id that does not exist is answered with kOK and changes
    nothing; read_playback_setup lists the ids of a saved project. ``verified`` is
    True only when Dorico's log shows the MIDI thru endpoint moving, which happens
    for the instrument Dorico monitors; otherwise it is None, not False.
manage_flowsA

List, add, rename or delete flows of the open project by id.

Returns:
    Result dictionary with ``flows`` (flowID and flowName) read back after the
    change.

Note:
    Measured in Dorico Elements 6.2.40: renaming and deleting are refused in
    Write mode (``kCommandNotAllowed``), so this switches to Setup mode and back.
    Deleting opens a confirmation dialog that a person must answer in Dorico;
    this waits up to ``wait_seconds`` for the flow to disappear and says so when
    it has not. Deleting needs ``confirm=True``. Use it to remove the extra flow
    a MusicXML import adds.
rename_playerA

Rename a player by id.

Returns:
    Result dictionary with the command and whether Dorico finished it.

Note:
    Refused in Write mode, so this switches to Setup mode and back (Dorico
    Elements 6.2.40). No query lists players; their ids come from a saved project
    through read_playback_setup. Deleting a player by id is not possible: Dorico's
    command acts on the selection in Setup mode.
add_markingA

Write a dynamic or a tempo at a bar, staff and beat, without the popover.

Returns:
    Result dictionary with the command sent and ``verified`` when Dorico
    selected a newly created event of the expected type.

Note:
    Places the caret the way goto_bar does, then sends the popover's command
    with the text as ``Definition``: Dorico creates the item directly and
    selects it (Dorico Elements 6.2.40, dynamic measured and checked in an
    exported PDF). Mind the pickup flag: without it a flow that opens with a
    pickup gets the marking one bar early. Note input is left afterwards.
export_pdfA

Export the score to PDF unattended without opening a dialog.

Writes the file next to the .dorico project, named after the layout. This is the
unattended path. File.Export opens a modal dialog and is not usable from here.

Returns:
    Result dictionary reporting whether the command was accepted.

Note:
    Receiving kOK does not prove a file exists yet. Dorico runs commands on its
    UI thread, so a request sent while a modal dialog is open waits in the queue
    until the dialog closes. Tested against Dorico Elements 6.2.30. Check the
    expected path on disk rather than trusting the return.

    The all_layouts path is catalogued as untested, unlike the current-layout
    path which is verified, so treat a multi-layout export as unproven and check
    what actually landed. For an interchange format rather than a printable one,
    use export_musicxml.
goto_barA

Move the caret to a bar and return the assumed position.

The position is assumed, not read. Dorico exposes no caret coordinates over the
Remote API, so this dead-reckons: it enters note input, rewinds to bar 1 of the
top staff, then steps forward to the bar, staff and beat asked for.

Returns:
    Result dictionary with the assumed caret position and the caveat attached.

Note:
    Because it counts rather than measures, the answer drifts from the truth if
    anything moved the caret in between, and it cannot detect that. Treat it as
    the position it aimed for, and confirm what was written with read_selection
    or by inspecting the score.

    This enters note input, so it is the call to make before add_notes or
    add_rest. To scroll the view without touching the caret, use navigate.

    Ask whether the flow opens with a pickup bar before relying on a bar
    number, because Dorico leaves a pickup out of the count and this lands one
    bar short without the pickup flag. The API cannot tell, so the person with
    the score on screen has to say, or read an exported MusicXML with
    read_score.

    The move costs the same handful of commands at any flow length, so a long
    flow is no less exact than a short one.
open_popoverA

Open an input popover at the caret for manual text entry.

Opens the popover and stops there. Dorico's Remote API cannot populate popovers
directly, so this positions the caret if requested, triggers the
NoteInput.Create* command, and returns the required input format.

Returns:
    Result dictionary with the popover kind, caret location, and typing
    instructions.

Note:
    Requires user interaction in Dorico. Opening a popover leaves it waiting
    for keyboard input. Treat anything sent while it waits as unsafe: a modal
    dialog leaves later commands accepted but unexecuted (docs/protocol.md,
    'Modal Dialog Detection'), and a waiting popover has not been measured to
    behave any better.

    For an unattended write, put the marking in a ScoreSpec and use write_score:
    dynamics and clefs are ScoreSpec fields, and a key or time signature goes in
    through write_score(method='musicxml').
run_commandA

Dispatch any catalogued Dorico command by ID, with optional parameters.

The escape hatch, reaching the whole catalogued command set rather than the
handful of tools here. What it can send is bounded by the catalog.

Returns:
    Result dictionary with the command outcome and the catalog row status, which
    says how well that command is actually established.

Note:
    Read the registry_status in the answer before trusting the result: a row may
    be verified, reachable, unavailable, broken or untested, and only verified
    has been seen to work. Combined with kOK meaning acceptance rather than
    effect (docs/protocol.md), a clean return from an untested row is weak
    evidence. Check with get_status or by inspecting the score.

    Prefer a dedicated tool where one exists: write_score, transpose,
    switch_mode, playback and save all add validation or verification this does
    not. Use search_commands to find a command ID and what it takes.
score_schemaA

Return the ScoreSpec input format write_score/render_to_dorico expect.

Call this instead of guessing or reading source. Unknown keys are rejected by
the parser rather than ignored, so the shape has to match exactly.

Returns:
    Result dictionary with a copyable minimal example in both the flat and the
    nested form, the allowed enum values (durations, articulations, dynamics,
    clefs) and the indexing rules.
write_scoreA

Render a ScoreSpec into Dorico by caret entry or MusicXML import.

The main way to write music here, and the one to reach for whenever there is
more than a single beat to enter: add_notes and add_rest do not chain, because
each re-enters note input at the caret and stacks on the same beat.

Returns:
    Result dictionary with the execution report, the preflight warnings, and the
    caveats attached to what was dispatched.

Note:
    Choose the method by what the score needs. 'caret' adds to the current flow
    and leaves the rest of the project alone, but it cannot set a key or time
    signature, because those go in through a popover no API can type into.
    'musicxml' carries them, at the price of arriving as a new flow rather than
    joining the current one.

    Call score_schema first for the exact shape: unknown keys are refused rather
    than ignored. Dorico must be in write mode, so use switch_mode if unsure.
    Nothing is verified by the return, since kOK means accepted rather than
    effective (docs/protocol.md), so check the result in the score.

    The caret path repositions between staves by jumping to the start of the
    flow, so it needs to know nothing about the flow's meter or length.
render_to_doricoA

Render a ScoreSpec through the caret path, or plan it without sending.

The lower half of write_score, exposed on its own for the two cases where that
matters: seeing the command plan before it runs, and skipping the preflight
checks and the MusicXML option that write_score adds on top.

Returns:
    Result dictionary with the command plan when dry_run is true, or the
    execution outcome when it is false.

Note:
    Prefer write_score for ordinary composition: it runs the range and voice
    leading checks first and can take the MusicXML path when a key or time
    signature is needed. Come here to inspect what would be sent, or when the
    caret path is specifically what is wanted.

    With dry_run true this is a read: nothing is dispatched and Dorico need not
    even be running.
export_musicxmlA

Write a ScoreSpec to a MusicXML file on disk, without Dorico.

Entirely offline: no connection is opened and Dorico need not be running. Key,
time signature, clefs, dynamics and tempo all survive the round trip, which is
what makes this the way to set the two signatures no popover will accept.

Returns:
    Result dictionary with the outcome and the path that was written.

Note:
    A specified path is overwritten without confirmation. Omit the path to
    write to a temporary file.

    To get the file into Dorico afterwards, import_musicxml opens it as a new
    flow, and write_score(method='musicxml') does both steps in one call. For a
    printable file rather than an interchange one, use export_pdf.
read_project_infoA

Read metadata, flows, and player rosters from a saved .dorico file.

Opens the project as the ZIP archive it is and reads the document and per-flow
metadata out of it. Entirely offline: Dorico need not be running, and this works
on a project nobody has open.

Returns:
    Result dictionary with the document metadata, the flows, and the players.

Note:
    This reads the project wrapper, not the music: for notes and rhythms, export
    with export_musicxml and read that with read_score. For the project open in
    Dorico right now, get_status reports its state and read_selection its
    selection.
read_playback_setupA

Read a saved project's VST slots, routing and expression maps, and check them.

Returns:
    Result dictionary with ``slots`` (Dorico's rack beside what the audio engine
    hosts), ``instruments`` (player, ``instrument_id`` and routes) and ``problems``.

Note:
    Offline and read-only; for the open project, save first. ``instrument_id`` is
    the id playback_setup(action='route') needs. A problem such as "Dorico lists
    a sampler, the audio engine hosts HALion Sonic" means the slot will not sound as
    shown, which pushed status cannot reveal (Dorico Elements 6.2.40).
plugin_stateA

Export or replace the saved state of a VST instrument slot in a closed project.

Returns:
    Result dictionary with the slot, the preset file and, for import, the backup.

Note:
    Sets what a plugin holds (programs, instruments on channels) without its
    window, which no assistant can operate. Import refuses a preset made for
    another plugin and a project Dorico has open, writes a backup next to the
    project first and tests the rewritten file. It needs ``confirm=True``. Whether
    the project is open comes from Dorico's application log; without one the import
    is refused unless ``dorico_closed=True``.
read_scoreA

Read an existing MusicXML file measure by measure using music21.

Entirely offline and read-only. This is the way to see pitches, which Dorico
itself will not report over the Remote API.

Returns:
    Structured dictionary with the metadata, parts, measures and note events.

Note:
    Use the bars filter rather than reading everything when the question is
    local: a full read of a long score returns every note of every part.

    To see the music currently in Dorico, export it with export_musicxml first
    and read that. read_project_info reads a .dorico project wrapper instead,
    and read_selection reports the live selection without pitches.
read_open_scoreA

Read the whole open score back by way of a MusicXML export.

The only route to the full contents of the score that is open. Reads over the
Remote API see the selection alone, so everything else here works blind. This
is what makes bar count, key, time signature and above all a pickup bar
knowable instead of guessed.

Returns:
    Result dictionary with the parsed summary, the pickup finding, the last
    bar number, and the file that was read.

Note:
    Dorico's MusicXML export filter opens a modal dialog that requires user
    confirmation. This tool triggers the export dialog and awaits the resulting
    file in export_dir. Point the export dialog to export_dir once in Dorico to
    enable one-key export confirmations on subsequent reads.

    The result is a snapshot of the score at export time. Re-export after
    edits to refresh score state.
import_musicxmlA

Import a MusicXML file into Dorico via the Remote Control API.

Dispatches File.Open with MusicXMLImportFilter.

Returns:
    Result dictionary with success, supported, attempted,
    requires_confirmation, code, path and note.

Note:
    An import arrives as a new flow rather than joining the one on screen, and
    Dorico may raise a player assignment prompt that waits for a person. While
    that prompt is open, later commands are accepted but sit unexecuted in the
    queue (docs/protocol.md, "Modal Dialogs").

    To add music into the flow already open, use write_score(method="caret").
    Use export_musicxml to produce the file in the first place, or
    write_score(method="musicxml") to do both steps in one call.
analyze_harmonyA

Estimate the key of a ScoreSpec and name its chords in Roman numerals.

Entirely offline: the score is analysed as data and Dorico is not involved, so
this works on music that has never been in a project.

Returns:
    Result dictionary with the key estimate, its confidence, and a Roman numeral
    reading of each sonority.

Note:
    Key estimation relies on pitch distribution. For short or highly chromatic
    excerpts, verify the estimated tonal center before relying on Roman numerals.

    This answers what the harmony is. For whether the voices move well between
    those chords use check_voice_leading, for strict two-part exercises
    check_counterpoint, and for what could come next suggest_next_chord.
check_voice_leadingA

Audit a ScoreSpec for parallel fifths and octaves, overlaps and spacing.

Entirely offline and read-only: nothing in the score is changed and Dorico is
not involved. Written for part-writing of any number of voices, so a chorale or
a string quartet is the natural input.

Returns:
    Result dictionary with one entry per issue found, each naming the rule, the
    voices involved and where it happens. An empty list means nothing was found.

Note:
    These are the common-practice rules, so a passage that breaks them on purpose
    is reported too. The findings are advice and nothing here rewrites the music.

    For a strict two-part species exercise, check_counterpoint applies the
    stricter set of rules that belongs to it. For what the chords are rather than
    how the voices move between them, use analyze_harmony.
suggest_next_chordA

Suggest functional continuations for a Roman numeral progression.

Entirely offline and read-only: this reasons about numerals as symbols and never
touches a score or Dorico.

Returns:
    Result dictionary with the candidate next chords, each carrying its harmonic
    function and why it follows.

Note:
    Suggestions come from common-practice function, so they describe what usually
    follows rather than what must. Nothing is written anywhere. To hear a
    candidate, put it in a ScoreSpec and use write_score.

    This takes numerals, not notes. To get numerals out of actual music, run
    analyze_harmony first and feed its reading in here.
instrument_rangeA

Look up a standard instrument compass, or test one pitch against it.

Two questions through one door: without a pitch it reports the range, with one it
reports whether that note is inside it. Entirely offline and read-only.

Returns:
    Result dictionary with in_range when a pitch was given, or the lowest and
    highest playable pitches when it was not.

Note:
    These are the standard written ranges for a competent player, not the limits
    of the instrument or of a particular one: professionals exceed them and
    beginners do not reach them.

    Worth calling before write_score when writing for an instrument, since
    write_score with preflight left on runs the same check over a whole score and
    reports what falls outside.
check_counterpointA

Check a two-part first-species counterpoint against the classic rules.

Entirely offline and read-only. Enforces the strict set: begin and end on a
perfect consonance, consonant verticals only, no consecutive perfect fifths,
octaves or unisons, no voice crossing, and one melodic climax in the
counterpoint.

Returns:
    Result dictionary with one entry per issue, each naming the rule and the beat
    it happens on. An empty list means the exercise passes.

Note:
    Only first species is implemented, so passing any other species is refused
    rather than checked loosely. The two lines must be the same length, since
    note against note pairs them one to one.

    These rules are stricter than ordinary part-writing on purpose. For a
    chorale or a quartet use check_voice_leading, which applies the
    common-practice rules to any number of voices.
search_commandsA

Search the Dorico command catalog by query, category, or status.

Entirely offline: the catalog ships with this server, so nothing is asked of
Dorico and it need not be running.

Returns:
    Result dictionary with the total number of matches, a count per status, and
    the matching commands with their IDs, parameters and documentation.

Note:
    This is how to find a command ID and what it takes before sending it with
    run_command, and how to see the status that tells you how far to trust it.
    Only 'verified' rows have been observed to work.

    Prefer a dedicated tool where one exists: much of what the catalog can reach
    is already covered by write_score, transpose, playback, save and the rest,
    with validation run_command does not perform.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription
commands_catalogReturn the complete Dorico command catalog formatted as JSON. Exposes all 369 commands with metadata, parameter signatures, and verification status without requiring individual tool declarations.

TDQS

A3.9/5.0

Scored across 40 tools

Disambiguation4/5

Most tools target a clearly distinct action (connect, get_status, read_selection, transpose, save, export_pdf, analyze_harmony) and the descriptions actively cross-reference alternatives, which is unusually strong disambiguation. However, render_to_dorico is explicitly described as 'the lower half of write_score', add_notes/add_rest/write_score overlap on note entry, and set_time_signature/set_key_signature are deliberate no-op stubs that duplicate advice given by open_popover and write_score. The read family (get_status, read_selection, read_score, read_open_score, read_project_info) is large but well-differentiated by scope.

Naming Consistency3/5

Naming is uniformly snake_case and readable, and many tools follow verb_noun (get_status, read_selection, write_score, add_notes, export_pdf, import_musicxml, check_voice_leading). But there are many bare nouns and single words (transpose, save, playback, navigate, project_file, playback_state, playback_setup, plugin_state, score_schema, instrument_range) mixed in, so the verb_noun pattern is not predictable across the set.

Tool Count2/5

40 tools is well past the point where an agent can hold the surface in view, spanning Dorico control, offline music theory, VST/playback configuration, MusicXML conversion and a command-catalog escape hatch. Each tool is individually justified, but several are narrow conveniences (rename_player, activate_playback, plugin_state, set_time_signature stubs) that inflate the set. The scope is genuinely broad, yet the count is heavy enough to slow tool selection.

Completeness4/5

Coverage is broad and lifecycle-complete for the main workflows: connect, status/selection reads, note entry, score writing, export/import, save/project file, flows, playback and setup, plus offline analysis and a catalog escape hatch for anything missing. Real gaps exist (pitch and caret position unavailable via the API, key/time signatures not settable directly, no player deletion), but each is documented with a concrete workaround rather than left as a dead end.

Maintenance

ActivityNo data
ResponsivenessOutdated data