Skip to content
LOPS Docs

Source Ops

v1.0.0

The Source Ops LOP introspects live TouchDesigner networks and extracts detailed operator information — names, types, parameters, connections, children, parent relationships, and docked operators — into a structured JSON table. The output is formatted for direct use with the RAG Index LOP, enabling agents and retrieval workflows to understand and reason about your TouchDesigner project structure.

Overview

Section titled “Overview”

Source Ops walks through a set of operators (determined by an OP Find filter) inside a target component and builds a per-operator JSON record containing whatever detail level you configure. Each record is written as a row in the output index_table DAT with columns for doc_id, filename, source_path, content (full JSON), metadata (summary), and timestamp. Text and Table DATs also have their raw text content captured.

Parsing runs synchronously on the main TouchDesigner thread, so large networks will cause a brief pause. Use the OP Find filter to limit scope when working with complex projects.

Input/Output

Section titled “Input/Output”

Inputs

Section titled “Inputs”

None — the operator discovers targets through its internal OP Find or a custom OP Find DAT you provide.

Outputs

Section titled “Outputs”
  • index_table (DAT, 1 output): One row per parsed operator. The content column holds the full JSON representation; metadata holds a simplified summary with operator name, path, type, and project info. This table plugs directly into a RAG Index LOP.

Usage Examples

Section titled “Usage Examples”

Parse All Operators in a Component

Section titled “Parse All Operators in a Component”
  1. On the Parse page, set Component to the container you want to inspect (defaults to the parent of the Source Ops operator).
  2. Pulse Parse Ops.
  3. Each operator found by the OP Find is processed and added to the output index_table.

Filter Which Operators Get Parsed

Section titled “Filter Which Operators Get Parsed”

Source Ops uses TouchDesigner’s built-in OP Find internally. You can configure it two ways:

  • Use the built-in OP Find: Pulse Open Op Find pars to open the parameters of the internal opfind1 DAT. Set type filters, name patterns, tag filters, etc. directly there.
  • Supply your own OP Find: Point the Custom Op Find parameter to an external OP Find DAT. It must have a path column. This lets you share a single filter across multiple Source Ops instances or build more complex queries.

Control What Gets Extracted

Section titled “Control What Gets Extracted”

Toggle the detail-level parameters on the Parse page to control how much data each record contains:

  • Include Parameters — captures every parameter’s name, label, and current value. Use Parse Types to narrow this to All Pars, Custom Only, Built-in Only, or Modified Only.
  • Include Expressions — adds Python expression strings and parameter modes when parameters are expression-driven.
  • Include Bindings — adds bind expressions and bind reference paths.
  • Include Connections — maps input/output wires, connectors, and COMP-level connections.
  • Include Children Info — lists child operators and child counts (only applies to COMPs).
  • Include Parent Info — records the parent operator’s path, name, and type.
  • Include Docked Ops — includes docked operator information.

Keep the Index Up to Date Automatically

Section titled “Keep the Index Up to Date Automatically”

Toggle Auto Parse to On. Whenever the OP Find results change (operators added, removed, or renamed), the index is automatically re-parsed without needing to pulse manually.

Feed Results into RAG

Section titled “Feed Results into RAG”
  1. Place a RAG Index LOP downstream.
  2. Wire the Source Ops output into the RAG Index input.
  3. The index_table format (doc_id, filename, source_path, content, metadata, timestamp) matches what RAG Index expects — no transformation needed.

Best Practices

Section titled “Best Practices”
  • Start narrow, expand later. Use OP Find filters to parse only the operators you care about. Parsing an entire project with all detail toggles on produces large tables and takes longer.
  • Modified Only is powerful for diffing. Set Parse Types to Modified Only to capture only parameters that differ from their defaults — useful for understanding what has been customized in a network.
  • Custom Only for LOPs introspection. When parsing other LOPs operators, Custom Only captures the operator-specific parameters without the noise of built-in TouchDesigner parameters.
  • Clear before re-parsing. Pulse Clear Index before a fresh parse to avoid duplicate rows from previous runs. Pulsing Parse Ops already clears the table automatically, but Clear Index is useful if you want to empty the table without re-parsing.

Troubleshooting

Section titled “Troubleshooting”
  • “path column not found” error — The OP Find DAT connected to Custom Op Find must have a column named path. If you are using a custom DAT, make sure it outputs operator paths in that column.
  • Operators missing from results — Check your OP Find filter settings. Pulse Open Op Find pars to review what the filter is matching. The Component parameter sets the root — operators outside that component tree are not discovered.
  • Parsing is slow — Reduce scope with tighter OP Find filters, or disable detail toggles you do not need (especially Include Parameters with All Pars on large networks).

Parameters

Section titled “Parameters”

Parse

Section titled “Parse”
Component (Component) op('source_ops').par.Component COMP
Default:
..
Parse Ops (Parseops) op('source_ops').par.Parseops Pulse
Default:
False
Auto Parse (Autoparse) op('source_ops').par.Autoparse Toggle
Default:
False
OP Find [ must have path column ] Header
Open Op Find pars (Openfilter) op('source_ops').par.Openfilter Pulse
Default:
False
Custom Op Find (Opfind) op('source_ops').par.Opfind DAT
Default:
"" (Empty String)
Include Parameters (Includeparameters) op('source_ops').par.Includeparameters Toggle
Default:
False
Parse Types (Parsetypes) op('source_ops').par.Parsetypes Menu
Default:
all
Options:
all, custom, builtin, modified
Include Expressions (Includeexpressions) op('source_ops').par.Includeexpressions Toggle
Default:
False
Include Bindings (Includebindings) op('source_ops').par.Includebindings Toggle
Default:
False
Include Connections (Includeconnections) op('source_ops').par.Includeconnections Toggle
Default:
False
Include Children Info (Includechildren) op('source_ops').par.Includechildren Toggle
Default:
False
Include Parent Info (Includeparent) op('source_ops').par.Includeparent Toggle
Default:
False
Include Docked Ops (Includedocked) op('source_ops').par.Includedocked Toggle
Default:
False
Clear Index (Clear) op('source_ops').par.Clear Pulse
Default:
False
Header

Changelog

Section titled “Changelog”
v1.0.02024-11-06

Initial release

Section titled “Related Operators”