MCP MeasureMCP Measure

index observed

osc-bridge

OSC ↔ MIDI bridge for synthesizers and DAWs, with the SynthHub catalogue. A MIDI MCP and OSC MCP.

Should I use this

Quality & Safety

A
Description quality
99%
Schema completeness
94%
Naming quality
89%
Poisoning risk
60%
Permission match
100%
Protocol compliance
100%

Findings (4)

  • HIGHTool poisoning patterns detected
  • MEDIUMTool description contains URL to non-standard domainin submit_driver
  • MEDIUMTool description contains URL to non-standard domainin relay_status
  • LOWTool 'list_routes' description lacks action verbin list_routes

Based on automated analysis of tool definitions and protocol compliance.

Context Cost

~9,298Tokens (tool definitions)
~2.3 KBTypical response size
Significant attention impact (7.26% of 128k context)

This is the approximate number of tokens consumed each time the server's tools are loaded into a model's context. Higher counts reduce the attention available for other tasks.

Install

One-Click Install

Add this to your `claude_desktop_config.json` file:

{
  "mcpServers": {
    "osc-bridge": {
      "command": "npx",
      "args": [
        "@roomi-fields/osc-bridge"
      ]
    }
  }
}

Runnable packages

npm@roomi-fields/osc-bridge0.18.0stdio

Remote endpoints

https://mcp.osc-bridge.roomi-fields.com/mcpstreamable-http
https://mcp.synthhub.roomi-fields.com/mcpstreamable-http

What it can do

Tool inventory

Tools (29)

🟢 Read-only🟡 Write🔴 Delete⚪ Unknown
🟢list_devices(kind, limit, query, user_id, vendor)

Find device drivers in the catalogue of synths, drum machines, controllers and DAWs. Without arguments it lists them all; `query` keeps drivers whose vendor, name or slug contain every word (e.g. 'korg minilogue'). Returns name, vendor, OSC prefix (slug), kind, source tier and firmware version when the source states one. Pass the slug to list_routes for the full CC/NRPN/SysEx map.

Input Schema

