Set a single keyframe on a parameter.

Args: node_path: Node path. parm_name: Parameter name. frame: Frame number. value: Value at this keyframe. slope: Tangent slope. accel: Acceleration.

Batch-set multiple keyframes on a parameter.

Args: node_path: Node path. parm_name: Parameter name. keyframes: List of dicts with "frame", "value", and optionally "slope"/"accel".

Delete a keyframe at a specific frame.

Args: node_path: Node path. parm_name: Parameter name. frame: Frame number to delete.

Get all keyframes on a parameter.

Args: node_path: Node path. parm_name: Parameter name.

Set the current frame in the timeline.

Args: frame: Frame number.

Get the current frame and FPS.

Set the global frame range.

Args: start: Start frame. end: End frame.

Set the playback range (green bar in the timeline).

Args: start: Start frame. end: End frame.

Control playback: play, stop, or reverse.

Args: action: One of "play", "stop", or "reverse". real_time: Enable or disable real-time playback. fps: Frames per second.

List all cache-type nodes under a root path.

Args: ctx: MCP context. root_path: Root path to search from.

Frames on disk for a cache node, against the range it is set to write.

This is what to poll after a background write_cache: complete is true when every frame of expected_range is on disk, missing_frames lists the rest, writing is true while files are still arriving, and hint tells you when the finished cache is not yet loaded from disk. Never wait for a cache with a shell loop; call this between other work.

Args: ctx: MCP context. node_path: Path to the cache node.

Delete cached files on disk for a cache node.

Args: ctx: MCP context. node_path: Path to the cache node. frame_range: [start, end] frame range to limit deletion.

Execute a cache node, and report whether a cache actually appeared.

Foreground by default: Houdini shows its own progress dialog and the user can cancel. The call holds until the write finishes, however long that is; a client that hands a long call to a background task notifies you with the verdict when it lands. Do nothing else in Houdini meanwhile (every other call queues behind the write) and never poll the disk.

success and wrote_files reflect the files on disk and the errors of the node that did the writing -- a filecache delegates to an internal ROP and stays silent itself, so a failed write used to be reported as success. Errors are named with the node they came from.

Args: ctx: MCP context. node_path: Path to the cache node. frame_range: [start, end] frame range to render. Overrides the node's $FSTART/$FEND expressions for this and later writes. background: Save from a separate Houdini process (File Cache's own "Save to Disk in Background") so Houdini stays usable, at the cost of the user seeing no progress there. Saves the hip first, returns at once with status "launched"; follow it with get_cache_status. Use it only when asked to keep working while a cache writes. A verified foreground write turns the node's Load from Disk on.

Get CHOP node track data.

Args: node_path: CHOP node path. channel_name: Specific channel to retrieve. start: Start sample index. end: End sample index.

Create a new CHOP node.

Before using this, call list_node_types(context='Chop', filter='') to verify the correct node type. CHOPs has many dedicated nodes for motion and timing — noise, wave, spring, jiggle, lag, limit, filter, math, function, blend, shift, stretch, trim, cycle, speed, constraintlookatat, constraintpath — that may already do what you need.

Args: parent_path: Parent network path. chop_type: CHOP node type to create. name: Node name override.

List all channels on a CHOP node.

Args: node_path: CHOP node path.

Export a CHOP channel to a parameter via a chop() expression.

Args: chop_path: CHOP node path. channel_name: Channel to export. target_node_path: Target node path. target_parm_name: Parameter to receive the export.

Execute arbitrary Python code inside Houdini. LAST RESORT only.

DO NOT use this to:

• Create nodes or networks → use build_network or create_node

• Set parameters → use set_parameter or set_parameters

• Create wrangles or write Python SOPs → use create_wrangle

• Connect nodes → use connect_nodes or connect_nodes_batch

• Read geometry → use get_geometry_info, get_points, sample_geometry

ONLY use this when no dedicated tool exists for the operation — i.e. hou.* API calls or Python-level state that no other tool exposes. The justification parameter is mandatory: name the dedicated tools you considered and why none covers this operation.

Args: code: Python source code to execute. justification: Which dedicated tools you considered and why none covers this operation. return_expression: Python expression to evaluate after execution.

Execute an HScript command in Houdini.

Args: command: HScript command string to execute.

Evaluate an expression in Houdini and return its result.

Args: expression: Expression string to evaluate. language: Expression language, "hscript" or "python".

Get a Houdini environment variable value.

Args: var_name: Name of the environment variable.

Every file path the scene references, with the parameter holding it and whether it exists.

Args: ctx: MCP context. include_missing_only: Only report paths that are missing on disk.

Set Houdini's cook update mode, or read it when called with no mode.

"manual" before a long build stops every parameter change from re-cooking; set "auto" back afterwards.

Args: ctx: MCP context. mode: "auto", "on_mouse_up" or "manual". Omit to read.

Get a compact overview of a network.

Keep depth low (1–2). Larger values on complex scenes return thousands of nodes and can overflow the context window.

Args: path: Network path. depth: Recursion depth (default 2, keep ≤ 3).

Trace the cook dependency chain for a node.

Args: node_path: Node path.

Explain a node in human-readable form.

Args: node_path: Node path.

Get the current node selection.

Set the node selection.

Args: node_paths: Node paths to select.

Get a high-level summary of the scene.

Take or compare scene state snapshots.

Args: action: "take" or "compare". snapshot_name: Snapshot name.

Get detailed error analysis for nodes.

Args: node_path: Node to analyze, or scan from root_path if omitted. root_path: Root path to scan.

Get information about a COP node.

Args: node_path: Path to the COP node.

Get geometry representation from a COP node.

Args: node_path: Path to the COP node. output_index: Output connector index.

Get image layer data from a COP node.

Args: node_path: Path to the COP node. output_index: Output connector index.

Create a COP node in the specified network.

Before using this, call list_node_types(context='Cop', filter='') for Copernicus nodes (Houdini 20+), or context='Cop2' for legacy COPs. Copernicus is the modern image processing system and is preferred over COP2 (deprecated as of Houdini 20.5). COPs has many dedicated image-processing nodes — blur, sharpen, levels, contrast, over, multiply, luminance, premultiply, channelcopy, noise, ramp, fractalnoise, worleynoise, rasterizegeo, heighttonormal, sdfshape — that may cover the operation without needing a VEX COP or Python.

Args: parent_path: Path to the parent COP network. cop_type: COP node type to create. name: Override node name.

Set flags on a COP node.

