Skip to main contentSkip to footer
EsempioscriptintermediateEseguibileschema-validation

Validazione: garantisce che gli output degli LLM corrispondano a schemi di dati predefiniti.

Questo componente fornisce validazione dello schema e parsing di dati strutturati per assicurare formati coerenti per il codice a valle.

Fatti chiave

Livello
intermediate • Blocchi di Costruzione degli Agenti
Runtime
Python • API OpenAI
Pattern
Structured extraction with explicit acceptance criteria
Interazione
Sandbox live • Script
Aggiornato
14 marzo 2026

Naviga questo esempio

Vista rapida del flusso

Come questo esempio si muove tra input, esecuzione e risultato rivedibile
Validazione: garantisce che gli output… -> Validate structured output -> Free-form input -> Schema parse -> Safe handoff -> Natural-language input, structured output

Trigger

Validazione: garantisce che gli output…

Runtime

Validate structured output

Esito

Free-form input

Perché esiste questa pagina

Questo esempio è mostrato sia come codice sorgente reale che come pattern di interazione orientato al prodotto, così i discenti possono collegare implementazione, UX e dottrina senza lasciare la libreria.

Flusso visivoCodice realeSandbox o walkthroughAccesso MCP
Come dovrebbe essere usato questo esempio nella piattaforma?

Usa prima la sandbox per comprendere il pattern di esperienza, poi ispeziona il sorgente per vedere come il confine del prodotto, il confine del modello e il confine della dottrina sono effettivamente implementati.

UX pattern: Structured extraction with explicit acceptance criteria
Natural-language input, structured output
Validation creates a reviewable contract
Downstream code can act on the result safely
Riferimenti sorgente
Voce di libreria
agents-building-blocks-4-validation
Percorso sorgente
content/example-library/sources/agents/building-blocks/4-validation.py
Librerie
openai, pydantic, requests
Requisiti di runtime
OPENAI_API_KEY
Principi correlati
Progettare per la delega piuttosto che per la manipolazione diretta, Sostituire la magia implicita con modelli mentali chiari, Stabilire fiducia attraverso l'ispezionabilità, Rendere espliciti i passaggi, le approvazioni e i blocchi, Ottimizzare per la guida, non solo per l'inizio

4-validation.py

python
"""
Validation: Ensures LLM outputs match predefined data schemas.
This component provides schema validation and structured data parsing to guarantee consistent data formats for downstream code.

More info: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses
"""

from openai import OpenAI
from pydantic import BaseModel


class TaskResult(BaseModel):
    """
    More info: https://docs.pydantic.dev
    """

    task: str
    completed: bool
    priority: int


def structured_intelligence(prompt: str) -> TaskResult:
    client = OpenAI()
    response = client.responses.parse(
        model="gpt-4o",
        input=[
            {
                "role": "system",
                "content": "Extract task information from the user input.",
            },
            {"role": "user", "content": prompt},
        ],
        text_format=TaskResult,
    )
    return response.output_parsed


if __name__ == "__main__":
    result = structured_intelligence(
        "I need to complete the project presentation by Friday, it's high priority"
    )
    print("Structured Output:")
    print(result.model_dump_json(indent=2))
    print(f"Extracted task: {result.task}")
Cosa dovrebbe ispezionare il discente nel codice?

Cerca il punto esatto in cui lo scope del sistema è delimitato: definizioni di schema, impostazione del prompt, configurazione di runtime e il punto di chiamata che trasforma l'intenzione dell'utente in un'azione concreta del modello o del workflow.

class TaskResult(BaseModel):
response = client.responses.parse(
text_format=TaskResult
return response.output_parsed
Come si relaziona la sandbox al sorgente?

La sandbox dovrebbe rendere leggibile l'UX: cosa vede l'utente, cosa sta decidendo il sistema e come il risultato diventa revisionabile. Il sorgente mostra poi come quel comportamento è effettivamente implementato.

Write a natural-language task description.
Parse it into a schema-bound object.
Inspect the structured result and whether the output is valid enough for downstream use.
SandboxStructured extraction with explicit acceptance criteria
Schema-bound extraction and validation

This sandbox shows how validation turns a vague language model response into a structured contract that downstream code can safely depend on.

Spiegazione UX

The user should not have to guess whether the system extracted the right fields. A validation layer lets the product expose the exact shape of the result and whether it is safe to use.

Spiegazione AI Design

The model is still doing interpretation, but schema parsing constrains how the result is expressed. That turns a fuzzy completion into something application code can route, store, and verify.

Guida all'interazione

  1. 1Write a natural-language task description.
  2. 2Parse it into a schema-bound object.
  3. 3Inspect the structured result and whether the output is valid enough for downstream use.

Natural-language input

Pydantic schemaStructured parse

Schema contract

  • `task: str`
  • `completed: bool`
  • `priority: int`

Parsed result

The parsed object appears here once the schema-bound extraction runs.

What validation changes

  • Natural-language input, structured output
  • Validation creates a reviewable contract
  • Downstream code can act on the result safely
Usato in corsi e percorsi

Principi correlati

Runtime architecture

Usa questo esempio nei tuoi agenti

Questo esempio è disponibile anche tramite il layer agent-ready del blueprint. Usa la pagina Per agenti per recuperare MCP pubblico, export deterministici e setup per Claude o Cursor.

Definisci trigger, contesto e confini prima di aumentare l'autonomia
Rendi espliciti controllo, osservabilita e recovery nel runtime
Scegli i pattern operativi giusti prima di delegare ai workflow