Understand Struct

Struct is Blatent’s model for structured decisions. It turns messages, documents and other input into constrained JSON: extracted fields, classifications, chosen actions or generated content.

Start with input and a JSON Schema. Add application state for facts your backend knows, and policies for additional rules the answer must satisfy.

Input: the material to interpret

The input field holds the material to interpret: messages, documents, logs or formatted text such as XML, YAML or Markdown. Send text as a string in the JSON request body, or pass a JSON value directly.

Schema: the answer to generate

Send a JSON Schema in schema to define the output fields, types and constraints. Field descriptions guide Struct's interpretation; schema rules restrict the allowed values. For example, an enum limits a support category to “billing”, “technical” or “other”, while its description explains how to choose.

State: facts your application supplies

The optional state field is a JSON object of application facts supplied alongside the input. For example, send a customer's refund request in input and the order's payment status in state.

State provides context. To enforce restrictions, Struct's schema extensions under x-runtime can use those facts to limit choices, such as making refund approval unavailable for an unpaid order.

Policy: additional rules the answer must satisfy

The optional policy field adds rules for the answer, such as requiring a total to equal the sum of its line items. Struct evaluates them with Open Policy Agent (OPA), a policy engine. You write the rules in its language, Rego.

If a candidate fails a policy, Struct searches for alternatives within the configured budget. It returns a compliant answer, or an error if none is found.

The response

The API returns a JSON object with the generated answer in output, alongside metadata such as usage. Your schema applies to the value inside output.

A successful answer satisfies the supported schema constraints and any attached policy. Evaluate its interpretation accuracy too: an allowed category can still be the wrong classification.

Where Struct fits

Struct is an LLM built for software that needs fast, accurate generation at low cost. It combines interpretation with enforceable output rules, so your application controls what it can return.

It shines in high-volume extraction, classification, workflow routing and constrained content generation, where latency, cost and predictable behavior matter on every request.

Find a guide

Start with your first request, or jump to a feature below. Each guide stands alone, with files and request examples in Python, TypeScript and cURL.

• Make your first request

  Send input and a schema, then read the answer.

• Define your output

  Choose fields, types and allowed values.

• Write effective descriptions

  Tell Struct what each field means and how to choose its value.

• Combine constraints

  Require several rules, allow alternatives or exclude values.

• Reuse schema definitions

  Define a shared schema once and use it in several fields.

• Supply application state

  Attach facts your application already knows.

• Control flow

  Shape decisions with conditions, switches and for-each loops.

• Extract exact source text

  Return exact excerpts from the input without rewriting them.

• Reduce label bias

  Compare candidates with interchangeable IDs.

• Enforce rules with OPA

  Write rules that every returned answer must satisfy.

• Use state in OPA rules

  Check generated answers against application facts.

• Use OAuth scopes

  Apply verified permissions from your application.

• Register and reuse schemas

  Store a schema once and reuse it by ID.

Browse worked examples for complete use cases, or the resolve reference for request and response details.