Args: node_path: Path to the COP node. display: Display flag state. export_flag: Render/export flag state. compress: Compress flag state.

List available COP node types.

Args: filter: Substring filter for node type names.

Get VDB volumetric data from a COP node.

Args: node_path: Path to the COP node. output_index: Output connector index.

Get DOP network simulation state.

Args: node_path: DOP network node path.

List all DOP objects in a simulation.

Args: node_path: DOP network node path.

Get detailed data for a specific DOP object.

Args: node_path: DOP network node path. object_name: DOP object name.

Read a specific field value from a DOP record.

Args: node_path: DOP network node path. object_name: DOP object name. data_path: Dot-separated subdata path (e.g. "Geometry", "Forces/Gravity"). field_name: Field name to read.

List all relationships between DOP objects.

Args: node_path: DOP network node path.

Advance the simulation by a number of frames.

Args: node_path: DOP network node path. steps: Number of frames to advance.

Reset the simulation to its initial state.

Args: node_path: DOP network node path.

Get detailed memory breakdown for the simulation.

Args: node_path: DOP network node path.

Get geometry summary for a SOP node.

Args: node_path: Node path. output_index: Which output to read, for nodes with several (FLIP compress, Vellum solver, whitewater source): 0 is the first.

Read point positions and attributes with pagination.

Args: node_path: Node path. attributes: Attribute names to read. start: Start index. count: Max points per page. group: Point group filter.

Read primitive data and attributes with pagination.

Args: node_path: Node path. attributes: Attribute names to read. start: Start index. count: Max prims per page. group: Prim group filter.

Read attribute values as a flat array with pagination.

For spot-checking a few values prefer sample_geometry — it returns a representative spread of points with all their attributes in one call. Use get_attrib_values when you need a specific slice of one attribute.

Values are element-major: for a float3 attribute every 3 consecutive values belong to one element. Check has_more and increment start to read subsequent pages.

Args: node_path: Node path. attrib_name: Attribute name. attrib_class: "point", "prim", "vertex", or "detail". start: First element index to return. count: Max elements per page (default 200).

Set a detail attribute on a SOP node.

Appends an Attribute Create SOP after the node and moves the display flag to it; the result includes the new node's path.

Args: node_path: Node path. attrib_name: Attribute name. value: Value to set.

List all geometry groups on a SOP node.

Args: node_path: Node path.

Get element indices in a geometry group, with pagination.

Check has_more and increment start to read subsequent pages.

Args: node_path: Node path. group_name: Group name. group_type: "point", "prim", or "edge". start: First element index to return. count: Max elements per page (default 5 000).

Get the bounding box of a SOP node's geometry.

Args: node_path: Node path.

Get metadata for a geometry attribute.

Args: node_path: Node path. attrib_name: Attribute name. attrib_class: "point", "prim", "vertex", or "detail".

Sample evenly distributed points from a SOP node's geometry.

Args: node_path: Node path. sample_count: Number of points to sample. seed: Random seed.

Get intrinsic values for primitives.

Args: node_path: Node path. prim_index: Primitive index, or None for a summary.

Find the nearest point(s) to a given position.

Args: node_path: Node path. position: Query position as [x, y, z]. max_results: Max nearest points to return.

Aggregate statistics for numeric attributes: min, max, mean, sum.

Use this to prove something is happening, rather than reading values. get_geometry_info names the attributes; get_attrib_values returns every value, which on a 60k-point cache tells you nothing you can read. Vector attributes also report per-component ranges, so a velocity field's per-axis extremes come back in the same call.

Args: node_path: SOP node path. attribs: Attribute names. Omit for every attribute of the class. attrib_class: "point", "prim" or "detail".

Per-volume name, resolution, active voxel count and value range.

A primitive count cannot tell a correctly named non-empty density field from an empty one, which is the question worth asking before wiring a solver's sourcing. This is the SOP counterpart of get_cop_vdb.

Args: node_path: SOP node path holding volume or VDB primitives. max_volumes: Cap on volumes reported.

Build a whole node network in ONE atomic call — the PREFERRED way to construct anything of 3+ nodes (massively faster than node-by-node calls, and either the whole network builds or nothing does).

Every node type, parameter name, and input reference is validated against the running Houdini BEFORE anything is created; errors come back with did-you-mean suggestions. Use dry_run=True to prove a plan when using unfamiliar node types. The result includes cooked evidence: per-node errors and the display node's geometry counts — read them instead of assuming success.

Each node spec dict supports: type (required), name, parms (lists set whole parm tuples), inputs (list of source names — earlier spec names, existing children, or absolute paths; or dicts with index or input_name / source / source_output, where input_name is a connector name or label as get_node_card lists them; or {"indirect_input": n} to wire from connector n of the parent subnet itself), flags (display/render/bypass/ template), color [r,g,b], comment.

Args: parent_path: Network to build inside (e.g. "/obj/geo1"). nodes: Ordered node specs (see above). dry_run: Validate the whole spec without creating anything. layout: Also lay out the parent network afterwards (default True; honoured only when auto-layout is enabled). The nodes this call creates are always positioned, each relative to its inputs, regardless of this flag; nodes that already existed keep their exact positions, so building into a hand-arranged network is safe.

Inspect every node in a network at once — errors, warnings, flags, and the display node's cooked geometry counts.

Call this after building or modifying a network, the way an artist middle-clicks nodes: if healthy is false or error_nodes is non-empty, fix those nodes before telling the user anything is done.

Args: parent_path: Network to verify (e.g. "/obj/geo1").

Get the authoritative documentation card for a node type, straight from the running Houdini: connectors in order (inputs / outputs with index, name and label — the index of texcoord on mtlximage lives here), real parameter names/defaults/menus, and the node's own shipped help text. Connectors are read off a probe node the first time a type is asked for in a session (no undo entry, creation scripts not run); connectors_probed: false with connectors_note means they could not be read, not that the type has none.

Use this BEFORE setting parameters on a node type you have not used in this session — never guess parameter names. Unversioned names resolve to the newest version.

Args: node_type: Type name (e.g. "scatter", "rbdbulletsolver"). context: Category — "Sop", "Lop", "Vop" (MaterialX and other shader nodes inside a material network), "Dop", "Cop", "Chop", "Top", "Object", "Driver"; also "Cop2", "Shop", "VopNet". parm_filter: Substring filter for the parameter list. include_help: False drops the help text (about 4 KB per card) when only parameter names or connectors are needed.

Profile cooking and rank the most expensive nodes — how a senior artist finds the slow node instead of guessing.

Records a performance-monitor profile while force-cooking the display outputs under root_path. cook_ms is cumulative (parents include their children), so compare siblings to locate the hotspot.

Args: root_path: Network to profile (a geo container, or "/" broadly). frame: Optionally jump to this frame before cooking. limit: Max nodes to return.

Cook a node frame by frame and report what changed on each frame.

This is how you advance a sequential solver and how you prove a simulation is doing something. Frames are cooked in order, so a SOP solver, a DOP network or an animated chain all accumulate correctly, and per-frame cook time, errors, counts and attribute aggregates come back in ONE round trip instead of one per frame.

Prefer this over set_frame in a loop, and over stepping by hand: a 100-frame check is one call rather than 100. The frame is left where the cook ended, ready to screenshot.

Args: node_path: Node to cook; its output is what gets measured. start: First frame. Defaults to the playbar start. end: Last frame, inclusive. Defaults to the playbar end. step: Frame increment. Keep at 1.0 for any solver, since skipping frames gives it a discontinuous time step and invalid results. attribs: Point attributes to aggregate per frame (min/max/mean/sum). volumes: Also report per-volume name, resolution and value range.

Whether a node has cooked, how often, and whether it is time dependent.

Note the shape of the limitation: every command runs on Houdini's main thread, so a long cook blocks the bridge and cannot be polled while it runs. This answers the after-the-fact question instead -- did it really recook, is it time dependent, did it end in error -- plus whether the hip has unsaved changes. For asynchronous work use a ROP's background execution and get_render_progress.

Args: node_path: Node to report on.

List all installed HDA files and their definitions.

Args: ctx: MCP context. filter: Substring filter for type names or file paths.

Get detailed information about an HDA definition.

Args: ctx: MCP context. node_path: Node path. hda_file: HDA file path. type_name: HDA type name.

Install an HDA file into the current session.

Args: ctx: MCP context. file_path: HDA file path. force: Force reinstall even if already loaded.

Uninstall an HDA file from the current session.

Args: ctx: MCP context. file_path: HDA file path.

Reload an HDA file from disk.

Args: ctx: MCP context. file_path: HDA file path.

Create a new HDA from an existing subnet node.

Args: ctx: MCP context. node_path: Subnet node path. hda_file: Destination HDA file path. type_name: Operator type name. label: Human-readable label. version: Version string.

Save the current node contents back to its HDA definition.

Args: ctx: MCP context. node_path: Node path.

List all sections in an HDA definition.

Args: ctx: MCP context. node_path: Node path.

Read the content of a specific section in an HDA definition.

Args: ctx: MCP context. node_path: Node path. section_name: Section name.

Write content to a specific section in an HDA definition.

Args: ctx: MCP context. node_path: Node path. section_name: Section name. content: Section content.

Every installed definition of an HDA node's type: version, file, which is current.

Args: ctx: MCP context. node_path: An HDA instance.

Author an HDA's Type Properties interface in one call.

Use this for the asset's TYPE interface — tab folders, strict ranges, ordered menus, Hide/Disable When. create_spare_parameter is a different thing: it adds parameters to one node instance and never reaches the type.

Each entry of parameters is a dict: name, label, type (int|float|string|toggle|menu|folder), default, min, max, min_strict, max_strict, components, menu_items ([value, label] pairs or plain strings), folder_type (tabs|simple|collapsible|radio) + children for folders, hide_when / disable_when (Houdini conditionals), help.

Example — a Controls tab whose Bevel disappears for a single stud: [{"name": "controls", "label": "Controls", "type": "folder", "children": [ {"name": "stud_count", "type": "int", "default": 4, "min": 1, "max": 8, "min_strict": True, "max_strict": True}, {"name": "bevel", "type": "float", "default": 0.02, "min": 0.0, "max": 0.1, "hide_when": "{ stud_count == 1 }"}, {"name": "material", "type": "menu", "menu_items": [["plastic", "Plastic"], ["metal", "Metal"]]}]}]

