Output Formats - Blueprint AI Assistant

Four output format levels: overview, summary, detail, and backup, for different use cases.

Part of BlueprintAIAssistant. See also: AI Guide | Verb Reference | Batch Operations

Overview#

Blueprint AI Assistant exports Blueprint data in four named formats. The format controls the structure of the output and how much information is included. There is no separate detail parameter; everything is controlled by --format=.

Format Comparison#

Format	Size	Use when
`overview`	Smallest	Scanning many assets. Quick existence/type check with condensed graph.
`summary` (DEFAULT)	Moderate	Normal inspection: full metadata, variables, components, CDO, tree-walk graphs.
`detail`	Larger	Write operations: same as summary + 8-char node GUIDs after every node.
`backup`	Full	Programmatic parsing, CI/CD, full asset backup. Machine-readable with all GUIDs and internal type names.

overview (--format=overview)#

Metadata header plus a condensed tree-walk of each graph. The most compact human-readable format. Applies aggressive filtering: no Variables section, no Components, no CDO, no Event Dispatchers, no loop-back markers, no empty event stubs, trivial parameter values filtered out, connection traces hidden, and pure chains fully suppressed (depth = 0). Designed for scanning many assets quickly or confirming an asset exists.

Example#

BP_Enemy (Character, C++)
> Actor that deals damage.
Vars: 1 | Components: 2 | Dispatchers: 0

## EventGraph
### Event BeginPlay
├── Set Health (NewValue = 100.0)
└── Print String (InString = Enemy spawned)

summary (--format=summary): DEFAULT#

All metadata sections in human-readable text plus full tree-walk graphs with box-drawing characters. This is the default format when --format= is not specified.

Key Features#

All metadata sections included. Variables, Components, CDO overrides, and Event Dispatchers appear as plain text with human-friendly type names (Float instead of real).
Box-drawing tree for execution flow. ├── and └── show the sequence of nodes. Branching nodes (Branch, Sequence, Switch) display their outputs as labeled sub-trees.
Inline parameters. Non-exec input pins are shown directly on the node line: Set Health (NewValue = 100.0).
Pure node expansion. Pure nodes (no exec pins, like getters and math operations) are expanded below the consuming node using the ↳ prefix, up to 10 levels deep.
Source pin references. When a value comes from another node's output, the connection is shown with ←: Target ← Get Player Character.ReturnValue.
Branch labels. Multi-output pins are labeled: [True], [False], [0], [1], etc.
Loop-back markers. Cycle detection shows (loop back) where execution revisits an already-visited node.

Example#

# Blueprint: BP_Enemy
Type: Actor Blueprint
Parent: Character (C++)
> Actor that deals damage.

## Variables
- Health: Float = 100.0 (replicated, editable, category: "Combat")

## Components
- DefaultSceneRoot (SceneComponent) [ROOT]
  - EnemyMesh (SkeletalMeshComponent)

## Class Defaults (differs from parent)
- AutoPossessAI: PlacedInWorldOrSpawned

## EventGraph

### Event BeginPlay
├── Set Health (NewValue = 100.0)
└── Print String (InString = Enemy spawned)

Complex Graph Example#

For a Blueprint with branching logic, the tree structure reveals control flow:

### Event AnyDamage
├── Branch (Condition ← Is Valid.ReturnValue)
│   ├── [True]:
│   │   ├── Set Health (NewValue ← Clamp.ReturnValue)
│   │   │   ↳ Clamp (Value ← Subtract.ReturnValue, Min = 0.0, Max = 100.0) → NewValue
│   │   │     ↳ Subtract (A ← Get Health.ReturnValue, B ← Damage) → Value
│   │   └── Branch (Condition ← Less Equal.ReturnValue)
│   │       ├── [True]:
│   │       │   └── Call Die
│   │       └── [False]:
│   │           └── Play Hit React Montage
│   └── [False]:
│       └── (end)
└── (end)

In this example:

├── / └── show execution flow (which node runs next).
↳ shows pure node chains (data flow, where values come from).
← shows which output pin provides a value to an input pin.
[True] / [False] label the branch output pins.
(end) marks the end of an execution path.

detail (--format=detail)#

Same layout as summary, with one key addition:

8-character GUID suffixes appear after every node title (e.g., Set Health [C9D0E1F2]).

Use this format when you need node GUIDs for subsequent write operations (add-node, connect, disconnect, remove-node, set-pin-default).

Example#

### Event BeginPlay
├── Set Health [C9D0E1F2] (NewValue = 100.0)
└── Print String [D3E4F5A6] (InString = Enemy spawned)

#### Pin Details
| Node | GUID | Pin | Value/Connection |
|------|------|-----|------------------|
| Set Health | C9D0E1F2 | NewValue | 100.0 |
| Print String | D3E4F5A6 | InString | Enemy spawned |

backup (--format=backup)#

Full structured JSON output. Every field is present, every GUID is included, and pin types use the internal UE category names. This is the most complete format but also the most verbose.

Key Sections#