{
  "type": "object",
  "properties": {
    "kind": {
      "enum": [
        "hardware",
        "software"
      ],
      "type": "string"
    },
    "limit": {
      "description": "Return at most this many drivers.",
      "minimum": 1,
      "type": "integer"
    },
    "query": {
      "description": "Words that must all appear in the vendor, name or slug (case-insensitive).",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    },
    "vendor": {
      "description": "Exact vendor name, case-insensitive (e.g. 'Moog').",
      "type": "string"
    }
  },
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "properties": {
    "count": {
      "description": "Number of matching drivers, before `limit`.",
      "type": "integer"
    },
    "devices": {
      "items": {
        "properties": {
          "file": {
            "type": "string"
          },
          "firmware": {
            "description": "Firmware the source documents; null when it does not say.",
            "type": [
              "string",
              "null"
            ]
          },
          "id": {
            "description": "Driver id (path in the catalogue), e.g. 'korg/minilogue'.",
            "type": "string"
          },
          "kind": {
            "description": "'hardware' or 'software'.",
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "revision": {
            "type": "string"
          },
          "slug": {
            "description": "OSC prefix without the leading slash.",
            "type": "string"
          },
          "source_tier": {
            "type": "string"
          },
          "usage_status": {
            "description": "Hosted server only: trust from usage reports (see get_trust).",
            "type": [
              "string",
              "null"
            ]
          },
          "vendor": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "vendor",
          "slug",
          "kind"
        ],
        "type": "object"
      },
      "type": "array"
    }
  },
  "required": [
    "count",
    "devices"
  ]
}
🟢get_device_docs(slug, user_id)

Fetch the markdown companion documentation for one device, if present. The slug is the device's OSC prefix without the leading slash (e.g. 'ableton' for /ableton).

Input Schema

{
  "type": "object",
  "properties": {
    "slug": {
      "description": "Device slug, e.g. 'ableton' or 'minilab3'",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "slug"
  ]
}

Output Schema

{
  "type": "object",
  "properties": {
    "has_docs": {
      "description": "False when no companion .md exists for the device.",
      "type": "boolean"
    },
    "markdown": {
      "description": "The companion documentation, or a not-found message when has_docs is false.",
      "type": "string"
    },
    "slug": {
      "type": "string"
    }
  },
  "required": [
    "slug",
    "has_docs",
    "markdown"
  ]
}
🟢list_routes(slug, user_id)

Return the OSC routes a device exposes: declarative commands (OSC paths it accepts), cc/nrpn params, sysex params, named note triggers (drum sounds), and reply patterns. Use this to discover what a device can do.

Input Schema

{
  "type": "object",
  "properties": {
    "slug": {
      "description": "Device slug, e.g. 'minilab3'",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "slug"
  ]
}

Output Schema

{
  "type": "object",
  "properties": {
    "cc_params": {
      "description": "CC / NRPN parameters, each mapped to an OSC address. Every entry carries an 'expects' field (continuous/switch/momentary/trigger/clock/discrete) describing the device-side nature of the control — informative only, the signal realization is the caller's concern.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "commands": {
      "description": "Declarative OSC paths the device accepts, with typed args and mode (forward/frame).",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "device": {
      "type": "string"
    },
    "kind": {
      "type": "string"
    },
    "osc_prefix": {
      "type": "string"
    },
    "params": {
      "description": "SysEx parameters, each mapped to an OSC address. Each entry carries an 'expects' field — see cc_params.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "replies": {
      "description": "Reply patterns the device emits back onto the OSC surface.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "triggers": {
      "description": "Named note-triggered sounds (drum machines, samplers). Send '<address> [velocity] [note] [channel]' to fire a Note On; 'note' is required when the entry has no natural note.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "vendor": {
      "type": "string"
    }
  },
  "required": [
    "device",
    "osc_prefix",
    "commands",
    "cc_params",
    "params",
    "triggers",
    "replies"
  ]
}
🟢export_device(device, format, user_id)

Write one driver in a format other tools read: 'oscquery' gives its OSC namespace as OSCQuery JSON (every route with type tags, ranges and access, for OSC controllers and browsers); 'midnam' gives its MIDI names as a MIDI Name Document (controllers incl. NRPN/RPN, named values, drum notes per channel, for DAWs such as Ardour or Logic). Both carry the credit and licence of the driver's sources. The document is the text content; an OSCQuery namespace is large (every address, each CC 0-127 included).

Input Schema

{
  "type": "object",
  "properties": {
    "device": {
      "description": "Driver id (e.g. 'korg/minilogue') or slug, from list_devices.",
      "type": "string"
    },
    "format": {
      "enum": [
        "oscquery",
        "midnam"
      ],
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device",
    "format"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "properties": {
    "bytes": {
      "description": "Size of the document, which is the text content.",
      "type": "integer"
    },
    "device": {
      "description": "Driver id.",
      "type": "string"
    },
    "file_name": {
      "description": "A file name to save it under.",
      "type": "string"
    },
    "format": {
      "type": "string"
    },
    "media_type": {
      "description": "'application/json' or 'application/xml'.",
      "type": "string"
    }
  },
  "required": [
    "device",
    "format",
    "media_type",
    "file_name",
    "bytes"
  ]
}
🟢report_result(address, device, firmware, identity_hex, note, ...)

Tell the catalogue how a driver behaved on a real device, after testing it: 'works', 'fails' or 'partial', for the whole driver or one OSC address (from list_routes). Give the firmware version, and the device's reply to the MIDI Identity Request (F0 7E 7F 06 01 F7) as identity_hex when you can: trust is counted per firmware, so a failure on another firmware does not count against the driver, and a report of unknown firmware cannot be placed. Several accounts that agree on one firmware mark the driver usage-verified there; a report that several others contradict is rolled back and puts its account under review. Report only what was actually tested.

Input Schema

{
  "type": "object",
  "properties": {
    "address": {
      "description": "One OSC address of the driver (e.g. '/minilogue/filter/cutoff'); omit to report on the whole driver.",
      "type": "string"
    },
    "device": {
      "description": "Driver id (e.g. 'korg/minilogue') or slug, from list_devices.",
      "type": "string"
    },
    "firmware": {
      "description": "Firmware version of the tested device.",
      "type": "string"
    },
    "identity_hex": {
      "description": "The device's reply to the MIDI Identity Request, in hex (e.g. 'F0 7E 00 06 02 42 2C 01 00 00 02 01 00 00 F7'). Proves the device was connected and carries its firmware version.",
      "type": "string"
    },
    "note": {
      "description": "What happened, briefly (500 characters at most): wrong range, no effect, other parameter moved…",
      "type": "string"
    },
    "outcome": {
      "enum": [
        "works",
        "fails",
        "partial"
      ],
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device",
    "outcome"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "properties": {
    "recorded": {
      "type": "boolean"
    },
    "report": {
      "description": "The report's id.",
      "type": "integer"
    },
    "status": {
      "description": "accepted: counts in the trust; pending: the account is under review; rolled-back: other accounts contradict it on this firmware.",
      "enum": [
        "accepted",
        "pending",
        "rolled-back",
        "rejected"
      ],
      "type": "string"
    },
    "trust": {
      "description": "The driver's trust after this report (see get_trust).",
      "type": "object"
    }
  },
  "required": [
    "recorded",
    "report",
    "status",
    "trust"
  ]
}
🟢get_trust(device, user_id)

How far a driver has been confirmed by people who used it, per firmware: status (unreported, unconfirmed, usage-verified, firmware-dependent, failing, disputed), how many users report it works / fails / partly works, each firmware's own status, the device identities seen for each firmware, and the same per OSC address. needs_firmware: true means reports disagree and some have no firmware — identify the device before reporting (see learn). Check it before relying on a driver, together with its source_tier.

Input Schema

{
  "type": "object",
  "properties": {
    "device": {
      "description": "Driver id (e.g. 'korg/minilogue') or slug, from list_devices.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device"
  ],
  "additionalProperties": false
}

Output Schema

{
  "type": "object",
  "properties": {
    "addresses": {
      "type": "object"
    },
    "device": {
      "type": "string"
    },
    "overall": {
      "type": "object"
    }
  },
  "required": [
    "device",
    "overall",
    "addresses"
  ]
}
🟢report_mapping(address, cc, channel, device, firmware, ...)

Teach the catalogue which MIDI message a control really sends: after the user moved one control on the device (see relay_listen), give the driver address it is (from list_routes) — or, for a control the driver lacks, its panel label — and the CC, NRPN or note it sent, with the firmware and the device's Identity Reply when you have them. When several accounts observe the same thing on one firmware the mapping is learned; get_trust shows learned mappings and where they differ from the driver.

Input Schema

{
  "type": "object",
  "properties": {
    "address": {
      "description": "The driver's OSC address for the control.",
      "type": "string"
    },
    "cc": {
      "maximum": 127,
      "minimum": 0,
      "type": "integer"
    },
    "channel": {
      "maximum": 16,
      "minimum": 1,
      "type": "integer"
    },
    "device": {
      "description": "Driver id or slug.",
      "type": "string"
    },
    "firmware": {
      "type": "string"
    },
    "identity_hex": {
      "description": "The device's reply to the MIDI Identity Request, in hex.",
      "type": "string"
    },
    "label": {
      "description": "The control's panel label, when the driver has no address for it.",
      "type": "string"
    },
    "note": {
      "maximum": 127,
      "minimum": 0,
      "type": "integer"
    },
    "nrpn_lsb": {
      "maximum": 127,
      "minimum": 0,
      "type": "integer"
    },
    "nrpn_msb": {
      "maximum": 127,
      "minimum": 0,
      "type": "integer"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device"
  ],
  "additionalProperties": false
}
🟡submit_driver(driver, firmware, note, source, user_id)

Contribute a driver for a device the catalogue lacks (or a better one): the full driver file as a JSON object, in the osc-bridge device schema (device.name, device.vendor, device.osc_prefix, and cc_params / params / commands / triggers — see https://synthhub.roomi-fields.com/DEVICE_JSON_SCHEMA/). It is checked, then merged into the SynthHub catalogue by the merge job if it parses, lints and passes the tests, as its own file of source 'agent-contributed'. Say where the data comes from (manual page, tested on the device).

Input Schema

{
  "type": "object",
  "properties": {
    "driver": {
      "description": "The driver file.",
      "type": "object"
    },
    "firmware": {
      "description": "Firmware the driver was written or tested for.",
      "type": "string"
    },
    "note": {
      "type": "string"
    },
    "source": {
      "description": "Where the mapping comes from (e.g. 'manual v1.2 p. 34, tested on the device').",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "driver"
  ],
  "additionalProperties": false
}
🟡submit_fix(device, firmware, user_id)

Contribute a corrected variant of a driver from what the catalogue learned: where learned mappings (get_trust → mappings, differs: true) disagree with the driver on one firmware, builds a copy of the driver with the learned CC / NRPN numbers, as a new file for that firmware, and queues it for the merge job.

Input Schema

{
  "type": "object",
  "properties": {
    "device": {
      "description": "Driver id or slug.",
      "type": "string"
    },
    "firmware": {
      "description": "Needed when learned mappings differ on several firmwares.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device"
  ],
  "additionalProperties": false
}
🟢get_contribution(id, user_id)

Where a contribution stands: pending (waiting for the merge job), merged (with its pull request), rejected (with the reason), or held (its account is under review).

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "integer"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}
🟡share_preset(category, code, derived_from, description, device, ...)

Share something the user made on a device with every SynthHub user, under CC BY-SA 4.0: a sound, a sequence or pattern, a kit, a project, a bank of their own sounds, or a MIDI clip any device can play. Its content: the device's own data (SysEx, e.g. from backup_presets), settings by driver address (from list_routes, e.g. {'/filter/cutoff': [90]}, which also works for devices without dumps), and/or a standard MIDI file. Only what the user made: never factory presets, nor sounds or sequences bought or downloaded from others — set own_sound only after asking the user. Made from someone else's shared preset? Pass derived_from: it credits them, as the licence requires. Describe it well (category, genres, tags, tempo, key, tips): that is how people find it. The same content shared twice returns the existing id; the author publishes new versions with update_preset and can withdraw it (withdraw_preset). Through a relay, the device data can be captured from the device itself: pass code and start the dump from the device's menu during the call, or give request_hex (the device's dump-request message, which the user accepts at the relay). An audio preview is added by its author with PUT /u/<account>/v1/presets/<id>/audio (MP3, Ogg, M4A or WebM, 1 MB at most).

Input Schema

{
  "type": "object",
  "properties": {
    "category": {
      "description": "The kind of sound or part.",
      "enum": [
        "bass",
        "lead",
        "pad",
        "pluck",
        "keys",
        "organ",
        "brass",
        "strings",
        "bell",
        "arp",
        "sequence",
        "drums",
        "percussion",
        "fx",
        "texture",
        "vocal",
        "other"
      ],
      "type": "string"
    },
    "code": {
      "description": "A relay's pairing code: capture the device data from the device instead of hex.",
      "type": "string"
    },
    "derived_from": {
      "description": "Id of the shared preset it was made from.",
      "type": "string"
    },
    "description": {
      "description": "What it sounds like (500 characters at most).",
      "type": "string"
    },
    "device": {
      "description": "Driver id (e.g. 'korg/minilogue') or slug.",
      "type": "string"
    },
    "firmware": {
      "description": "Firmware version of the device it was made on.",
      "type": "string"
    },
    "genres": {
      "description": "Musical styles: 'techno', 'ambient'… (8 at most).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "hex": {
      "description": "The device data as SysEx, in hex (64 KB at most).",
      "type": "string"
    },
    "key": {
      "description": "Musical key, e.g. 'A minor'.",
      "type": "string"
    },
    "kind": {
      "description": "What it is (default sound).",
      "enum": [
        "sound",
        "sequence",
        "kit",
        "project",
        "bank",
        "clip"
      ],
      "type": "string"
    },
    "librarian": {
      "description": "The synth the librarian took it from (take_sound's librarian): loading it then goes through the same exchange, fitted to the receiving synth.",
      "type": "string"
    },
    "midi_base64": {
      "description": "A standard MIDI file, base64 (64 KB at most).",
      "type": "string"
    },
    "name": {
      "description": "Its name (80 characters at most).",
      "type": "string"
    },
    "own_sound": {
      "description": "Must be true: the user made it (not a factory preset, not someone else's).",
      "type": "boolean"
    },
    "port": {
      "description": "With code: the device's port name (or part of it), when the relay has several.",
      "type": "string"
    },
    "request_hex": {
      "description": "With code: the device's dump-request SysEx, sent first (e.g. 'F0 42 30 00 01 2C 10 F7').",
      "type": "string"
    },
    "seconds": {
      "description": "With code: how long to wait for the dump (default 5).",
      "maximum": 30,
      "minimum": 1,
      "type": "integer"
    },
    "settings": {
      "additionalProperties": true,
      "description": "Settings by driver address: {'/filter/cutoff': [90], '/amp/attack': [12]} (512 at most).",
      "type": "object"
    },
    "tags": {
      "description": "Character and free words: 'warm', 'dark', 'evolving'… (8 at most).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "tempo": {
      "description": "BPM, for sequences and clips.",
      "type": "number"
    },
    "tips": {
      "description": "How to play it: mod wheel, aftertouch, register… (500 characters at most).",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "device",
    "name",
    "own_sound"
  ],
  "additionalProperties": false
}
🟡update_preset(category, changelog, description, firmware, genres, ...)

Publish a new version of a preset this account shared: new content (hex, file, settings or midi_file) makes a new version, kept with a change note — earlier versions stay available; the description fields alone change it in place. Someone else's preset: share yours with derived_from instead.

Input Schema

{
  "type": "object",
  "properties": {
    "category": {
      "enum": [
        "bass",
        "lead",
        "pad",
        "pluck",
        "keys",
        "organ",
        "brass",
        "strings",
        "bell",
        "arp",
        "sequence",
        "drums",
        "percussion",
        "fx",
        "texture",
        "vocal",
        "other"
      ],
      "type": "string"
    },
    "changelog": {
      "description": "What changed in this version (500 characters at most).",
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "firmware": {
      "type": "string"
    },
    "genres": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "hex": {
      "type": "string"
    },
    "id": {
      "type": "string"
    },
    "key": {
      "type": "string"
    },
    "midi_base64": {
      "description": "A standard MIDI file, base64 (64 KB at most).",
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "settings": {
      "additionalProperties": true,
      "type": "object"
    },
    "tags": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "tempo": {
      "type": "number"
    },
    "tips": {
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}
🟢find_presets(author, category, device, genre, kind, ...)

Search what SynthHub users shared (CC BY-SA 4.0): sounds, sequences, kits, projects, banks, MIDI clips. Filter by device, kind, category, genre, tag, author (pseudonym) or words; sort by newest, most stars, most loaded into a device or most trusted (confirmed on real devices). Returns, per preset, its id, name, kind, device, description, author, version, whether it has device data, settings, a MIDI file or an audio preview (URL), and its counts. Get one with get_preset.

Input Schema

{
  "type": "object",
  "properties": {
    "author": {
      "description": "An author's pseudonym (e.g. 'u1a2b3c4d').",
      "type": "string"
    },
    "category": {
      "enum": [
        "bass",
        "lead",
        "pad",
        "pluck",
        "keys",
        "organ",
        "brass",
        "strings",
        "bell",
        "arp",
        "sequence",
        "drums",
        "percussion",
        "fx",
        "texture",
        "vocal",
        "other"
      ],
      "type": "string"
    },
    "device": {
      "description": "Driver id or slug (its other variants are included).",
      "type": "string"
    },
    "genre": {
      "type": "string"
    },
    "kind": {
      "enum": [
        "sound",
        "sequence",
        "kit",
        "project",
        "bank",
        "clip"
      ],
      "type": "string"
    },
    "limit": {
      "description": "At most this many (default 20).",
      "maximum": 50,
      "minimum": 1,
      "type": "integer"
    },
    "offset": {
      "description": "Skip this many: the next page (the reply's total says how many match).",
      "minimum": 0,
      "type": "integer"
    },
    "query": {
      "description": "Words that must all appear in the name, description, tags, genres, category or device id ('dx7 piano').",
      "type": "string"
    },
    "sort": {
      "description": "new (default), most stars, most loaded into a device, or most confirmed on real devices.",
      "enum": [
        "new",
        "stars",
        "loads",
        "trusted"
      ],
      "type": "string"
    },
    "tag": {
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
🟢get_preset(id, user_id, version)

One shared preset in full: its content (SysEx hex, settings by driver address, MIDI file), description and playing tips, versions with their change notes, what it was derived from and its derivatives (remixes), comments, preview URLs, author, licence and attribution line, trust and counts. Load it with load_preset; credit it as the attribution line says when you publish something made from it.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Preset id from find_presets (e.g. 'p3fa9c1d2e4b7').",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    },
    "version": {
      "description": "An earlier version (default the current one).",
      "minimum": 1,
      "type": "integer"
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}
⚪report_preset(firmware, id, note, outcome, user_id)

Tell SynthHub how a shared preset behaved once loaded on a real device: 'works' (it loaded and sounds as described), 'fails' (refused, wrong sound), or 'factory' (it is a factory preset or someone else's sound: presets that several users flag are hidden until reviewed). Give the firmware.

Input Schema

{
  "type": "object",
  "properties": {
    "firmware": {
      "type": "string"
    },
    "id": {
      "type": "string"
    },
    "note": {
      "description": "What happened, briefly (500 characters at most).",
      "type": "string"
    },
    "outcome": {
      "enum": [
        "works",
        "fails",
        "factory"
      ],
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "id",
    "outcome"
  ],
  "additionalProperties": false
}
🔴withdraw_preset(id, user_id)

Withdraw a preset this account shared: it is no longer listed nor served. Copies others already made stay under CC BY-SA.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}
🔴comment_preset(flag, id, remix, remove, text, ...)

Comment on a shared preset — how it sounds, how you used it, what you changed — optionally attaching your remix (a preset you shared with derived_from). Comments are public at once. Also: remove one of this account's comments (remove), or flag someone else's as abusive or off-topic (flag); comments several accounts flag are hidden until reviewed.

Input Schema

{
  "type": "object",
  "properties": {
    "flag": {
      "description": "Id of someone else's comment to flag (instead of commenting).",
      "type": "integer"
    },
    "id": {
      "description": "The preset to comment on.",
      "type": "string"
    },
    "remix": {
      "description": "Id of your remix, to attach.",
      "type": "string"
    },
    "remove": {
      "description": "Id of this account's comment to remove (instead of commenting).",
      "type": "integer"
    },
    "text": {
      "description": "The comment (2000 characters at most).",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
⚪star_preset(id, on, user_id)

Star a shared preset for this account, as on GitHub (on: false takes the star back). Without id, lists the presets this account starred.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "on": {
      "description": "Default true.",
      "type": "boolean"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
🔴preset_collection(action, author, collection, description, id, ...)

Collections of shared presets, public, made by one account (e.g. 'Dark basses for minilogue'). action: create (name, description), rename (collection, name, description), add or remove (collection, id), delete (collection), get (collection: its presets), list (this account's collections, or author: someone's).

Input Schema

{
  "type": "object",
  "properties": {
    "action": {
      "enum": [
        "create",
        "rename",
        "add",
        "remove",
        "delete",
        "get",
        "list"
      ],
      "type": "string"
    },
    "author": {
      "description": "With list: an author's pseudonym.",
      "type": "string"
    },
    "collection": {
      "description": "Collection id (e.g. 'c1a2b3c4d5e6').",
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "id": {
      "description": "Preset id to add or remove.",
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "action"
  ],
  "additionalProperties": false
}
⚪follow_author(author, limit, on, user_id)

Follow an author of shared presets (by pseudonym), or stop (on: false); with author alone and on omitted, shows their page: profile, presets, followers. Without author, lists the newest presets of the authors this account follows.

Input Schema

{
  "type": "object",
  "properties": {
    "author": {
      "type": "string"
    },
    "limit": {
      "maximum": 50,
      "minimum": 1,
      "type": "integer"
    },
    "on": {
      "type": "boolean"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
🟡set_profile(about, bio, featured, gear, link, ...)

Set the public profile shown on this account's author page and with its shared presets and comments, instead of its pseudonym alone: display name, link (https), a few words, the presets put first, where they are, more links, their instruments and a README. A field left out stays as it is; an empty one is cleared. Ask the user what they want shown; all of it is public.

Input Schema

{
  "type": "object",
  "properties": {
    "about": {
      "description": "Their README in Markdown: who they are, how they work, what they offer; 8000 characters at most.",
      "type": "string"
    },
    "bio": {
      "description": "A few words about them and their sounds, 600 characters at most.",
      "type": "string"
    },
    "featured": {
      "description": "Ids of their own listed presets, shown first on their page, in this order.",
      "items": {
        "type": "string"
      },
      "maxItems": 6,
      "type": "array"
    },
    "gear": {
      "description": "The instruments they play, e.g. 'Korg minilogue'.",
      "items": {
        "type": "string"
      },
      "maxItems": 20,
      "type": "array"
    },
    "link": {
      "description": "An https:// address: their site, SoundCloud, Bandcamp…",
      "type": "string"
    },
    "links": {
      "description": "More https:// pages of theirs: a channel, a shop, a band.",
      "items": {
        "type": "string"
      },
      "maxItems": 8,
      "type": "array"
    },
    "location": {
      "description": "Where they make music, 60 characters at most.",
      "type": "string"
    },
    "name": {
      "description": "40 characters at most.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
🟢relay_status(code, user_id)

Check a relay: the user opened https://synthhub.roomi-fields.com/connect/ (or ran osc-bridge connect) and gave you its pairing code. Returns the MIDI output and input ports of their machine, and devices: the driver the user confirmed for each port on the page (use it directly, no detection needed). Nothing is sent to the hardware.

Input Schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "The pairing code the relay page or program shows (e.g. 'K7QM-2XPA').",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
🟢relay_detect(code, listen_ms, maker_requests, timeout_ms, user_id)

Find which devices are connected to the user's machine through a relay: sends the MIDI Identity Request (F0 7E 7F 06 01 F7, changes nothing on the device) to every output and matches the answers — manufacturer, model, firmware version — against the drivers' identity blocks. With maker_requests, also sends the makers' own identity requests the drivers name (they change nothing either, but the relay asks the user to accept them, once per output: tell the user first), which recognise devices that ignore the universal one. Returns the best driver ids (recognised_by and firmware when an identity block recognised the device) and identity_hex to pass to report_result. A device that does not answer is found by its knobs with listen_ms (by_controls), or by what people confirmed of its port name (learned); when several remain, ask names the control to have the user turn next (expect: what each candidate would send), then call again with listen_ms.

Input Schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "The pairing code the relay page or program shows (e.g. 'K7QM-2XPA').",
      "type": "string"
    },
    "listen_ms": {
      "description": "Listen this long for a device that does not answer: ask the user first to turn three or four of its knobs during that time; the controls they send are matched against every driver (by_controls). Confirm the device with the user, then send its fingerprint to POST /v1/fingerprints so the next detection knows it.",
      "maximum": 20000,
      "minimum": 0,
      "type": "integer"
    },
    "maker_requests": {
      "description": "Also send the makers' identity requests, after the user accepts them at the relay (default false).",
      "type": "boolean"
    },
    "timeout_ms": {
      "description": "How long to wait for answers (default 1000).",
      "maximum": 5000,
      "minimum": 100,
      "type": "integer"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
🟡relay_send(address, args, code, device, gap_ms, ...)

Play or set something on the user's hardware through a relay: give a driver (id or slug) and one of its OSC addresses from list_routes with its arguments (e.g. address '/filter/cutoff', args [64]; '/note/on', args [60, 100]) — the server turns it into the right CC, NRPN, note or SysEx message. Or give raw MIDI bytes as hex. Values are the device's own numbers, clamped to the parameter's range. Any SysEx but the Identity Request (patch dumps, stores, settings, preset restores) may overwrite the device's memory: the relay asks the user to accept it first and this call waits for the answer (up to 2 minutes), so tell the user what you are about to send.

Input Schema

{
  "type": "object",
  "properties": {
    "address": {
      "description": "OSC address of the driver, with or without its prefix.",
      "type": "string"
    },
    "args": {
      "description": "OSC arguments (numbers, strings, booleans).",
      "items": {},
      "type": "array"
    },
    "code": {
      "description": "The pairing code the relay page or program shows (e.g. 'K7QM-2XPA').",
      "type": "string"
    },
    "device": {
      "description": "Driver id (e.g. 'korg/minilogue') or slug.",
      "type": "string"
    },
    "gap_ms": {
      "description": "Pause between the SysEx messages of a dump, for devices that write slowly (default 50).",
      "maximum": 2000,
      "minimum": 0,
      "type": "integer"
    },
    "hex": {
      "description": "Raw MIDI messages instead of device/address, e.g. 'B0 2B 40'.",
      "type": "string"
    },
    "port": {
      "description": "Output port name (or part of it); needed when the relay has several.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
🟢relay_listen(code, device, seconds, user_id)

Listen to what the user's hardware sends through a relay for a few seconds: notes, CC, NRPN, SysEx, decoded. With a device, each CC or NRPN that moved is matched to the driver's OSC addresses — ask the user to move one control on the device while listening to learn which address it is, or to check that the driver's map is right (then record what you saw with report_mapping, so the catalogue learns it).

Input Schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "The pairing code the relay page or program shows (e.g. 'K7QM-2XPA').",
      "type": "string"
    },
    "device": {
      "description": "Driver id or slug, to match what moved to its addresses.",
      "type": "string"
    },
    "seconds": {
      "description": "How long to listen (default 3).",
      "maximum": 15,
      "minimum": 1,
      "type": "integer"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
⚪take_sound(code, port, program, user_id)

Take the sound the user's synth is playing — or one of its stored programs — straight from the synth through a relay, with its name. The synth is found among those SynthHub's librarian can talk to (the KnobKraft Orm adaptations, about 90 synths) by the identity and detect messages, then asked for its sound. The person accepts each step at the relay (finding the synth, asking it): tell them first. To share it: ask the user whether they made this sound themselves (never a factory preset, nor one bought or downloaded), then call share_preset with the device, name, hex, librarian and firmware returned here, and own_sound: true. When several synths answer, or none did, call again with port.

Input Schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "The pairing code the relay page or program shows.",
      "type": "string"
    },
    "port": {
      "description": "Output port name (or part of it): look on that port only, for every synth the librarian knows.",
      "type": "string"
    },
    "program": {
      "description": "A stored program (from 1) instead of the sound being played.",
      "minimum": 1,
      "type": "integer"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}
🔴load_preset(code, device, gap_ms, id, port, ...)

Load a shared preset (find_presets, get_preset) into the user's device through a relay: its settings are sent through the driver, its patch data as SysEx — which replaces the sound the device holds, so the relay asks the user to accept it and this call waits for the answer (up to 2 minutes): tell the user first. Afterwards, tell SynthHub how it went with report_preset.

Input Schema

{
  "type": "object",
  "properties": {
    "code": {
      "description": "The pairing code the relay page or program shows.",
      "type": "string"
    },
    "device": {
      "description": "The device it goes into, when not the preset's own: one of get_preset's loads_on (an M-VAVE FM-1 takes DX7 voices); the sound is sent unchanged.",
      "type": "string"
    },
    "gap_ms": {
      "description": "Pause between the SysEx messages, for devices that write slowly (default 50).",
      "maximum": 2000,
      "minimum": 0,
      "type": "integer"
    },
    "id": {
      "description": "Preset id (e.g. 'p3fa9c1d2e4b7').",
      "type": "string"
    },
    "port": {
      "description": "Output port name (or part of it); needed when the relay has several.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "required": [
    "code",
    "id"
  ],
  "additionalProperties": false
}
⚪link_account(user_id)

Link this account to the user's SynthHub account on the site: returns a one-time address (valid 15 minutes) for the user to open and sign in (passkey, e-mail, Google or Discord). Afterwards what this account shared appears under their profile, and they manage it — and their stars, collections, comments — from the site. Offer it when the user wants to see or manage what you shared for them.

Input Schema

{
  "type": "object",
  "properties": {
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    }
  },
  "additionalProperties": false
}
🟡claim_presets(id, user_id, verify)

Claim presets SynthHub imported from another site (their page says 'imported', with the author's name and page there) when the user is that author: give the id of one of them; the server answers with a code for the user to add to their author page at that site (profile or bio). Once it is there, call again with verify: true: every preset imported from that author becomes the user's, to edit or withdraw.

Input Schema

{
  "type": "object",
  "properties": {
    "id": {
      "description": "Id of one of the imported presets.",
      "type": "string"
    },
    "user_id": {
      "description": "Your anonymous SynthHub id, if you kept it from an earlier session (see the server instructions). Optional.",
      "type": "string"
    },
    "verify": {
      "description": "True once the code is on the author page.",
      "type": "boolean"
    }
  },
  "required": [
    "id"
  ],
  "additionalProperties": false
}

Community

Rate this Server

Evidence

Recent observations

verifiedversion not recorded29 tools
verifiedversion not recorded28 tools
verifiedversion not recorded13 tools