It is edit_hda_interface with one insert per entry: names already in the interface are refused before anything is written, and the reply is read back off the definition — ops[].stored, renamed_by_houdini (a tab folder joins the existing tab set's naming series), not_found_after_write and instance_parms_missing.

Args: ctx: MCP context. node_path: An instance of the HDA whose definition is edited. parameters: Interface spec (see above). create_spare_parameters' spelling (parm_name, parm_type, default_value) is accepted too. replace: Start from an empty interface. Built-in parameters of the node type cannot be removed: Houdini puts them back (reinstated_by_houdini). dry_run: Validate and report the plan without writing.

Edit an HDA's EXISTING Type Properties interface in one atomic call: insert at a position, remove, hide/show, replace, modify, move.

set_hda_interface only appends. Every op here works on the definition's parameter group; all ops are applied to a copy, the result is checked for component-name collisions, and it is written once — a failing op changes nothing. Read the interface first with get_parm_template_tree.

Ops (dicts, applied in order): {"op": "insert", "spec": {...}, "after": name | "before": name | "in_folder": label or [labels]} — omit the position to append. spec is a set_hda_interface spec, plus types button (with "callback", Python by default), separator, label, vector, color, file, oppath; and fields naming_scheme (base1|xyzw|rgba|minmax| startend|uvw), default_expression, hidden, join_with_next, callback, tags; folder_type "multiparm" for a multiparm block (children named "item#"). {"op": "remove", "name": name_or_folder_label} {"op": "hide" | "show", "name": ...} {"op": "replace", "name": ..., "spec": {...}} {"op": "modify", "name": ..., <label | help | default | default_expression | min | max | min_strict | max_strict | hide_when | disable_when ("" clears) | hidden | join_with_next | menu_items | callback | naming_scheme | new_name | tags>} ("rename", "set_conditional", "set_default" are aliases) {"op": "move", "name": ..., "after" | "before" | "in_folder": ...}

Names are template names (t, not tx; stud_count); folders are addressed by label ("Controls"). Built-in parameters of the node type (an Object's Transform) cannot be removed — Houdini re-adds them at the top level and the reply says so in reinstated_by_houdini; hide them.

Args: ctx: MCP context. node_path: An instance of the HDA whose definition is edited. ops: Operations, in order. dry_run: Validate and report the plan without writing.

Search the running Houdini's own documentation — concepts, workflows, VEX functions, expression functions, HOM API, and every effects manual SideFX ships. Version-exact, straight from the install.

Use this BEFORE improvising: when unsure how a workflow is meant to be done ("pyro shaping", "vellum constraints"), what a VEX or expression function does, or what a Solaris/TOPs concept means. Follow up with get_help_page on a result path.

Args: query: Search words (all must match a page). scope: Optional corpus, named after the archive. Every help archive in the install is searchable, which on a full 22.0 is 47 of them. The ones worth knowing by name: "nodes", "vex", "expressions", "hom", "solaris", "tops", plus the workflow manuals "pyro", "fluid", "vellum", "destruction", "grains", "crowds", "model", "copy", "assets", "render", "shade", "anim", "character", "ref", "shelf". Omit to search all. limit: Max results.

Fetch one page of Houdini's shipped documentation by path.

Read the real reference instead of writing from memory — especially the VEX function pages (vex/functions/...) before any justified wrangle, and expression pages (expressions/...) before channel expressions.

Args: path: As returned by search_help — e.g. "nodes/sop/scatter", "vex/functions/noise", "expressions/ch".

The server's written guide for a subject: what to build, in what order, which mistakes it exists to prevent, and the shipped help pages to read.

Call this BEFORE designing a setup you have not built this session, and again the moment two attempts at the same symptom have failed. Each guide is distilled from that subject's SideFX manual.

Args: topic: Help scope name or common alias: pyro, fluid (flip, water, whitewater), vellum (cloth), destruction (rbd), mpm (sand, snow), ocean, solaris, tops, model, copy, render, shade, character, crowds, heightfields, copernicus, assets, troubleshooting, dyno. description: What you are trying to build, for the guide's framing.

Get USD stage info from a LOP node.

Args: node_path: LOP node path.

Get detailed info about a USD prim.

Array attributes longer than 16 elements (points, faceVertexIndices, primvars:st, ...) come back as a summary: size, element_type, the first 8 as head, and min/max for numeric data. That is what a mesh question needs; the full arrays of a building ran to 6.6 million characters. Pass full=True for every element, or read one array in windows with get_usd_attribute(offset=, limit=).

Args: node_path: LOP node path. prim_path: USD prim path. full: Return array attributes in full instead of summarised.

List USD prims on a stage with filtering.

Args: node_path: LOP node path. root_path: Root prim path to list from. prim_type: USD type filter (e.g. "Mesh", "Xform"). kind: Kind filter (e.g. "component", "group"). depth: Max traversal depth.

Read a USD attribute value from a prim.

A long array (over 16 elements) answers with value as a summary (size, element_type, head, min/max) plus slice: the elements from offset, at most limit of them (default the first 64), with has_more. Walk a big array by raising offset; pass full=True to get every element in value at once.

Args: node_path: LOP node path. prim_path: USD prim path. attr_name: Attribute name. time: Time code (frame number). full: Return the whole array as value. offset: First element of the window for a long array. limit: Window size for a long array.

List all layers in a USD stage.

Args: node_path: LOP node path.

Get prim counts by USD type under a root path.

Args: node_path: LOP node path. prim_path: Root prim path to gather stats from.

Get prims modified by the last LOP node cook.

Args: node_path: LOP node path.

Create a new LOP node.

Before using this, call list_node_types(context='Lop', filter='') to verify the correct node type. Solaris ships many specialized LOPs — sublayer, reference, materiallibrary, assignmaterial, karmarendersettings, editproperties, xform, prune, configurelayer, collection, addvariant — that may not be obvious from their names.

Args: parent_path: Parent node path. lop_type: LOP node type (e.g. "sphere", "sublayer", "merge"). name: Node name. prim_path: USD prim path to set on the node.

Set a USD attribute value via an inline Python LOP.

Args: node_path: LOP node path to connect after. prim_path: USD prim path. attr_name: Attribute name. value: Value to set.

The material each prim renders with, resolved the way the renderer resolves it (ComputeBoundMaterials), and where the binding comes from: direct on the prim, inherited from which ancestor, or which collection. A binding to a material prim that does not exist is reported in missing_material, not as unbound.

Batched: pass every prim of interest in one call.

Args: node_path: LOP node whose stage to read. prim_paths: Prim paths to resolve. purpose: "full" (default; what Karma renders, falling back to an all-purpose binding), "preview", or "all" (all-purpose bindings only).

List all USD materials on a stage.

Each material reports surface_shaders keyed by render context: "surface" is the universal output, a UsdPreviewSurface for viewports and Storm, and "mtlx" is the MaterialX shader Karma renders. surface_shader is the mtlx one when present, so it agrees with get_material_info on the same material.

bound_to lists the prims a binding is authored on. rendered_on (up to 50 paths) and rendered_on_count are the geometry that resolves to the material for rendering, including geometry bound through a parent or a collection; get_usd_bound_material says why for a given prim.

Args: node_path: LOP node path.

Search USD prims by path pattern.

Args: node_path: LOP node path. pattern: Glob pattern (supports *, **) or substring.

Get composition arcs for a USD prim.

Args: node_path: LOP node path. prim_path: USD prim path.

Get variant sets and selections for a USD prim.

Args: node_path: LOP node path. prim_path: USD prim path.

Inspect a USD layer by index.

Args: node_path: LOP node path. layer_index: Layer index (0 = root layer).

Create a USD light in a LOP network.

Args: parent_path: Parent LOP network path. light_type: "dome", "distant", "rect", "sphere", "disk", or "cylinder". name: Light node name. intensity: Light intensity. color: [r, g, b] color values. position: [x, y, z] world position.

List all USD lights on a LOP stage.

Args: node_path: LOP node path.

Set properties on a USD light prim via an inline Python LOP.

Args: node_path: LOP node path to connect after. prim_path: USD light prim path. properties: Property name-value pairs to set.

Create a preset lighting rig in a LOP network.

Args: parent_path: Parent LOP network path. preset: "three_point", "studio", "outdoor", or "hdri". intensity_mult: Multiplier for all light intensities.

List all material nodes under a root path.

Args: ctx: MCP context. root_path: Root path to search for materials.

Get detailed information about a material node.

assignments lists the nodes under /obj and /stage whose material-path parameters name this material; only those parameters are read, so the call costs the same on a 4,000-node scene as on an empty one (assignment_scan reports how many nodes were visited).

Args: ctx: MCP context. node_path: Absolute path to the material node.

Create a new material network in /mat.

The keys base_color ([r, g, b]), roughness, metalness and opacity are accepted on both shader types and mapped to the shader's own parameter names (base_colorr/g/b and specular_roughness on MaterialX, basecolor, rough, metallic and opac on Principled). Any other key must be the shader's real parameter name; a list sets the whole parm tuple. The reply lists what was applied and, under "skipped", every key that matched no parameter, with the reason.

Args: ctx: MCP context. name: Name for the new material node. shader_type: "principled" (principledshader::2.0), "materialx" (mtlxstandard_surface), or any material node type name. params: Parameter name-value pairs to set on the shader.

List available VOP/material node types.

Args: ctx: MCP context. filter: Substring to filter type names and labels by.

Create a node inside a parent network.

Before using this, call list_node_types(context='', filter='') to verify a dedicated node exists for the operation. Houdini has thousands of nodes — many common operations (boolean, scatter, copy to points, fracture, ocean, hair, vellum, pyro, etc.) have dedicated nodes that are better than writing VEX or Python.

Args: ctx: MCP context. parent_path: Parent network path. node_type: Node type (e.g. 'geo', 'box', 'grid'). name: Node name. position: [x, y] network editor position.

Delete a node.

Args: ctx: MCP context. node_path: Node path.

Rename a node.

Args: ctx: MCP context. node_path: Node path. new_name: New node name.

Copy a node, optionally into a different parent network.

Args: ctx: MCP context. node_path: Source node path. dest_parent: Destination parent path. new_name: Name for the copy.

Move a node to a different parent network.

Args: ctx: MCP context. node_path: Node path. dest_parent: Destination parent path.

Get type, connections, flags, errors, cook time, and non-default parameters for a node.

Returns only parameters that differ from their defaults (non_default_parameters) plus a total_param_count. Use get_parameter_schema to inspect the full parameter list.

Args: ctx: MCP context. node_path: Node path.

List children of a network node.

Avoid recursive=True on large networks — it can return hundreds or thousands of nodes. Prefer find_nodes with a specific pattern instead.

Args: ctx: MCP context. parent_path: Parent network path. recursive: Include all descendants (use sparingly on large scenes). filter_type: Node type filter (e.g. 'box', 'merge').

Search for nodes by name pattern, type, or context.

Narrow the search: use inside to limit to a specific sub-network and supply at least one of pattern, node_type, or context. Searching from inside="/" with no filters scans the entire scene and can return hundreds of nodes.

Args: ctx: MCP context. pattern: Glob pattern for node names (e.g. 'box*'). node_type: Node type filter (e.g. 'box', 'null'). context: Category filter (e.g. 'Sop', 'Object'). inside: Root path to search within (default '/').

List available node types for a context category.

IMPORTANT: Any context can have hundreds of node types (SOPs alone can exceed 800 in a production install). Always pass a filter keyword (e.g. 'mountain', 'scatter', 'boolean') instead of dumping the full list — the unfiltered response is capped at limit and may still be large.

Args: ctx: MCP context. context: Category name (e.g. 'Sop', 'Lop', 'Dop', 'Top', 'Cop2'). filter: Substring to filter type name or label (case-insensitive). limit: Max entries to return (default 200, max recommended 200).

Change a node's type in place, keeping wires, name, position, flags, parameter values and (for subnets/assets) network contents.

This is how an HDA instance is moved to an installed newer version (building::2.0) without losing its edits, and how a placeholder is swapped for the real node. Every value set before the swap and not after it is named in parms_dropped (no such parameter on the new type) or parms_reset (back at its default). Unversioned names map to the preferred version, as create_node does.

Args: node_path: Node to change. new_type: Type name in the node's own category. keep_name: Keep the node's name. keep_parms: Carry parameter values over by name. keep_network_contents: Keep a subnet's/asset's children (False resets an asset to its definition's contents, also on a node that is already of new_type).

Press a button parameter — "Stash Input", "Reload Geometry", an asset's own Build button — and read the node's errors and warnings afterwards.

The call holds until the callback returns, with no deadline. A callback that opens a dialog blocks Houdini's main thread and this bridge with it; read the button's script first if in doubt. For a Save to Disk or a render use write_cache / start_render, which report a verdict.

A press usually only dirties the node, so errors/warnings are from its last cook unless cook=True; without it needs_cook says whether they are stale (a cook that failed leaves it True too). has_script_callback is False for built-in buttons that still do work (File's Reload, Stash's Stash Input).

Args: node_path: Node that owns the button. parm_name: The button parameter's name. arguments: Optional kwargs handed to the callback script; values must be int, bool, float or str. cook: Cook the node after the press so errors describe the result.

Connect two nodes together.

To feed a node INSIDE a subnet from one of the subnet's own input connectors (a SubnetIndirectInput — not a node, it has no path), pass the subnet as source_path and the connector index as indirect_input.

Args: ctx: MCP context. source_path: Upstream node path; with indirect_input, the subnet whose input connector is the source. dest_path: Downstream node path. output_index: Source output index. input_index: Destination input index. input_name: Destination connector name or label (e.g. "base_color" on a VOP shader); wins over input_index. indirect_input: Index of the subnet input connector at source_path to wire from (dest_path must live inside that subnet).

Connect multiple node pairs in a single call.

Args: connections: List of connections. Each dict has keys: source_path (str), dest_path (str), output_index (int, default 0), input_index (int, default 0), input_name (str, optional: connector name or label, wins over input_index), indirect_input (int, optional: source_path is then a subnet and this is the index of its input connector to wire from — for the first node of a chain built inside that subnet).

Disconnect one or all inputs of a node.

Args: ctx: MCP context. node_path: Node path. input_index: Input index to disconnect. disconnect_all: Disconnect all inputs.

Reorder the input connections of a node.

Args: ctx: MCP context. node_path: Node path. new_order: New input ordering (e.g. [1, 0] swaps first two).

Set flags on a node.

Args: ctx: MCP context. node_path: Node path. display: Display flag. render: Render flag. bypass: Bypass flag. template: Template flag. lock: Lock flag.

Auto-layout children of a network node.

Does nothing when auto-layout is disabled via FXHOUDINIMCP_AUTO_LAYOUT=0.

Args: ctx: MCP context. parent_path: Parent network path. spacing: Spacing multiplier between nodes.

Set a node's position in the network editor.

Args: ctx: MCP context. node_path: Node path. x: Horizontal position. y: Vertical position.

Set a node's color in the network editor.

Args: ctx: MCP context. node_path: Node path. r: Red (0.0-1.0). g: Green (0.0-1.0). b: Blue (0.0-1.0).

Draw a titled network box around nodes, to document a graph you built.

Args: ctx: MCP context. parent_path: Network the box lives in. node_paths: Sibling nodes to enclose; the box fits around them. comment: Title shown on the box. color: RGB in 0..1.

Leave a sticky note in a network.

Args: ctx: MCP context. parent_path: Network the note lives in. text: Note text. position: [x, y] in network editor units. size: [width, height] in network editor units. color: RGB in 0..1.

Set an object's translate, rotate, scale and/or parent in one call.

Only the arguments you pass change. Object-level nodes under /obj only; SOP transforms are a Transform SOP, not this.

Args: ctx: MCP context. node_path: Object node, e.g. "/obj/geo1". translate: [tx, ty, tz]. rotate: [rx, ry, rz] in degrees. scale: [sx, sy, sz]. parent: Object to parent under, or "" to unparent.

Get the value and metadata of a parameter.

Args: node_path: Node path. parm_name: Parameter name.

Set a parameter value.

Args: node_path: Node path. parm_name: Parameter name. value: New value (int, float, string, bool, or list).

Batch-set multiple parameters on a node.

Args: node_path: Node path. params: Mapping of parameter names to values.

Get the template schema for parameter(s) on a node.

Most nodes have dozens of parameters; many have 100+. Always use parm_name or filter unless you genuinely need the full list.

Args: node_path: Node path. parm_name: Exact parameter name for a single-parameter lookup. filter: Substring to match against parameter name or label (case-insensitive). Use instead of dumping all params.

Who references a parameter, and what it references — in one call.

incoming: for each parameter of the node (or just parm_name), the parameters elsewhere whose expressions read it — what breaks if this control is renamed. outgoing: what this node's expressions and backtick strings read, resolved to parameter paths (pure ch() links and richer expressions alike; unresolved names a written target that no longer exists). node_dependents / node_references give the node-level view for this node only.

Args: node_path: Node to inspect. parm_name: One parameter instead of all of them. direction: "both", "incoming" or "outgoing". limit: Cap on reported entries.

The whole parameter interface as a tree, the way Type Properties shows it: folders (with folder_type — tabs, collapsible, multiparm), every parameter in order with defaults, default expressions, ranges, menu items, Hide/Disable When conditionals, callbacks, naming scheme; a multiparm's default_instances. Each entry uses get_parameter_schema's keys (default_value, is_hidden, menu_items...).

get_hda_info shows only the top folders and get_parameter_schema flattens the structure away; read this before editing an interface. Give node_path for a node (its instance interface, spares included) or type_name + context for a type.

Args: node_path: Node whose interface to read. type_name: Node type instead (with context). context: Category of type_name — "Sop", "Object", "Lop", ... folder: Narrow to one folder by label, or a list of nested labels. max_entries: Cap on entries (depth-first); the reply says when it cut.

Set an expression on a parameter.

Args: node_path: Node path. parm_name: Parameter name. expression: Expression string. language: "hscript" (default) or "python".

Get the expression on a parameter.

Args: node_path: Node path. parm_name: Parameter name.

Revert a parameter to its default value.

Args: node_path: Node path. parm_name: Parameter name.

Create a channel reference from one parameter to another.

The destination gets an HScript expression that reads the source as its own type: chs() for a String parameter, ch() for numbers, toggles and menus. The path is relative to the destination node (chs("../CTRL/mat")), so the link survives moving the pair, collapsing into a subnet or instancing an HDA. The reply carries the expression, the function used and the destination's evaluated value.

Args: source_path: Source node path. source_parm: Source parameter name. dest_path: Destination node path. dest_parm: Destination parameter name.

Lock or unlock a parameter.

Args: node_path: Node path. parm_name: Parameter name. locked: True to lock, False to unlock.

Add a spare parameter to a node.

Args: node_path: Node path. parm_name: Internal parameter name. parm_type: "float", "int", "string", "toggle", or "menu". label: UI label. default_value: Default value. min_val: Minimum value (float/int only). max_val: Maximum value (float/int only).

Batch-create multiple spare parameters in one call, optionally in a folder tab.

Args: node_path: Node path. parameters: List of parameter specs. Each dict has keys: parm_name (str), parm_type (str: "float"/"int"/"string"/"toggle"/"menu"), label (str), default_value (optional), min_val (optional), max_val (optional). folder_name: If provided, wraps all parameters in a named folder tab. folder_type: Folder style: "Tabs", "Collapsible", or "Simple".

Read many parameter values at once, matched by name or label substring.

The batch counterpart of set_parameters. Several unrelated groups of settings ("flame", "wind", "buoy") come back in one call instead of one call each, and unlike get_node_card these are the live values on this node rather than the defaults for its type.

Args: node_path: Node to read. patterns: Substrings matched against parameter name and label. Omit for everything, up to the cap. include_defaults: Also report whether each value is still the default.

Capture the current 3D viewport to an image file.

Args: output_path: Image file path. resolution: [width, height] in pixels. camera: Camera node path. settle_seconds: Wait this long before capturing, without blocking Houdini, so a Karma viewport can converge after a change. Use this instead of a shell sleep between calls. Capped at 120.

Capture all four viewport panes to separate images.

Args: output_path: Base image path; viewport names are appended. resolution: [width, height] in pixels.

List all render (ROP/Driver) nodes in the scene.

Get render settings from a ROP node.

Args: node_path: ROP node path.

Set render parameters on a ROP node.

Args: node_path: ROP node path. settings: Parameter name-value pairs.

Create a new render (ROP) node in /out.

Args: renderer: Renderer type ('karma', 'opengl', 'mantra', 'rop_geometry', 'rop_alembic', 'usdrender', 'fetch', 'merge', 'rop_fbx', 'rop_gltf'). name: Node name. camera: Camera node path. output_path: Output file path.

Execute any node that renders or writes files.

Foreground by default: Houdini shows its own progress dialog and the user can cancel. The call holds until the render finishes, however long that is; a client that hands a long call to a background task notifies you with the verdict. Do nothing else in Houdini meanwhile and never poll the disk.

Not just /out ROPs: a LOP usdrender_rop (which is how Solaris renders), a SOP ROP Geometry, or a File Cache's Save to Disk all work, because what matters is whether the node can be executed rather than its category.

The result reports the output path it wrote to and whether anything is actually on disk there, so a render that succeeds and writes nowhere is visible instead of silent.

Args: node_path: Any node with a render() or an 'execute' button. frame_range: [start, end] or [start, end, increment]. background: Render in a separate hython on the saved hip and return at once with status "launched"; get_render_progress reports the process, its log tail and the files. The user sees no progress in Houdini, so use it only when asked to keep working while a render runs.

Capture a screenshot of a node's network editor view.

Args: node_path: Node path to focus on. output_path: Image file path.

Progress of a render or write started with start_render.

Accepts every node start_render accepts (a LOP usdrender_rop or Karma LOP, a SOP ROP, a File Cache), not only /out ROPs. Reports the node's errors with license_error singled out, the output files on disk, and for a background render the process state and the tail of its log. done is true when there is nothing left to wait for.

Args: node_path: The node given to start_render.

Check the Codex-to-Houdini bridge without raising on disconnect.

Returns structured connection diagnostics, including the configured bridge URL and Houdini health payload when reachable. Use this before live viewport workflows when Houdini may have restarted or its hwebserver may not be running.

Get information about the current Houdini scene.

Create a new empty Houdini scene.

Args: save_current: Save the current scene before clearing.

Save the current Houdini scene to disk.

Args: file_path: Destination path; defaults to the current hip file.

Open a Houdini hip file, or merge it — or named nodes from it — into the current scene.

Load warnings (missing assets and the like) come back in warnings. A merge reports what arrived: merged_nodes, conflicts (a node that already exists is merged under a new name, or overwritten in place with overwrite_on_conflict=True) and not_found_in_file. node_paths are absolute (/obj/building_v3) and bring their contents.

Args: file_path: Path to the hip file to open. merge: Merge into the current scene instead of replacing it. node_paths: With merge, the absolute node paths to merge; default everything. overwrite_on_conflict: With merge, overwrite same-named nodes instead of renaming the merged copy.

Import a geometry, USD, or Alembic file into the scene.

Args: file_path: Path to the file to import. parent_path: Network path for the import node. node_name: Name for the created node.

Export a node's output to a file on disk, and report whether it landed.

SOPs are saved directly, LOPs export their USD stage, and a /out ROP is pointed at file_path and executed (its own output path is restored afterwards). Reports wrote_files, so success: True means a file appeared or changed -- not merely that the call returned. A frame_range writes name.0001.ext per frame and leaves the playbar where it was.

Args: node_path: Path to the node to export. file_path: Destination file path. For a ROP this overrides its output parameter for the duration of the export. frame_range: Frame range as [start, end] or [start, end, step].

Get information about a Houdini network context.

Args: context: Context path, e.g. "/obj", "/stage", "/out".

Undo the last change(s) made in Houdini.

Every tool call is one undo step, however many nodes it touched, so one undo reverses one build_network or set_parameters call. Needs a graphical Houdini: hython keeps no undo history.

Args: ctx: MCP context. steps: How many steps to undo (default 1).

Redo the last undone change(s) in Houdini.

Args: ctx: MCP context. steps: How many steps to redo (default 1).

Find shelf tools by name, label or keyword.

Use this when a setup exists as a shelf tool rather than as a node: oceans, quick sims, rigging setups. A full install ships around 8,000 of them, so always filter.

Args: filter: Substring matched against name, label and keywords. limit: Maximum tools to return.

Read the script a shelf tool runs, plus its help and imports.

This is how you learn SideFX's own recipe instead of reinventing it. Most scripts are two or three lines calling a worker in a toolutils module, and the reported imports name exactly what to read next.

Args: tool_name: Internal tool name, from list_shelf_tools.

Run a shelf tool and report the nodes it created.

Tools that wait for a viewport selection or a dialog (the FLIP ocean layer, collide-with, most "select the object then..." tools) are refused up front: through the bridge they would block Houdini until someone clicks. Read the recipe with get_shelf_tool_script and build the nodes with build_network instead. Tools that only create nodes run fine.

Args: tool_name: Internal tool name, from list_shelf_tools. kwargs: Overrides merged into the synthetic kwargs the script reads. parent_path: An extra network to watch for new nodes. /obj, /stage, /out, /mat and /img are always watched, because a shelf tool is free to build in more than one of them: largeOcean creates both a geo in /obj and a LOP in /stage.

List all takes in the scene with their hierarchy.

Get the current take and its overridden parameters.

Set the current take by name.

Args: name: Take name to make current.

Create a new take, optionally under a parent take.

Args: name: Name for the new take. parent_name: Parent take name (defaults to current take).

Get an overview of a TOP network.

Args: ctx: MCP context. node_path: TOPnet or TOP node path.

Cook a TOP node to execute its work items.

Args: ctx: MCP context. node_path: TOP node path. block: Wait for cooking to complete. generate_only: Only generate work items, do not cook.

Cancel active cooking on a TOP network.

Args: ctx: MCP context. node_path: TOP node or TOPnet path.

Pause cooking on a TOP network.

Args: ctx: MCP context. node_path: TOP node or TOPnet path.

Dirty work items on a TOP node so they can be regenerated.

Args: ctx: MCP context. node_path: TOP node path. remove_outputs: Also remove output files from disk.

Get work item state counts for a TOP node.

Args: ctx: MCP context. node_path: TOP node path.

Get detailed information about a specific work item.

Args: ctx: MCP context. node_path: TOP node path. work_item_index: Work item index within the node.

Get the PDG dependency graph structure for a TOP network.

Args: ctx: MCP context. node_path: TOPnet or TOP node path.

Generate static work items on a TOP node without cooking.

Args: ctx: MCP context. node_path: TOP node path.

Get information about TOP scheduler nodes in a network.

Args: ctx: MCP context. node_path: TOP scheduler or TOPnet path.

List the work items that failed on a TOP node, with the tail of each log.

Args: ctx: MCP context. node_path: TOP node path. limit: Maximum items returned.

Cook logs for a TOP node, or the scheduler log of one work item.

Args: ctx: MCP context. node_path: TOP node path. work_item_index: Work item index; omit for the node's own errors and warnings. tail: Maximum characters of log text, taken from the end.

Create an Attribute Wrangle node with VEX code.

LAST RESORT. VEX is for attribute math that no node expresses — NEVER for modeling, scattering, copying, deforming, grouping, or randomizing, which all have dedicated nodes. Building geometry in a wrangle when a native node exists is a failure, not a shortcut.

The justification parameter is mandatory: state which list_node_types searches you ran and why none of the results can do this. If you cannot write that sentence honestly, you have not checked — check first.

Args: parent_path: Parent SOP network path. vex_code: VEX snippet to set. justification: Which native nodes you checked (the actual list_node_types filters used) and why none can express this logic. run_over: Element to run over ("Points", "Vertices", "Primitives", "Detail", "Numbers"). name: Node name.

Set VEX code on an existing Attribute Wrangle node.

Args: node_path: Path to the wrangle node. vex_code: VEX snippet to set.

Read the VEX code from an Attribute Wrangle node.

Args: node_path: Path to the wrangle node.

Set a VEX expression on a parameter.

Args: node_path: Path to the node. parm_name: Parameter name. vex_code: VEX expression code.

Validate VEX code by cooking the node and checking for errors.

Args: node_path: Path to the wrangle node.

List all visible pane tabs in the Houdini UI.

Get viewport settings for a pane tab.

Args: pane_name: Pane tab name.

Set the viewport to look through a specific camera.

Args: camera_path: Camera node path, or a USD camera prim path for a Solaris viewport. The result reports the camera the viewport is actually looking through, and fails if it did not take. pane_name: Pane tab name.

Set the viewport shading mode.

Args: display_mode: One of 'wireframe', 'shaded', 'smooth', 'smooth_wire', 'hidden_line', 'flat', 'flat_wire', 'matcap', 'matcap_wire'. pane_name: Pane tab name.

Set the viewport's Hydra rendering delegate for live preview.

Use this during lookdev to preview materials and lighting directly in the viewport instead of writing full renders to disk.

Args: renderer: Renderer name. The result reports the delegate that is actually active afterwards, read back from Houdini rather than inferred from a setter not raising. renderer: Renderer name — "GL", "Storm", "Karma CPU", "Karma XPU", etc. Case-insensitive partial match. pane_name: Pane tab name.

Frame the current selection in the viewport.

Args: pane_name: Pane tab name.

Frame all geometry in the viewport.

Args: pane_name: Pane tab name.

Set the viewport to a standard viewing direction.

Args: direction: "front", "back", "top", "bottom", "left", "right", or "perspective". pane_name: Pane tab name.

Capture a screenshot of the viewport or a specific pane tab.

The image is written to disk only; open output_path with your file reader to look at it. Prefer get_geometry_info, get_node_info or get_scene_summary unless visual confirmation is genuinely needed.

Args: output_path: Image file path. pane_name: Pane tab name. settle_seconds: Wait this long before capturing, without blocking Houdini, so a Karma viewport can converge after a change. Use this instead of a shell sleep between calls. Capped at 120.

Capture a screenshot of the network editor.

The image is written to disk only; open output_path with your file reader to look at it. Prefer get_node_info or list_children for inspecting node connections unless visual confirmation of wiring is genuinely needed.

Args: output_path: Image file path. node_path: Node path to navigate to before capture.

Navigate the network editor to a specific network path.

Args: network_path: Network path to navigate to.

Find all nodes with errors or warnings in the scene.

Args: root_path: Root node path to search from.

Display a status message in Houdini's status bar.

Call this at the START of every major step so the user can follow along in real time without having to inspect tool call logs. Examples: "Creating base geometry...", "Wiring SOP chain...", "Setting up pyro simulation...", "Assigning materials...".

Args: message: Status message to display (keep it short and human-readable). severity: "message" (default), "important", "warning", or "error".

Point the Scene Viewer at a network, and optionally a node inside it.

set_current_network moves the network EDITOR; this moves the VIEWER. That is what decides whether a scene graph view exists, so it is the prerequisite for previewing a USD stage or setting a Hydra delegate: call this with "/stage" before set_viewport_renderer or before binding a USD camera prim.

The result reports is_scene_graph_view, which is the question you are usually really asking.

Args: network_path: Network for the viewer to display, e.g. "/stage". current_node: Node inside it to make current, which selects the stage a Solaris viewport shows. pane_name: Pane tab name.

Build a Pyro smoke/fire simulation network from source geometry.

Preferred over manual DOP wiring — builds the entire pyro network in one call. For custom setups beyond what this provides, use create_node with DOP nodes (pyrosolver, smokeobject, volumesource, etc.).

Args: source_geo: Source SOP path. container: Container type. res_scale: Resolution scale multiplier. substeps: DOP substeps. name: Top-level geo node name.

Build an RBD rigid-body simulation network with fracture and solver.

Preferred over manual DOP wiring — builds the entire RBD network in one call. For source geometry, build SOP chains with native nodes (voronoifracture, booleanfracture, rbdmaterialfracture) instead of VEX.

Args: geo_path: Source geometry object path. ground: Add a ground plane. pieces_type: Fracture method ("voronoi"). name: Top-level geo node name.

Build a FLIP fluid simulation network from source geometry.

Preferred over manual DOP wiring — builds the entire FLIP network in one call. Use FLIP Source SOP or Volume Source DOP for custom sourcing.

Args: source_geo: Source SOP path. domain: Domain type. particle_sep: Particle separation distance. name: Top-level geo node name.

Build a Vellum simulation network with configure node and solver.

Preferred over manual DOP wiring — builds the entire Vellum network in one call. Use Vellum Drape SOP to let cloth settle before the main simulation.

Args: geo_path: Source geometry object path. sim_type: Simulation type ("cloth", "hair", "grain", "softbody"). substeps: Solver substeps. name: Top-level geo node name.

Create a material in /mat with configurable surface properties.

Args: name: Material node name. mat_type: Material type ("principled", "materialx"). base_color: [R, G, B] base color, 0-1 per channel. roughness: Surface roughness, 0-1. metallic: Metallic factor, 0-1. opacity: Opacity, 0-1.

Assign a material to a geometry node via a Material SOP.

Args: geo_path: Target geometry node path. material_path: Material to assign.

Build a sequential chain of SOP nodes wired together in a single call.

PREFERRED over individual create_node calls for linear SOP chains — builds and wires the entire chain in one round-trip, which is significantly faster.

Each step dict: {"type": str, "name": str (optional), "params": dict (optional)}. Nodes are created in order and each is automatically connected to the previous.

Example: steps=[ {"type": "box"}, {"type": "polybevel", "params": {"offset": 0.05}}, {"type": "scatter", "params": {"npts": 200}}, {"type": "copy_to_points", "name": "copy1"}, ]

Args: parent_path: Parent SOP network path. steps: List of step dicts defining the chain.

Set up a render configuration with camera and ROP node.

Args: renderer: Renderer type ("karma", "mantra"). camera: Camera node path; creates one if omitted. output_path: Output image path (supports Houdini variables). resolution: [width, height] resolution. samples: Render sample count. name: ROP node name in /out.