success: Boolean indicating the export succeeded.
summary: A one-line natural language description of the Blueprint's purpose (auto-generated, rule-based).
blueprint: Metadata including name, path, blueprintType, parentClass, nativeParentClass, inheritanceChain, and implementedInterfaces.
variables: Array of variable definitions. Each entry includes name, type (with category, subCategory, isArray, isSet, isMap), defaultValue, category, tooltip, and flags (replication, editability, expose-on-spawn, etc.).
classDefaults: CDO property diff from the parent class. Contains a properties array where each entry has name, value, and type.
components: Component hierarchy with root (name of the root component) and tree (array of nodes, each with name, componentClass, parent, isRoot, and overridden properties).
eventDispatchers: Array of event dispatchers, each with name and parameters.
graphs: Array of graphs. Each graph has name, graphType (EventGraph, Function, Macro, InterfaceImpl), an optional signature (for functions), and a nodes array. Each node has nodeId, nodeClass, displayTitle, posX, posY, comment, isDisabled, and a pins array. Each pin has pinName, pinId, direction, isExec, isHidden, type, defaultValue, and linkedPins (with optional resolvedNodeId for reroute resolution).

Example#

{
  "success": true,
  "summary": "Actor that deals damage.",
  "blueprint": {
    "name": "BP_Enemy",
    "path": "/Game/Blueprints/BP_Enemy",
    "blueprintType": "Normal",
    "parentClass": "/Script/Engine.Character",
    "nativeParentClass": "/Script/Engine.Character",
    "inheritanceChain": ["BP_Enemy", "Character", "Pawn", "Actor", "Object"],
    "implementedInterfaces": []
  },
  "variables": [
    {
      "name": "Health",
      "type": {
        "category": "real",
        "subCategory": "",
        "isArray": false,
        "isSet": false,
        "isMap": false
      },
      "defaultValue": "100.0",
      "category": "Combat",
      "tooltip": "",
      "flags": {
        "replicated": true,
        "repNotify": false,
        "instanceEditable": true,
        "blueprintReadOnly": false,
        "exposeOnSpawn": false,
        "savegame": false,
        "transient": false
      }
    }
  ],
  "components": {
    "root": "DefaultSceneRoot",
    "tree": [
      {
        "name": "DefaultSceneRoot",
        "componentClass": "SceneComponent",
        "isRoot": true
      },
      {
        "name": "EnemyMesh",
        "componentClass": "SkeletalMeshComponent",
        "parent": "DefaultSceneRoot",
        "isRoot": false
      }
    ]
  },
  "classDefaults": {
    "properties": [
      {
        "name": "AutoPossessAI",
        "value": "PlacedInWorldOrSpawned",
        "type": "Enum"
      }
    ]
  },
  "eventDispatchers": [],
  "graphs": [
    {
      "name": "EventGraph",
      "graphType": "EventGraph",
      "nodes": [
        {
          "nodeId": "A1B2C3D4-...",
          "nodeClass": "K2Node_Event",
          "displayTitle": "Event BeginPlay",
          "posX": 0,
          "posY": 0,
          "pins": [
            {
              "pinName": "then",
              "pinId": "E5F6A7B8-...",
              "direction": "Output",
              "isExec": true,
              "isHidden": false,
              "linkedPins": [
                {
                  "nodeId": "C9D0E1F2-...",
                  "pinName": "execute",
                  "resolvedNodeId": "C9D0E1F2-..."
                }
              ]
            }
          ]
        },
        {
          "nodeId": "C9D0E1F2-...",
          "nodeClass": "K2Node_CallFunction",
          "displayTitle": "Set Health",
          "posX": 300,
          "posY": 0,
          "pins": [
            {
              "pinName": "execute",
              "direction": "Input",
              "isExec": true,
              "linkedPins": [{"nodeId": "A1B2C3D4-..."}]
            },
            {
              "pinName": "NewValue",
              "direction": "Input",
              "isExec": false,
              "type": {"category": "real"},
              "defaultValue": "100.0",
              "linkedPins": []
            },
            {
              "pinName": "then",
              "direction": "Output",
              "isExec": true,
              "linkedPins": [
                {"nodeId": "D3E4F5A6-...", "resolvedNodeId": "D3E4F5A6-..."}
              ]
            }
          ]
        },
        {
          "nodeId": "D3E4F5A6-...",
          "nodeClass": "K2Node_CallFunction",
          "displayTitle": "Print String",
          "posX": 600,
          "posY": 0,
          "pins": [
            {
              "pinName": "InString",
              "direction": "Input",
              "isExec": false,
              "defaultValue": "Enemy spawned",
              "linkedPins": []
            }
          ]
        }
      ]
    }
  ]
}

GUIDs are truncated in this example. In actual output, full 32-character GUIDs appear in every nodeId and pinId field. The example also omits some pin fields; real output includes all pins on every node.

Choosing a Format#

Need	Format
Does this asset exist? What type?	`overview`
Scan many assets quickly	`overview`
Understand a Blueprint's structure	`summary`
Paste into AI chat for analysis	`summary`
Prepare for write operations (need node GUIDs)	`detail`
See all nodes including disconnected/orphaned	`backup`
Programmatic parsing (Python, CI/CD)	`backup`
Full asset backup or migration	`backup`

Command Examples#

# Default export (summary format)
-verb=export -asset=/Game/Blueprints/BP_Enemy

# Quick scan (overview)
-verb=export -asset=/Game/Blueprints/BP_Enemy --format=overview

# Get node GUIDs for write operations
-verb=export -asset=/Game/Blueprints/BP_Enemy --format=detail

# Full JSON for programmatic use
-verb=export -asset=/Game/Blueprints/BP_Enemy --format=backup

# Export to file instead of stdout
-verb=export -asset=/Game/Blueprints/BP_Enemy --format=detail -out=C:/exports/enemy.txt