Skip to main content
Glama
ismail: agent DAW (MCP server)

ismail: agent DAW (MCP server)

Midi Read

midi_read

Reads a Standard MIDI File to list its tempo, meter, markers, tracks and channels, or imports its notes, pitch bend, controllers and MPE into a project's tracks.

Instructions

Read a Standard MIDI File (.mid, from a DAW, a score program or the web). Without into, it lists what the file holds: tempo and meter (and any changes), markers, and every track and channel with its note count, range and bars. With into={: } it writes those notes into existing tracks (track_add first), where is the track's name, '#', or 'ch<1-16>' (that channel across the file, e.g. 'ch10' for drums). bar: where the file's bar 1 lands. mode='replace' clears the span the notes cover on each target first, 'add' merges. quantize: a grid in beats (0.25 = 16ths) the starts snap to; default keeps them as played. Positions are read in beats, so a file at another tempo keeps its bars at this project's tempo (the reply says when the tempos differ). Pitch bend and controllers in the part become the target's expression lanes (automation inst.lane., which a performer voice plays): pitch bend -> bend (semitones, at the file's RPN 0 bend range, else +-2), cc:1 -> vib (0..50 cents), cc:11 -> level (-40..0 dB), cc:2 -> breath (0..1); the reply names the messages no lane took. lanes: the map as data, as midi_write takes it ({lane: {'midi': 'bend' | 'pressure' | 'cc:', 'range': [lo, hi]}}, {lane: None} skips one), e.g. {'mute': {'midi': 'cc:20', 'range': [0, 1]}}. An MPE part (the file configures MPE with RPN 6 in any track, lower or upper zone, sized as it says, or mpe=True, 'lower' or 'upper' for a file that does not say; mpe=False reads it as one plain part, every channel's messages into one lane) is read per note, in the configuration in force at its first note (the reply warns when it changes while the part plays), its zone's member channels only; a part on a zone's master channel or outside every zone is a plain part. Bend at +-48 unless the file says, and per-note pressure -> level; a lane follows the newest note still sounding, since ismail's lanes are per track. Poly pressure (one key's own) is read the same way, as its channel's pressure following the newest key still held, onto the lane that takes pressure (lanes={'level': {'midi': 'pressure', 'range': [-40, 0]}} on a plain part; a channel that sends channel pressure too keeps its own); the reply says so. Lanes replace the target's points over the span they cover; quantize moves notes only. Reach for it when the person brings a .mid (from their DAW, a score program or the web) to open, read or import into a song, its pitch bend, mod wheel, other controllers and MPE included. The listing names each track's GM program (1 to 128); into= writes notes and lanes, not programs (a track's sound is its instrument).

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "project": "<project>",
      "file": "<file>"
    },
    "name": "midi_read"
  }
}

Input Schema

NameRequiredDescriptionDefault
barNo
mpeNo
fileYes
intoNo
modeNoreplace
lanesNo
projectYes
quantizeNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv0.4.5
    • addedInput schema / properties / lanes
      Added value: +{
      +  "additionalProperties": true,
      +  "default": null,
      +  "type": "object"
      +}
    • addedInput schema / properties / mpe
      Added value: +{
      +  "default": null,
      +  "title": "Mpe"
      +}
  2. Addedv0.4.0

TDQS

A4/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the entire burden and does so thoroughly: mode='replace' clears the covered span, 'add' merges, lanes replace target points over their span while quantize moves notes only, into= writes notes and lanes but not GM programs, and the reply reports tempo mismatches, untaken messages, and MPE configuration changes mid-part. These are exactly the write-side effects and caveats an agent needs before calling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a long, minimally punctuated wall of text that mixes routing guidance, parameter semantics and MPE edge cases without headings or paragraph breaks. The most decision-relevant sentence ('Reach for it when...') is buried near the end rather than front-loaded, and tempo behavior is restated more than once. Much content is substantive, but the structure actively impedes scanning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex 8-parameter tool with nested objects and no schema descriptions, the definition covers the hard cases—MPE zoning, poly vs channel pressure, controller-to-lane mapping, span replacement—and an output schema exists so return values need not be spelled out. Coverage is strong, though the unexplained `project` parameter and the difficulty of parsing the MPE rules leave a small completeness gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must supply all meaning, and it does for most parameters: bar ('where the file's bar 1 lands'), mode (replace vs add), quantize ('a grid in beats, 0.25 = 16ths'), lanes (concrete map shape with an example), mpe ('lower'/'upper'/True/False), and into (target mapping with three track-reference forms). Only `project` is left unexplained, which is the main gap at 8 parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

It names a specific verb and resource ('Read a Standard MIDI File') and explicitly splits the two modes: listing contents without `into`, and writing notes into existing tracks with `into`. It also distinguishes itself from midi_write by describing the lanes map 'as midi_write takes it'. The density of MIDI jargon (RPN 6, MPE zones, poly pressure) makes the core purpose harder to grasp than it needs to be.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Near the end it gives an explicit trigger: 'Reach for it when the person brings a .mid ... to open, read or import into a song'. It also states the prerequisite that target tracks must exist ('track_add first'). What it lacks is a clear statement of when NOT to use it or a named alternative for adjacent needs, so it falls short of full when/when-not coverage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools