Connect to Wwise via WAAPI.

Args: url: WebSocket URL (default ws://127.0.0.1:8080/waapi)

Get Wwise application info (version, platform, project).

Query Wwise objects using WAQL.

Args: waql: WAQL query string (e.g. '$ from type sound') return_fields: JSON array of fields to return

Save the current Wwise project.

Execute any WAAPI call directly (escape hatch).

Args: uri: WAAPI function URI (e.g. ak.wwise.core.object.getTypes) args_json: JSON string of arguments options_json: JSON string of options

Create a Wwise object in the hierarchy.

Args: parent_path: Parent object path (backslash-separated, e.g. \Actor-Mixer Hierarchy\Default Work Unit) object_type: Wwise type (Sound, RandomSequenceContainer, Event, etc.) name: Object name on_conflict: Name conflict mode: merge, rename, replace, fail

Set a property on a Wwise object.

Args: object_path: Object path or GUID property_name: Property name (Volume, Pitch, Lowpass, IsLoopingEnabled, etc.) value: JSON-encoded value (number, bool, or string)

Set a reference on a Wwise object (e.g. OutputBus, Attenuation).

Args: object_path: Object path or GUID reference: Reference name (OutputBus, Attenuation, SwitchGroupOrStateGroup, etc.) value: Target object path or GUID

Import audio files into Wwise.

Args: audio_files: JSON array of objects with 'audioFile' and 'objectPath' keys. Example: [{"audioFile": "/path/to/shot.wav", "objectPath": "\Actor-Mixer Hierarchy\Default Work Unit\Shot_01"}] import_operation: createNew, useExisting, or replaceExisting language: Import language (default SFX)

Create a Wwise Event with an Action targeting an object.

Args: name: Event name (e.g. Play_Gunshot_Rifle) target_path: Path to the target object the action acts on action_type: Action type name (Play, Stop, Pause, etc.) event_parent: Parent path for the event (default: Events\Default Work Unit)

Create a Game Parameter (RTPC) in Wwise.

Creates the GameParameter object. To bind it as an RTPC curve on a specific property, use execute_waapi with ak.wwise.core.object.setRTPCCurve or configure the binding in the Wwise Authoring GUI.

Args: name: GameParameter name (e.g. RTPC_Wind_Intensity) min_value: Minimum range value max_value: Maximum range value default_value: Default value

Assign a child object to a switch/state value in a SwitchContainer.

Args: switch_container_path: Path to the SwitchContainer (for context only) child_path: GUID or path of the child to assign switch_value: GUID or path of the switch/state value

Create an Attenuation ShareSet and set its distance curve.

Args: name: Attenuation name curve_type: Curve type (VolumeDryUsage, LowPassFilterUsage, etc.) curve_points: JSON array of {x, y, shape} points parent_path: Parent path (default: Attenuations\Default Work Unit)

Preview a Wwise object (Event, Sound, Container) via transport.

Args: object_path: Path to the object to preview action: Transport action — play, stop, or pause

Generate Wwise SoundBanks.

Args: bank_names: JSON array of bank names to generate (e.g. ["Weapons_Bank", "UI_Bank"])

Create a complete AAA Wwise project structure (Bjorn Jacobson method).

Creates separate Work Units for merge-safe version control, structured bus hierarchy for clear signal routing, and switch/state groups for runtime control.

Naming convention: Type_Owner_Category_Action_Material_Variation Example: sfx_plyr_loc_walking_dirt_01

Everything goes into dedicated Work Units — nothing in Default Work Unit.

Args: bus_structure: JSON override for bus tree (default: AAA standard with AmbientMaster, NPCMaster, PlayerMaster, UIMaster, MusicMaster, Reverbs) actor_work_units: JSON array of Actor-Mixer Work Unit names (default: Player_Locomotion, Player_Weapons, NPC_Locomotion, NPC_Voice, Ambience, UI, Music) event_work_units: JSON array of Event Work Unit names (default: Player, NPC, Locomotion, Ambience, UI, Music) switch_groups: JSON dict of SwitchGroup name -> values array (default: Surface_Type, Footstep_Type) state_groups: JSON dict of StateGroup name -> values array (default: Weather, PlayerState, Zone) include_reverbs: Create Reverb AuxBuses (LargeRoom, SmallRoom, Cave, Outdoor)

Create a complete gunshot system: RandomSequenceContainer + Sound children + Event.

Args: weapon_name: Weapon name (used in object naming) num_variations: Number of sound variation slots to create pitch_randomization: Pitch randomization range in cents (stored as note)

Create a surface-switched footstep system: SwitchGroup + SwitchContainer + per-surface RandomSeq + Event.

Args: surface_types: JSON array of surface type names with_switch_group: Create the SwitchGroup (set false if it already exists)

Create an RTPC-driven ambient blend system: GameParameter + BlendContainer + looped Sounds + Event.

Args: layer_names: JSON array of layer/sound names rtpc_parameter_name: Name for the RTPC GameParameter

Create a non-spatial UI sound: ActorMixer(UI) + Sound + Event + bus routing.

Args: sound_name: Name for the UI sound bus_path: Output bus path (default: Master Audio Bus)

Create a state-driven weather ambient system: StateGroup + SwitchContainer + per-state Sounds + Event.

Args: weather_states: JSON array of weather state names

List MetaSounds nodes, optionally filtered by category or tag.

Args: category: Filter by category (e.g. "Filters", "Generators") tag: Filter by tag (e.g. "underwater", "oscillator")

Returns: JSON with node list including name, category, description, and pin counts.

Get full details for a specific MetaSounds node.

Args: node_name: Exact node name (e.g. "Biquad Filter", "Wave Player (Mono)")

Returns: JSON with complete node definition including all pins and defaults.

Semantic search for MetaSounds nodes by description or purpose.

Uses TF-IDF embeddings for meaning-based search with tag fallback. Examples: "underwater effect", "random variation", "smooth transition"

Args: query: Natural language search query

Returns: JSON with ranked results (name, score, category, description).

List all MetaSounds node categories with counts.

Returns: JSON with category names and node counts.

Validate a MetaSounds graph specification.

Checks node types exist, pin names are valid, type compatibility, required inputs are connected, no duplicate IDs.

Args: graph_spec: JSON string of the graph specification

Returns: JSON with validation result: errors list (empty = valid).

Convert a validated graph spec to Builder API command sequence.

The command sequence can be sent to the UE5 plugin (Phase 3) to construct the MetaSound asset via the Builder API.

Args: graph_spec: JSON string of a valid graph specification

Returns: JSON with ordered command list for the Builder API.

Generate a complete graph spec from a template.

Templates are auto-discovered from the metasounds template directory.

Args: template_name: Template name (e.g. "gunshot", "footsteps") params: JSON string of template parameters (overrides defaults)

Returns: JSON with the complete graph specification ready for validation.

Connect to the UE5 audio plugin via TCP.

Args: host: Plugin host address (default 127.0.0.1) port: Plugin TCP port (default 9877)

Get UE5 engine info (version, project, features).

Get combined status of Wwise and UE5 plugin connections.

Duplicate a UE5 asset from source to destination path.

Copies any asset (MetaSounds, Blueprints, SoundWaves, etc.) to a new location. Useful for cloning existing assets as starting points for modification.

Args: source_path: Source asset path (e.g. /Game/Audio/Foley/MetaSounds/MSS_FoleySound_Walk) dest_path: Destination asset path (e.g. /Game/Audio/Creatures/MSS_Creature_Walk)

Validate a graph spec, convert to Builder commands, and send all to UE5.

This is the high-level tool that does everything: validate, convert, and execute the full command sequence via the UE5 plugin.

Args: graph_spec: JSON string of the MetaSounds graph specification

Create a new MetaSounds source builder in UE5.

Args: name: Name for the MetaSound asset asset_type: Asset type — Source, Patch, or Preset

Add a MetaSounds node to the current graph.

Args: node_type: Node type name (e.g. "Sine", "Wave Player (Mono)") node_id: Unique ID for this node instance position_x: Editor X position position_y: Editor Y position

Connect two node pins in the current MetaSounds graph.

Args: from_node: Source node ID from_pin: Source output pin name to_node: Destination node ID to_pin: Destination input pin name

Set a default value for a node input pin.

Args: node_id: Node instance ID input_name: Input pin name value: Default value (JSON-encoded for complex types)

Build the current MetaSounds graph to a UE5 asset.

Args: name: Asset name path: Content path (default /Game/Audio/Generated/)

Open the last built MetaSound asset in the UE5 MetaSounds editor.

Must call ms_save_asset first to create a .uasset on disk. Opens the graph editor showing all nodes and connections visually.

Convert the current MetaSounds builder to a preset of a referenced asset.

The builder's graph becomes read-only, inheriting the referenced asset's topology. Only exposed input defaults can be overridden.

Args: referenced_asset: Content path of the source MetaSound (e.g. /Game/Audio/MySynth)

Preview/audition the current MetaSounds graph in the editor.

Args: name: Optional asset name to audition (empty = current)

Stop any currently playing MetaSounds audition preview.

Export a complete MetaSounds graph from UE5 — nodes, pin types, defaults, variables, interfaces.

Returns the full graph data. Optionally converts to our reusable template format.

Args: asset_path: Content path of the MetaSound asset (e.g. /Game/Audio/MySound) convert_to_template: If True, also convert the export to template format

Sync MetaSounds node catalogue from the running UE5 engine.

Calls the list_metasound_nodes command to get ALL registered node classes with their complete pin specs directly from the engine registry. Updates the in-memory METASOUND_NODES dict and optionally the SQLite DB.

Args: update_db: If True, also upsert nodes into the SQLite knowledge DB filter: Optional substring filter for node class names limit: Max nodes to fetch (default 5000)

Returns: JSON summary: total nodes, new nodes added, existing nodes updated, categories.

Search Blueprint nodes by name or description.

Searches across curated and scraped Blueprint data.

Args: query: Search term (matched against name and description) category: Optional category filter source: Data source — "all", "curated", or "scraped"

Get full Blueprint node info including pin specs.

Prefers scraped data (richer pin info), falls back to curated.

Args: node_name: Exact node name (e.g. "PlaySound2D", "SpawnSoundAtLocation")

List Blueprint node categories with counts.

Args: source: Data source — "all", "curated", or "scraped"

List project assets by class type via the UE5 plugin.

Queries the Asset Registry for all assets matching the given class under the specified path. Useful for discovering Blueprints, MetaSounds, SoundWaves, etc. before scanning.

Requires the UE5 C++ plugin to be running.

Args: class_filter: Asset class name — Blueprint, MetaSoundSource, SoundWave, etc. path: Path prefix to search under (default: /Game/) limit: Max results to return (default: 5000)

Deep-scan a Blueprint asset to extract graph nodes, function calls, and audio relevance.

Inspects all graphs (event graphs, function graphs, macros) and classifies each node by type: CallFunction, Event, CustomEvent, VariableGet/Set, etc. Detects audio-relevant nodes (PlaySound, PostEvent, AudioComponent refs).

Requires the UE5 C++ plugin to be running.

Args: asset_path: Blueprint asset path (e.g. "/Game/Blueprints/BP_Character") audio_only: If True, only return audio-relevant nodes include_pins: If True, include full pin details per node

Export the audio-relevant subgraph from a Blueprint with full edge wiring.

Returns only audio nodes + their 1-hop neighbours, with pin data and connections between them. Useful for understanding how Blueprint events drive MetaSounds/Wwise parameters.

Requires the UE5 C++ plugin to be running.

Args: asset_path: Blueprint asset path (e.g. "/Game/Blueprints/BP_Character")

Execute a Blueprint function via the UE5 plugin.

Args: function_name: Blueprint function name to call args_json: JSON string of function arguments

Add a graph variable to the current MetaSounds builder (UE 5.7+).

Graph variables store state within a MetaSound graph, readable and writable by Get/Set Variable nodes.

Args: name: Variable name (must be unique within the graph) type: Data type (Float, Int32, Bool, Trigger, Audio, Time, String) default_value: Optional default value as string

Add a Get, Set, or GetDelayed variable node to the current graph.

Args: node_id: Unique ID for this node instance variable_name: Name of the graph variable to access mode: Access mode — "get" (read current), "set" (write), or "get_delayed" (read previous frame)

Create a preset variant from an existing MetaSound asset.

A preset shares the referenced asset's graph topology but overrides specific input defaults. Use this to create weapon/surface/character variants without duplicating the graph.

Args: preset_name: Name for the new preset asset referenced_asset: Content path of the source MetaSound to reference overrides_json: JSON object of input_name -> value overrides asset_path: Content path for the output asset

Build a MetaSound Source that morphs between two parameter sets.

Creates a Source with a Morph input (0.0-1.0) that smoothly interpolates each parameter between set A (Morph=0) and set B (Morph=1). Uses Map Range nodes for each parameter and InterpTo for smooth transitions.

Args: name: Name for the morph MetaSound asset param_set_a_json: JSON object of param_name -> value at Morph=0 param_set_b_json: JSON object of param_name -> value at Morph=1 asset_path: Content path for the output asset

Execute a named sequence of parameter changes and/or preset swaps.

Each step is a dict with:

• "action": "set_default" or "convert_to_preset"

• Plus action-specific fields (node_id/input/value or referenced_asset)

Useful for cinematic audio cues, dynamic music transitions, and scripted sound design sequences.

Args: name: Descriptive name for this macro sequence steps_json: JSON array of step dicts

Open a Blueprint asset for editing via the UE5 plugin.

Must be called before adding nodes or connecting pins. Resets any previously registered node handles.

Args: asset_path: Blueprint asset path (e.g. "/Game/Blueprints/BP_Character")

Add a node to the active Blueprint's event graph.

Supports 4 node kinds:

• CallFunction: Audio-allowlisted functions (SetFloatParameter, PlaySound2D, etc.)

• CustomEvent: User-defined events

• VariableGet: Read a Blueprint variable (must pre-exist)

• VariableSet: Write a Blueprint variable (must pre-exist)

Args: node_id: Unique ID for this node (used in connect/set_pin calls) node_kind: One of: CallFunction, CustomEvent, VariableGet, VariableSet function_name: Required for CallFunction — the function to call event_name: Required for CustomEvent — the event name variable_name: Required for VariableGet/VariableSet — the variable name position_x: Editor X position position_y: Editor Y position

Connect two pins between registered Blueprint nodes.

Both nodes must be registered (via bp_add_bp_node or bp_register_existing).

Args: from_node: Source node ID from_pin: Source output pin name to_node: Destination node ID to_pin: Destination input pin name

Set a default value on a Blueprint node's input pin.

Args: node_id: Registered node ID pin_name: Input pin name value: Default value as string

Compile the active Blueprint.

Returns compile status and any compiler messages. Must have called bp_open_blueprint first.

Register an existing Blueprint node by its GUID so it can be wired to.

Use bp_scan_blueprint with include_pins=true to find node GUIDs, then register them here before connecting pins.

Args: node_id: MCP handle ID you want to use for this node node_guid: The node's FGuid string from the Blueprint scan

List all pins on a registered Blueprint node.

Returns pin name, direction, type, default value, and connection status.

Args: node_id: Registered node ID

High-level: wire a SetFloatParameter call into a Blueprint.

Opens the Blueprint, optionally registers a source node, adds a SetFloatParameter call, sets the parameter name, connects the source if provided, and compiles.

Args: asset_path: Blueprint asset path param_name: MetaSounds parameter name (e.g. "Speed", "Intensity") source_node_guid: Optional GUID of existing node to wire as value source source_pin: Output pin name on the source node for the float value

Sync Blueprint function catalogue from the running UE5 engine.

Calls list_blueprint_functions to enumerate all BlueprintCallable UFunctions with their parameter signatures directly from the engine. Optionally upserts results into the blueprint_nodes_scraped SQLite table.

Args: audio_only: Only fetch audio-relevant functions (default True) update_db: If True, upsert into the SQLite blueprint_nodes_scraped table filter: Optional substring filter on function or class name class_filter: Optional exact class name filter limit: Max functions to fetch (default 10000)

Returns: JSON summary: total functions, classes found, new vs updated counts.

Build a complete 3-layer audio system (Wwise + MetaSounds + Blueprints) from a pattern.

Auto-detects which backends are connected and degrades gracefully:

• Full (Wwise + UE5): executes everything, returns created IDs

• Wwise-only: executes Wwise, returns MetaSounds commands for later

• Offline: returns all 3 layer specs as JSON (dry-run preview)

Available patterns: gunshot, footsteps, ambient, spatial, ui_sound, weather, preset_morph, macro_sequence, sfx_generator, vehicle_engine.

Args: pattern: Pattern name (e.g. "gunshot", "footsteps") name: Asset name prefix (defaults to pattern name) params_json: JSON overrides for all 3 layers, e.g. {"wwise": {"num_variations": 5}}

Build a complete AAA audio project: infrastructure + content for all categories.

Creates AAA Wwise infrastructure (buses, work units, switches, states), then generates 3-layer content (Wwise + MetaSounds + Blueprints) for each audio category, routes outputs to correct buses, and moves objects to dedicated work units.

Auto-detects connection state:

• Full (Wwise + UE5): creates infrastructure, builds all content, routes + moves

• Wwise-only: creates infrastructure, builds Wwise content, returns MS commands

• Offline: returns complete manifest of what would be created (dry-run)

Args: categories: Comma-separated category filter (default: all). Available: player_footsteps, player_weapons, npc_footsteps, ambient_wind, weather, ui setup_params: JSON overrides for template_aaa_setup, e.g. {"include_reverbs": false}

Place an AnimNotify_PlaySound on an animation at a specific time.

This is the proper way to sync sounds to animation frames (e.g. footsteps at the exact moment each foot hits the ground).

Args: animation_path: Animation asset path (e.g. "/Game/Characters/Anims/Walk") time: Time in seconds where the notify fires sound: Optional SoundBase asset path to play notify_name: Name for the notify event (default "Footstep")

Place a Blueprint-based AnimNotify on an animation at a specific time.

Unlike place_anim_notify (which creates engine AnimNotify_PlaySound), this places BP AnimNotify classes that can do surface detection, line traces, and material-based sound selection — the Lyra footstep pattern.

Args: animation_path: Animation asset path (e.g. "/Game/Characters/Anims/Walk") time: Time in seconds where the notify fires notify_blueprint_path: Blueprint AnimNotify asset path (e.g. "/Game/Blueprints/AnimNotifies/BP_AnimNotify_FoleyEvent_Walk_L") notify_name: Name for the notify event (default "BPNotify")

Spawn a persistent AmbientSound actor at a world location.

Creates a spatial audio source that gets louder as the player approaches. Perfect for environmental sounds (campfire, waterfall, machinery).

Args: sound: SoundBase/MetaSound asset path (e.g. "/Game/Audio/Ambient/Fire") location: World position as [x, y, z] name: Label for the emitter actor auto_play: Whether to start playing immediately (default True)

Import a .wav or .ogg sound file from disk into the UE5 Content folder.

Args: file_path: Absolute path to the audio file on disk dest_folder: Destination folder in Content (e.g. "/Game/Audio/SFX")

Set the surface type on a Physical Material (creates it if needed).

Surface types drive material-dependent sounds — e.g. footsteps on grass vs metal vs wood produce different sounds.

Args: material_path: Physical Material asset path (e.g. "/Game/Materials/PM_Grass") surface_type: Surface type name (e.g. "Grass", "Metal", "Wood", "SurfaceType1")

Place an AudioVolume actor — defines an ambient audio zone.

When the player enters this volume, reverb/interior settings activate. Use for rooms, caves, outdoor areas with different acoustic properties.

Args: location: World position as [x, y, z] extent: Half-size of the volume box as [x, y, z] (default [500,500,500]) name: Label for the volume actor reverb_effect: Optional ReverbEffect asset path priority: Volume priority (higher = takes precedence when overlapping)

Spawn an instance of a Blueprint actor into the editor level.

Use this to place a character/object in the scene so you can see it while wiring up audio. Great for demos and iterative sound design — spawn it, open its Blueprint, wire sounds, compile, hear it live.

Args: blueprint_path: Blueprint asset path (e.g. "/Game/Blueprints/BP_Creature") location: World position as [x, y, z] (default origin) rotation: Rotation as [pitch, yaw, roll] in degrees (default zero) label: Optional display label for the spawned actor

Find actors in the current editor or PIE world.

Args: query: Optional label/name/path substring. class_filter: Optional class-name substring, e.g. "Character", "CameraActor". limit: Maximum actors to return, clamped by the plugin.

Move and/or rotate an actor in the current editor or PIE world.

Args: actor: Actor label, object name, or full path returned by find_actor. location: Optional world position as [x, y, z]. rotation: Optional rotation as [pitch, yaw, roll] in degrees. focus_camera: Also frame the actor in the active editor viewport.

Frame an actor in the Unreal Editor viewport camera.

Args: actor: Actor label, object name, or full path returned by find_actor. active_viewport_only: When true, move only the active viewport camera.

Set the runtime player camera view target to an actor.

This is intended for PIE/simulation. Use focus_editor_camera for the editor viewport.

Args: actor: Actor label, object name, or full path returned by find_actor. blend_time: Camera blend duration in seconds. player_index: Local player/controller index.

Possess a Pawn/Character with a runtime player controller.

Args: actor: Pawn/Character label, object name, or full path returned by find_actor. player_index: Local player/controller index. set_view_target_on_possess: Also set the possessed pawn as the camera target.

Query past session log events with optional filters.

Args: session_id: Filter by session ID event_type: Filter by type (tool_call, waapi_call, tcp_command, session_start, session_end) tool_name: Filter by tool name since: ISO date string — only events after this timestamp status_filter: Filter by result status (ok, error) limit: Max rows to return (default 50, max 500) summary_only: If true, return per-session aggregates instead of raw events

Get overall session logging statistics.

Returns total sessions, event counts by type, error rate, and top 10 most-used tools.