Skip to main content
Glama

vi_dump

Reads a LabVIEW VI's block diagram as a graph of nodes, nested structures and wires with terminal-level connections, plus constant values and front-panel classes, so you can inspect or edit the VI.

Instructions

The block diagram as a graph: every node (controls, indicators, constants, functions by palette name, subVIs, loops, cases and their frames, tunnels, shift registers, property/invoke nodes), which diagram it sits in ("in": a structure id, "case_4#1" = frame 1), and every wire with its source and sinks as "node.terminal". Node ids are what vi_edit's "remove" and "existing" take; dump again after each edit. Controls carry their front-panel class ("vi_class": "WaveformChart", "Slide", ...). Property Nodes carry "vi_class", the linked "control" label if any, "items" (terminal names, top to bottom) and "write"; Invoke Nodes their "method".

"source" says how it was read. method="auto" first uses LabVIEW's compiler export ("dfir": adds wire data types and case frame values, but refuses VIs with some controls or nodes), then walks the diagram objects instead ("scan": works on any VI, including broken ones). Both include constant values. method="dfir" or "scan" forces one. Password-protected VIs cannot be read.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "path": "<path>"
    },
    "name": "vi_dump"
  }
}

Input Schema

NameRequiredDescriptionDefault
pathYes
methodNoauto

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.40.1

TDQS

A4.5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations supplied, the description carries the full burden and meets it: it discloses the automatic fallback chain (compiler export first, object walk second), the exact tradeoffs (dfir adds wire data types and case frame values but refuses VIs with some controls or nodes; scan works on any VI including broken ones), that both include constant values, that method can force either, and that password-protected VIs are unreadable. These are precisely the operational traits an agent cannot infer from the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the return shape and node-id contract, then a second paragraph covers read strategy and restrictions, so structure mirrors how an agent needs the information. It is dense and long, but nearly every clause carries distinct payload (id formats, "case_4#1" frame notation, vi_class on controls and property nodes, "items" ordering, "write"). Minor tightening is possible but nothing is padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, so the description is responsible for describing returns, and it does so in detail: node categories, containing-diagram "in" field with frame notation, wire source/sink format, vi_class, property-node items and write flag, invoke-node method, and the "source" field. Combined with the method fallback and password-protection limits, an agent has enough to call this correctly and interpret results without further documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and it does for the parameter that matters: the three values of "method" (auto, dfir, scan) are each defined along with their behavioral consequences and default-like behavior of auto. "path" is left implicit as the VI to read, which is the one small gap, but the otherwise undocumented enum is fully explained in prose.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description establishes a specific resource and scope: the full block-diagram graph of a VI, enumerated by node kind (controls, indicators, constants, functions, subVIs, loops, cases, tunnels, shift registers, property/invoke nodes) plus every wire with source and sinks. It also distinguishes itself from the sibling vi_edit by stating that its node ids are what vi_edit's "remove" and "existing" take. The only weakness is that the action verb is implied by the name rather than stated, but an agent can still tell exactly what it gets back.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is anchored in a concrete workflow: node ids feed vi_edit, and the agent is told to "dump again after each edit", which is explicit sequencing guidance. It also supplies a when-not constraint (password-protected VIs cannot be read) and a method-selection rule (auto, or force dfir/scan). It stops short of naming which sibling to use for a text or metadata view of the VI, so the comparison set is partial rather than exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.