com.eurorackref/eurorack

Patch diagram tool. Use when the user describes routing across multiple Eurorack corpus modules. Renders modules as boxes laid out by wire topology (matrix-shaped patches anchor on a hub; otherwise modules step left-to-right by signal-flow rank), jacks as colored ports keyed to signal type, wires as bezier curves. Inline SVG on claude.ai surfaces (web, Desktop chat, mobile); JSON elsewhere. (When to *offer* a diagram unprompted: SKILL.md §4.) **Trigger phrases:** "show me the patch", "draw what I just described", "remind me what's connected to what", "explain the routing", or any time you'd otherwise hand-draw a patch in SVG/text — use this instead of drawing. Strict gate — call only when ALL of: 1. At least 3 named corpus modules. 2. Explicit wire connections between them (user-stated or derived from a coherent description). 3. The patch is concrete — user is following a tutorial, describing their own rack, or referencing back what's connected to what. Do NOT call for: a single module, a question about one module's jacks, "what should I patch X to?" (that's a recommendation, not a graph), or hypothetical patches with unnamed placeholders ("connect a VCO to a filter"). Jack names. Corpus jack names are descriptive ("V/Oct CV input", "TRIG input", "Strumming trigger input"), not panel-text shorthand ("V/OCT", "TRIG"). The resolver accepts panel-text as a fallback when it unambiguously substring-matches one jack of the right direction (e.g. "TRIG" → "TRIG input"); successful resolutions surface as `panel_text_resolved` warnings so you can confirm. Ambiguous panel text ("OUT" on a multi-output module) errors with the candidate list. To skip the fallback entirely, call get_modules to discover the exact corpus names up front (one round trip for the whole batch). Multi-channel modules require a CH<N> prefix. Modules with per-channel jacks (Quadrax, Maths, Tangrams, Stages, Optomix, QMMG, DXG, Pamela's New Workout, Cold Mac, etc.) enumerate each channel separat…

Return modules that have a typed compatibility relationship with the given module. Both edge directions are returned and tagged via the per-match `direction` field — so a single call answers both "what is X a R for?" and "what is a R for X?". `relationship` is OPTIONAL. Omit it to get EVERY edge touching the module across all relationship kinds — the bare "what pairs with / relates to X?" question — with each match self-describing via its own `relationship`. Pass a relationship to restrict to that one kind. Prefer the relationship-less call when you don't already know which kind exists; reach for the typed form only when the question names a specific role ("what clocks X?"). Use this for two question shapes: 1. Patch-time compatibility — "what could I use as a clock source for X?" (returns matches with direction='inbound'), or "what does X clock?" (direction='outbound'). 2. Catalog comparison — "what's an alternative to X?" (symmetric), "what does X replace?" (outbound) / "what replaces X?" (inbound), "is there an expander for X?" (inbound). The vocabulary describes the edge as stored (from = role-bearer, to = target): Patch-time: - clock-source-for — A clocks B - cv-source-for — A produces CV that B consumes - modulator-for — A is a modulator suitable for B (LFO, S&H, random) - audio-source-for — A is an audio source for B (typically a VCO into a VCF) - quantizer-for — A quantizes for B - trigger-source-for — A produces triggers that B consumes - envelope-target-for — A is something B's envelope output is designed to drive Catalog: - replaces — A is the newer successor to B (Morphagene replaces Phonogene) - alternative-to — symmetric: A and B occupy similar design space with different character - expander-for — A is an expander module for the host module B Direction tag on each match: - outbound: queried module is the FROM side (role-bearer). Match is what the qu…

For a (technique_id, role_id) pair, return modules that can fill the role, ranked by affordance match. Use this when the user has named a technique and you need to recommend modules for a specific role within it (e.g., "what should I use for the lpg role in a lowpass-gate-pluck patch?"). Optionally pass available_modules to restrict the search to the user's rack — the tool surfaces both documented realizations in the rack AND undocumented candidates whose capability tags match the role's required affordances (or, for roles that declare only optional affordances, those optional ones). This tool exists to STOP the model from inventing module-role recipes from training-data priors. The output is editorially grounded: documented realizations carry corpus-curated notes; undocumented candidates are explicitly tagged so the agent can weigh confidence. Args: - technique_id (required): kebab-case technique id (see list_techniques). - role_id (required): kebab-case role id (e.g., "lpg", "voice", "env", "clock"). See list_techniques → role_definitions for the roles a technique declares. - available_modules (optional): array of "<manufacturer>/<module-slug>" ids — typically the user's rack. When supplied, restricts results AND surfaces undocumented candidates whose module_capabilities match the role's required affordances — or, for an optional-only role (no required affordances), its optional affordances. Returns: { "technique_id": "low-pass-gate-pluck", "role_id": "lpg", "role": { "label": "Low-Pass Gate", "description": "Vactrol-style..." }, "role_definition_description": "The vactrol-based or vactrol-emulating element...", "required_affordances": ["lowpass-gate"], "optional_affordances": [], "realizations": [ { "module_id": "make-noise/optomix", "documented": true, "affordances_provided": ["lowpass-gate"], "required_matched": ["lowpass-gate"], "optional_matched": [], "missing_requi…

Read one manual chunk by id to ground your answer in the manufacturer's documentation — the drill-in partner to get_module's manual_outline. Use it when a claim (voltage range, behavior, calibration step) benefits from the source's own account. **Read the chunk, then answer in your own words and point the user to the source (audit_url) to verify.** Paraphrase the substance; do not paste the chunk back as your reply. Quote verbatim only when the exact wording is load-bearing for a specific contested detail, and then only a short phrase. Citation style is SKILL.md §8 (cite-and-point, don't reproduce). `text` is **capped** (~800 chars): enough to ground an answer, not to reproduce the manual. If truncated:true, a " […]" marks the cut and the full passage is at audit_url — send the user there for the rest rather than stitching chunks together to rebuild it. When to call: - You have a chunk_id from get_module's manual_outline that looks relevant to the question. - You're writing an answer with specific technical claims and want the source's account to ground (and, if needed, briefly cite) it. - The user asked a prose-shaped question ("what does the manual say about X?") — read the chunk, then explain it in your own words with a link to verify. Prefer get_manual_chunk over search_manual when: - You already have the chunk_id from get_module's manual_outline. - You want exactly one chunk, not a ranked list. Returns: { "chunk_id": number, "source_id": number, "source_type": string, // "manual" | "product_page" | "firmware_notes" "source_title": string | null, "heading_path": string | null, // e.g. "Calibration > Tuning Procedure" "text": string, // chunk text, capped ~800 chars; paraphrase, don't paste "truncated": boolean, // true if text was trimmed; full passage at audit_url "audit_url": string // human-readable audit page for the source } Errors: - "Manual chunk not found: <…

Return the full citation-anchored specification for one Eurorack module by id. Use this when the user names a specific module and you want its specs (HP, power, jacks, parameters), capabilities (envelope, quantizer, logic, etc.), or firmware history. The typed prose fields (jack/parameter/mode descriptions) are paraphrased summaries; manual_outline → get_manual_chunk give the verbatim manual prose to quote against. How much to quote and overall answer shape live in SKILL.md (the "Answer shape" section + §8 citation) — this description is the data contract. ## Provenance fields Every typed row in the response — capabilities[], jacks[], parameters[], modes[], firmware_versions[], plus nested zones/assignments/tracking — carries a source_id pointing at the source the claim was extracted from. Cross-reference list_references(module_id=...) for the source title and canonical_url. The typed prose fields — jacks[].description, parameters[].behavior, modes[].description, capabilities[].notes, firmware_versions[].notes — are extractor-synthesized summaries grounded in the manual, NOT verbatim quotes. Treat them as the corpus's stated claim about the field; they're authoritative for what the field *does*, but they are not direct manual text. For verbatim quotation in your answer, always pull the actual prose via get_manual_chunk(chunk_id) — the description fields are the typed claim, not the source quote. manual_outline[] bundles a lightweight outline of the module's manual prose — one entry per chunk with heading, source, and a ~140-char preview snippet. Always scan it before answering — for prose-shaped questions to find the relevant chunk, for spec-shaped questions to find a chunk to quote alongside the typed data. When a snippet looks relevant, call get_manual_chunk(chunk_id) to pull the full text. manual_outline_total is set ONLY when the outline was truncated for a verbose module; its absence means the returned outline is complete. When set, use search_manual to…

Batched get_module — returns `{ modules: [...], errors: [...] }` with full citation-anchored specs for up to 25 modules in one call. Prefer this over multiple get_module calls when you have a known list of modules to fetch (e.g. preparing to call draw_patch_diagram across N modules, comparing several candidates side-by-side). One round trip vs. N. Args: - module_ids: array of "<manufacturer-id>/<module-slug>" strings. Up to 25 per call; duplicates are deduplicated. Optional args (apply to every module in the batch, same semantics as get_module): - view: "concise" returns the id-card subset (name, manufacturer, hp, description, capabilities, production_status, replaced_by) for every module and drops the heavy arrays — the cheapest way to triage a list ("which of these are LFOs?"). "full" (default) returns complete specs. Ignored when fields is set. - fields: top-level keys to include on each module (e.g. ["jacks","parameters"]). id and _meta are always returned. Use this when you only need a slice across N modules (e.g. just jacks for draw_patch_diagram) instead of N full specs. - heading_filter / outline_offset / outline_limit: narrow and paginate each module's manual_outline. Returns: - modules[]: GetModuleResponse for each id that resolved (same shape as get_module; narrowed when fields is set). - errors[]: { id, message } for each id that failed (e.g. unknown module). Other ids in the batch still resolve. If you only need a single module, use get_module — same shape, one element. Need only jacks (e.g. for draw_patch_diagram)? Pass fields: ["jacks"] to skip the full specs.

Return provenance metadata for one source by integer source_id. Sources include manufacturer manuals, product pages, firmware notes, schematics, errata, and (in v2) field notes. Source ids are surfaced wherever facts cite their origin — in get_module's reference list, in the audit page citation links, and (in v2) in the claims table. Args: - source_id (integer, required) Returns metadata only — not the document content. The audit_url field links to the audit site's per-source page where the document can be viewed. The archived_url field is a path on the worker that streams the archived bytes from R2 (e.g. /sources/123/document). Returns: { "id": number, "source_type": "manual" | "firmware_notes" | "product_page" | ..., "format": "pdf" | "html" | "text" | ..., "title": string | null, "canonical_url": string, // manufacturer-hosted URL "archived_url": string | null, // worker route to the R2-archived copy "content_hash": string | null, // sha256 of archived bytes "fetched_date": string, // when first archived "last_verified": string | null, // when canonical was last confirmed "canonical_changed_at": string | null, // null until manufacturer side changes "module_id": string | null, // owning module, if any "manufacturer_id": string | null, "audit_url": string // audit site page for this source } The pair (canonical_changed_at, last_verified) is the staleness signal: if canonical_changed_at > last_verified, the manufacturer document changed since we last checked it. Surface that to the user when relevant.

Return a canonical definition for a primitive Eurorack / synthesis concept and its relations to other concepts in the corpus. Use this for VOCABULARY questions, not module questions — when the user is asking what a term means or how two terms relate, not which modules implement it. Typical shapes: - "Is four-quadrant mult the same as through-zero AM?" → lookup_concept("four-quadrant mult") - "What's the difference between a gate and a trigger?" → lookup_concept("gate") - "Modular signal level vs line level — when does it matter?" → lookup_concept("modular signal level") - "Are clock dividers just pulse counters?" → lookup_concept("clock divider") - "Are polyphonic patch cables TRRRRRS?" → lookup_concept("polyphonic cable") Lookup is case-insensitive across three axes, tried in order: the canonical id ("through-zero-fm"), the canonical label ("Through-Zero FM (TZFM)"), and any registered alias ("tzfm", "through zero fm"). Spaces and hyphens are matched literally; the lookup does NOT normalize whitespace beyond lowercasing. If the term doesn't match anything, the response includes up to 5 substring-matched suggestions. Args: - name (string, required, min length 2): the term to look up. Examples: "AM", "ring mod", "four-quadrant mult", "TZFM", "clock divider", "gate", "trigger". Returns: { "concept": { "id": "amplitude-modulation", "label": "Amplitude Modulation (AM)", "description": "A multiplication of two signals: the carrier...", "aliases": ["am", "amplitude modulation", "amplitude mod"], "related_concepts": [ { "related_concept_id": "ring-modulation", "related_concept_label": "Ring Modulation (RM)", "relation_kind": "commonly_confused_with", "note": "AM with a unipolar modulator preserves the carrier..." }, ... ], "source_id": null, "citation_url": "https://learningmodular.com/glossary/...", "citation_quote": "Amplitude modu…

Call this when the user asks what they can SELL, remove, downsize, or trim — "what can I sell?", "which modules are redundant?", "what's doing double duty?", "I have too many modules, what can go?", "what's not pulling its weight?". The inverse of reachable_techniques: where that adds, this prunes. Given the user's COMPLETE rack, it runs a leave-one-out over the same technique matcher reachable_techniques uses — for each module, does removing it cost any currently-reachable technique? Returns three buckets plus the overlap map: - load_bearing: removing the module drops ≥1 reachable technique → KEEP. `sole_filler_for` names the techniques it props up. - sell_candidates: removing it drops nothing AND another rack module covers the same function → the first place to look. `overlaps` names the shared function and `also_provided_by` the other providers. - utility_or_uncovered: removing it drops nothing and nothing else does its job — it fills no catalogued technique role (usually a mixer / VCA / I/O / mult) OR serves an idiom the corpus is thin on. Judge by hand; this is NOT "sellable". - overlap_map: every function ≥2 of the rack's modules provide (the "you have three reverbs" view) — the evidence behind sell_candidates. IMPORTANT — this is decision-support, not a verdict, and the limits bite here: - cardinality is NOT counted: a 2nd VCA / envelope / mult reads "redundant" though real patches use both at once. Overrule the tool on utilities. - only the curated catalog is seen: a module serving an under-covered genre looks redundant when it isn't. - two modules covering the same role are BOTH flagged — you can usually drop only one. - it cannot weigh sonic character, ergonomics, or sentiment. Trust it most for specialized overlap (e.g. several reverbs); present results as candidates to weigh, never "sell these". Pass the COMPLETE rack — the server is stateless and a partial rack distorts the analysis. Args: - rack (string[], required): module ids, e…

Given a rack (a set of module ids the user owns), rank the modules NOT in the rack by how many rack members they pair with. The set-level companion to find_compatible_with: where that answers "what pairs with module X?", this answers "given my whole rack, what single module should I add — the one that pairs with the most of what I already have?". The ranking signal is `pair_count` — the number of DISTINCT rack members a candidate pairs with. A module that modulates five of your modules ranks above one that modulates one. This aggregate is the point: you can't get it from per-module find_compatible_with calls without tallying distinct members by hand. Use this for: - "What should I add to a rack with <modules>?" / "what fills out this system?" - "Given these modules, what pairs well with the most of them?" - Inspecting a rack's own internal pairing structure (the `internal` edges). Combination edges only. Ranking uses the seven patch-time relationships (clock-source-for, cv-source-for, modulator-for, audio-source-for, quantizer-for, trigger-source-for, envelope-target-for) — the "A and B work together in a patch" kinds. The substitution/catalog kinds (alternative-to, replaces, expander-for) are deliberately excluded: a pairing recommender shouldn't suggest replacing your modules with each other. For "what's an alternative to X?" use find_compatible_with. Args: - rack (string[], required): module ids, e.g. ["make-noise/maths", "mutable-instruments/plaits"]. Ids that match no module are returned in `unknown_ids` (and in `unresolved` with did-you-mean suggestions) rather than failing the call. Surface those rather than proceeding on a partial rack: the server is stateless about your rack — it keeps no memory of it between calls, so pass the COMPLETE current set every call. Max 64. - relationship (string, optional): restrict ranking to one combination kind above. Omit to consider all seven. - limit (number): default 25, max 100. Returns: { "rack":…

Given a rack (the module ids the user owns), return which canonical patch techniques the rack can realize, and which it is one module away from. The set-level companion to find_role_realizations: where that answers "which module fills role R in technique T?", this answers the rack owner's actual question — "given everything I own, what can I actually do, and what am I close to?". This is the right tool the moment a user gives you their modules and asks an open "what can I do / what can this rack do / what am I missing?" question — instead of guessing techniques from training priors or calling find_role_realizations technique-by-technique by hand. It runs the affordance match across the whole technique catalog for you. Returns two buckets: - reachable: every required role has a rack module that fills it. Each carries an `assignment` (role → module). `requires_shared_module: true` flags a technique only reachable by reusing one module for two roles — verify those roles can share one instance. - near_misses: all-but-one role fillable; `missing_roles` names the unfilled role(s) and the `required_affordances` you'd need. This is the acquisition signal — "you can already do X; you're one <affordance> module away from Y". Args: - rack (string[], required): module ids, e.g. ["make-noise/maths", "mutable-instruments/plaits"]. Max 64. Ids that match no module are returned in `unresolved` (with did-you-mean), not silently dropped. - limit (number): max techniques per bucket. Default 25, max 100. Stateless-rack contract: the server keeps no memory of your rack between calls — pass the COMPLETE current rack every call. A partial rack silently narrows what's reported reachable, so if a module id doesn't resolve, surface the `unresolved` did-you-mean to the user rather than proceeding on the incomplete set. Scope: reachability is role-PRESENCE based. It does NOT verify per-role instance counts (cardinality) — a technique needing two independent envelopes is judged re…

Report when this MCP server couldn't fully answer a question. Not a query tool — calling this writes a feedback record. Call this proactively — without being asked — whenever you hit one of: - missing_field: a field you expected on a module wasn't present (e.g. "I needed the LFO frequency range on Pamela's New Workout and parameter_zones didn't have it"). - missing_module: a module the user asked about isn't in the corpus yet. - tool_confusion: a tool's behavior surprised you (wrong shape, missing filter, ambiguous enum value, unclear description). - empty_result: a reasonable query came back empty and you suspect the corpus is incomplete rather than the query being wrong. - other: anything else worth flagging that doesn't fit above. - eval_finding: reserved for the eval harness at evals/mcp/. Don't use this as an agent — it's written by harvest.py --push when a rubric catches a behavior the agent didn't self-report (e.g., a model leaking prior knowledge after acknowledging a corpus gap). Be specific. Vague reports ("data could be better") are useless; actionable reports name the field, module, or tool. Reporting is encouraged — there is no rate limit and no judgment for over-reporting; a noisy log is more useful than a silent one. Args: - kind (required): one of missing_field | missing_module | tool_confusion | empty_result | other (eval_finding is reserved for the eval harness) - module_id: module this was about, if any ("<manufacturer>/<slug>"). For missing_module, use the id the user asked about even if it doesn't exist. - tool_name: tool that fell short (or that you'd want to exist). - expected (required, ≤200 chars): what you were trying to find or do. - observed (required, ≤500 chars): what actually happened. - suggestion (≤300 chars): concrete fix you'd propose ("add a release_curve field to parameters", "ingest mutable-instruments/yarns"). Returns: { acknowledged: true, id: number }

Bulk fuzzy name → id resolver. Pass a list of module NAMES (the way a user writes their rack — "Maths", "Plaits", "Pamela's New Workout", "Morph 4") and get back, per name, the best-matching corpus module id plus recovery affordances. This is the "import my rack" tool: resolving a 60-module inventory is ONE call here, not 60 search_modules calls. Use this the moment a user gives you a list of module names to map onto the corpus — before get_modules / draw_patch_diagram / reachable_techniques / rack_redundancy, all of which want ids. Feed the resolved best_match.id into those. For each input name it runs the same resolution search_modules uses (exact id, unique-slug recovery, module_aliases, separator-fold, token-AND, and edit-distance + multi-token fuzzy "did you mean"), then returns: - best_match: the single resolved module ({ id, name, manufacturer, hp, capabilities, production_status }), or null when nothing resolved confidently. - score: confidence 0..1 (1.0 exact id, ~0.97 unique slug / alias, ~0.9 literal name hit, ~0.72 token-AND relaxed, 0 when best_match is null). - match_kind: "id" | "slug" | "exact" | "relaxed" | "ambiguous" | "fuzzy" | "none". - did_you_mean: up to 5 fuzzy neighbours to confirm — populated when best_match is null (a near-miss like "morf 4" → joranalogue/morph-4, or "tiny time machin" → oam/tiny-time-machine). - ambiguous: up to 5 candidates when several modules tied for the match and the server declined to pick (e.g. a slug shared across manufacturers). Present them to the user; do NOT silently take the first. The server AUTO-RESOLVES a confident single match but never guesses through a genuine tie — that's the ambiguous bucket. A name with best_match=null AND empty did_you_mean/ambiguous is a real corpus gap: consider report_gap(kind="missing_module"). Args: - names (string[], required): module names or ids, up to 100. Order and duplicates are preserved in the response. Returns: { "resolutions": [ {…

Full-text search across parsed module manuals, product pages, and firmware release notes. Use this only when the question is about content that lives in continuous prose rather than in typed fields: - Procedural: calibration sequences, button combos, factory-reset steps, save/load procedures. - Diagnostic: LED color meanings, error indicators, troubleshooting trees. - Firmware specifics beyond the short notes on firmware_versions (which only carry the headline change). - Panel walkthroughs and prose explanations that aren't captured as parameters/jacks/zones. Do NOT call this for content already in get_module: a parameter's behavior, a jack's signal type or polarity, a mode's name or description, capability tags, HP, or power draw. Those are typed and authoritative there. Do NOT call this to summarize a module — that's get_module's job. search_manual returns excerpts, not summaries. Returned chunks are source prose, not typed facts. Read them to ground your answer, then paraphrase and point the user to the source to verify (cite-and-point, not reproduce — SKILL.md §8). `text` is capped (~800 chars); the full passage is at audit_url. Args: - query (string, required): search terms. Plain words are AND'd by default ("calibration LED" matches chunks mentioning both). If the AND match returns 0 rows, the server retries with OR (any-token match) and sets _meta.relaxed_to_or=true on the response — so a long natural-language query like "cascade mode time inner outer delay" still surfaces something useful instead of zeroing out. Best practice is still 2–4 distinctive keywords; the OR fallback is a safety net, not a substitute. Query is tokenized to alphanumeric runs; FTS5 punctuation is stripped. - module_id (string, optional): "<manufacturer>/<module-slug>" — restrict to one module. Strongly recommended when the user has named a module. - source_id (integer, optional): restrict to one source. Use when you already have a source_id from get_so…

Search the corpus for Eurorack modules matching a combination of filters. Filters compose with AND. Omit any filter to leave that dimension unrestricted. The result is sorted by module name; pagination metadata in the response envelope lets you page through long result sets. Args: - capability (string): capability id, e.g. 'envelope-generator', 'clock-source'. Run a search with NO capability filter to get the full capability taxonomy (ids + labels + counts) in _meta.taxonomy. Retired/variant slugs resolve via the capability_aliases layer (e.g. 'low-pass-gate' → 'lowpass-gate', 'quantiser' → 'quantizer'), so either form is accepted. - manufacturer (string): manufacturer id, e.g. 'make-noise', 'mutable-instruments'. - hp_min, hp_max (number): module width in HP. hp_max=10 finds modules ≤ 10 HP. - signal_type_in (string): the module accepts a jack of this signal type as input. One of audio, cv, gate, trigger, clock, mixed. signal_type_in='audio' and ='cv' both also match jacks tagged 'mixed' (the schema's value for jacks the source describes as accepting both audio and CV — e.g. Joranalogue Compare 2's signal inputs); the other values match literally. - signal_type_out (string): the module produces a jack of this signal type as output. Same 'mixed'-superset semantics as signal_type_in. - text (string): free-text match against module id, name, slug, description, and the ids/labels/descriptions of capabilities the module has (case-insensitive substring). Matches hyphenated forms like "filter-8" against the slug/id even when the display name uses a space ("Filter 8"), and is whitespace-insensitive on id/slug/name so "3x MIA" finds the module named "3xMIA". Capability-label coverage means text="multiband" finds modules tagged multiband-filter without knowing the kebab-case id, and a curated alias layer extends that to common word-form variants ("multi-output" / "multi-band" / "band-split" → multiband-filter, "low-pass" → lowpass-filter, retired ids like "v…

Return canonical synthesis / patching techniques with role-keyed module realizations drawn from the corpus. Use this when the user asks "how do I do X?" with X being a recognisable technique (low-pass-gate plucks, pinged-filter percussion, parallel multiband processing, complex-oscillator FM, karplus-strong pluck, clocked-delay feedback, modal-resonator excitation, wavefolder harmonics, envelope-follower ducking, Maths-style function-generator omnibus). It's also the right tool when the user has a module and asks "what's this good for?" — pass filter.module_id to retrieve every technique that references the module via its role_realizations. Each technique declares role_definitions (the roles the technique uses, each with required and optional affordances) and role_realizations (concrete modules that fill each role, with the affordances they provide). The model substitutes modules from the user's rack into roles by affordance match — DO NOT treat the realization list as exhaustive or as a recipe. Args: - filter (optional): { capability?, module_id?, text? } - capability: kebab-case capability id (see search_modules _meta.taxonomy). Returns techniques whose required *or* optional capability list includes this id. - module_id: "<manufacturer>/<module-slug>". Returns techniques that have a role_realization referencing this module. - text: free-text phrase. Substring-matches against technique id/label/description AND a curated alias table (technique_aliases) — that's the right surface when a user types evocative prose like "stuttering delay", "plucked string", "source of uncertainty" that doesn't grep against any kebab-case id. Two-way alias match: long alias ("source of uncertainty") matches short query ("uncertainty"), and vice versa. - When multiple filters supplied, AND-intersects. - Omit filter entirely to list all techniques. Returns: { "techniques": [ { "id": "low-pass-gate-pluck", "label": "Low-Pass Gate Pluc…

Module visualization tool. Use when the user wants to understand how a module's modes work, how parameters change between modes, or what a specific mode does — a visualization communicates the per-mode behavior better than prose. The host renders the result inline in the chat as an interactive visualization (mode buttons, per-mode descriptions, schematic curves); you do not need to build an artifact yourself — just call this tool. Do not use for general module specs (HP, jacks, capabilities) — call get_module instead. After calling, your prose can reference what the user is seeing in the visualization (e.g. "in formant mode, all three outputs become bandpass filters") rather than describing the visualization itself. Currently supported viz families: - filter_response — filters with characterized response curves (e.g. Three Sisters, Ripples, Belgrad, A-124, Filter 8, QPAS, SVF 1U, Cinnamon, C4RBN, Ikarie) - oscillator_morph — multi-mode oscillators and excited resonators (e.g. Rings, Loquelic Iteritas, Plaits) A module is supported when every one of its modes has a behavior_model_id the renderer knows. If you're unsure whether a given module qualifies, just call this tool — the error names the gap. Errors: - "Module not found: <id>" if no module with that id exists. - "Module not yet supported by visualize_module: <id>" when one or more modes lack a renderer-known behavior_model_id, or when the module mixes incompatible viz families. Suggest get_module for the underlying spec. The returned spec is a JSON object with: module_id, module_name, manufacturer, viz_type, params[], modes[], response_model_id, presets[]. Each mode has a behavior_model_id that the renderer uses to pick the curve set (e.g. crossover_lp_bp_hp vs formant_three_bp for filter_response). `response_model_id` (top-level) vs per-mode `behavior_model_id`: for multi-mode modules the top-level field is intentionally null — each mode carries its own behavior_model_id since the modes use dif…