Features

Author LLM data pipelines as DAGs in the graph editor or in Python via the SDK. Run with a result cache, schema contracts, and resumable runs. Self-hosted on FastAPI + Postgres.

Two ways to author a workflow

The graph editor and the Python SDK produce the same JSON document. Switch freely between them.

✎

Graph editor

Drag nodes, connect ports, configure inline.

Input PDF
LLM Prompt Extract
Sink Dataset
  • •React Flow canvas: pan, zoom, undo / redo, minimap.
  • •Connections checked against port schemas before they complete.
  • •Inline config for prompts, models, schemas, retry policies.
❯

Python SDK

Define workflows in code; produce the same JSON.

from pydantic import BaseModel
from substructure_sdk import Workflow

class Fields(BaseModel):
    title: str
    score: float

wf = Workflow("extract")
inp = wf.input("inp")
ext = wf.llm(
    "ext",
    model="gemini-3.5-flash",
    user_prompt="Extract: {{input.text}}",
    output_schema=Fields,
)
out = wf.output("out")
wf.connect(inp, ext).connect(ext, out)
  • •Node factories build the same JSON the server accepts.
  • •Pydantic BaseModel as output_schema; Pydantic itself optional.
  • •Validate locally; httpx client runs and polls workflows.

LLMs

Per-node provider and model selection with structured output.

Per-node model selection

Pick a provider (Gemini, GPT, Claude, and more) and a model for each LLM Prompt node. Model and provider must be set at creation; missing config fails loudly rather than defaulting silently.

Structured output

Define an output schema (or pass a Pydantic model via the SDK). Responses are forced to match — no parsing freeform text and hoping for the best.

Response repair

Markdown fence stripping, escape repair, and JSON extraction run before schema validation. When repair fails, the raw response is editable and revalidatable without re-calling the model.

Execution engine

In-process scheduler with caching, retries, and resume.

Result cache

Each node result is keyed by config + input. Identical inputs reuse the cached output across runs and workflows; file inputs are hashed by content so uploads dedupe.

Resumable runs

A failed run resumes from its last successful checkpoint. Only failed and downstream nodes re-execute. Schema changes are validated against cached results.

Run inspector

Run status overlays the editor live. Click any node for its actual input, output, timing, cost, retry attempts, and logs. Map iterations are tracked individually with partial replay and rerun.

Schemas

Typed contracts on every node port, checked at design time and at runtime.

Schema editor

Build nested schemas with a form, or paste raw JSON Schema. Field types, requireds, constraints. The Python SDK accepts plain Pydantic models in the same slots.

Design-time edge validation

Edges between incompatible ports are flagged in the editor with the path that doesn't match. The body of a Map narrows its inputs against the body node's input schema.

Retry and on-error policies

Retry policies (max attempts, backoff with jitter) are independent from on-error actions (skip, fallback, pause). Map iterations honor retries independently per item.

Datasets

Structured workflow output, browsable and queryable.

Dataset sinks

Route output into datasets that grow over time. Records link back to the run, workflow version, and source input that produced them. Sinks with a primary key upsert; rows are deletable from the viewer.

Browse and inspect

Filter, sort, and search a dataset's rows in a table view. Trace any record back to its source input and the run that created it.

Export and re-run

Download as CSV or JSON. Re-run selected records through an updated workflow to regenerate results with new prompts or models.

Triggers, integrations, hosting

External triggers, run callbacks, and self-hosting.

Webhook triggers

Each workflow exposes a unique URL. POST a payload to start a run. HMAC signing with a per-workflow secret keeps it private.

Run completion callbacks

Subscribe a URL per run. The server POSTs the final result (or failure) when the run finishes. Google Forms integration works via a generated Apps Script — no Google API credentials needed.

Self-hosted

FastAPI + Postgres + the React frontend. Bring your own provider API keys. Files flow through a configurable FileStore (local filesystem or S3) — nothing leaves your network.

Try Substructure

Self-hosted version is rolling out first. Get in touch to talk about access or use cases.

Contact us