CODLAB / Blog · IA e integrazione

Output strutturati per LLM e guardrail: decoding vincolato da grammatica, JSON Schema e validazione di dominio

14 nov 2026 CODLAB Team 13 min

Aggiornato a novembre 2026 · CODLAB Team

Risposta diretta: Collegare modelli linguistici di grandi dimensioni ai software gestionali richiede molto più di una richiesta di JSON nel prompt: un'integrazione affidabile unisce decoding vincolato da grammatica secondo JSON Schema, ordine verificato di emissione dei campi e validazione deterministica di dominio e delle fonti nel codice applicativo per evitare errori sintattici e azioni improprie.

Perché il testo libero fallisce al confine con i processi software aziendali

Finché un modello linguistico redige un paragrafo per la sola lettura umana, piccole variazioni di formato restano innocue. Quando invece opera come componente di un'architettura software — per classificare ticket, estrarre righe d'ordine da PDF tecnici, precompilare maschere gestionali o invocare uno strumento autorizzato — ogni deviazione formale diventa un'eccezione a runtime. Nella ricerca applicata di CODLAB su IA sovrana e dati e nello sviluppo software su misura in Django trattiamo perciò gli output strutturati come un contratto formale d'interfaccia tra generazione stocastica e servizi backend tipizzati.

Nei prototipi iniziali si tenta spesso di imporre la struttura tramite semplici istruzioni nel prompt di sistema («Rispondi esclusivamente con JSON valido senza blocchi Markdown»). Sotto carico reale questo approccio cede regolarmente su quattro fronti: il modello racchiude comunque l'output in delimitatori di codice, tronca la stringa al raggiungimento del limite di token, produce sequenze di escape non valide o caratteri di controllo non mascherati contrari alla specifica JSON (Bray, IETF RFC 8259, 2017) oppure introduce chiavi inesistenti rifiutate dal parser a valle.

Questo studio analizza il funzionamento del decoding vincolato da grammatica nei motori di inferenza, gli effetti collaterali dei vincoli rigidi sulla distribuzione di probabilità e sulle capacità di ragionamento, e il motivo per cui anche un oggetto conforme a JSON Schema (Draft 2020-12) richiede sempre un secondo livello di controllo deterministico nel codice applicativo. L'analisi approfondisce il piano delle interfacce già delineato nello studio su agenti IA, invocazione di strumenti e guardrail ristretti.

1. Dalle istruzioni nel prompt al decoding vincolato tramite automi e grammatiche

Anziché riparare stringhe malformate a valle, i motori di serving moderni applicano le regole sintattiche durante la selezione dei token. A ogni passo autoregressivo il modello calcola i logit sul vocabolario; nel constrained decoding un automa formale individua le prosecuzioni ammissibili per lo stato corrente della grammatica e imposta a meno infinito i logit dei token non validi prima del campionamento.

Brandon T. Willard e Rémi Louf hanno mostrato come espressioni regolari e grammatiche libere dal contesto possano essere riformulate come transizioni di automi a stati finiti (FSM) pre-indicizzate sul vocabolario del modello, garantendo il rispetto della struttura con un sovraccarico trascurabile per singolo passo (Willard & Louf, 2023, arXiv:2307.09702). Per schemi JSON annidati o firme ricorsive di funzioni occorre un automa a pila associato a una grammatica libera dal contesto (CFG). Yixin Dong et al. dimostrano con XGrammar come separare le maschere di token indipendenti dal contesto, precalcolate in cache, dalle regole dipendenti dallo stack valutate su una pila persistente, riducendo la generazione delle maschere sotto i 40 microsecondi per token anche su vocabolari estesi (Dong et al., 2024, arXiv:2411.15100).

Sul piano architetturale questo meccanismo offre tre garanzie precise — insieme a un limite strutturale invalicabile:

  • Parsabilità garantita secondo RFC 8259: se il budget di token non si esaurisce prima della parentesi di chiusura radice, la stringa è sempre leggibile da un parser JSON standard.
  • Rispetto rigoroso di chiavi e tipi secondo JSON Schema: tramite required ed enum del vocabolario JSON Schema Validation insieme ad additionalProperties: false il modello non può inventare attributi imprevisti né emettere testo dove è atteso un numero.
  • Assenza totale di verifica semantica e fattuale: l'automa sa che in una determinata posizione è sintatticamente lecito inserire una stringa o un codice documento, ma non può sapere se quel codice esista davvero nelle fonti estratte o rispetti le regole aziendali.

2. Distorsione della distribuzione e ordine di emissione: quando lo schema riduce l'accuratezza

Nella pratica ingegneristica si osserva spesso un fenomeno controintuitivo: passando da una risposta in testo libero a uno schema JSON rigido sul medesimo contesto documentale, la precisione logica del modello peggiora. La letteratura scientifica recente individua due cause distinte che guidano direttamente la progettazione degli schemi.

In primo luogo, il mascheramento locale dei token altera la distribuzione di probabilità condizionata del modello. Come dimostrano Kanghee Park et al. introducendo il Grammar-Aligned Decoding, azzerare in modo greedy i token non grammaticali a ogni singolo passo tronca localmente massa di probabilità senza rinormalizzare sull'insieme delle sequenze complete valide, producendo uscite grammaticali ma campionate con probabilità distorte rispetto alla distribuzione reale del modello (Park et al., NeurIPS 2024, arXiv:2405.21047). Ciò avviene, ad esempio, quando i prefissi della tokenizzazione subword spingono la generazione in rami sintattici con poche continuazioni valide.

In secondo luogo, i vincoli di formato comprimono il ragionamento intermedio. Zhi Rui Tam et al. mostrano su diversi compiti deduttivi che vincoli rigidi JSON o XML possono ridurre sensibilmente l'accuratezza rispetto alla generazione libera (Tam et al., 2024, arXiv:2408.02442). Nelle specifiche JSON e JSON Schema le proprietà di un oggetto sono insiemi non ordinati; molti motori di decoding emettono tuttavia le chiavi nell'ordine dichiarato. Sebbene i passaggi estratti siano già presenti nel prompt in prefill, nella generazione autoregressiva ogni token emesso dipende solo dal prompt e dai token già generati, mai da quelli successivi: se il motore emette action prima di citations e reasoning_summary, la classe viene campionata prima di esplicitare passaggi intermedi nell'output.

Da queste evidenze deriviamo due principi progettuali per gli schemi:

  1. Ordine prove-prima-del-verdetto come ipotesi progettuale verificabile: quando il motore di serving rispetta l'ordine dichiarato, collochiamo le citazioni (citations con verbatim_quote) e la sintesi (reasoning_summary) prima di action, misurandone l'effetto con il test di ablazione nella sezione 5.
  2. Separare ragionamento e formattazione nei compiti complessi: quando l'analisi richiede confronti multi-passaggio su tabelle e specifiche dense — come i blocchi prodotti dalla nostra pipeline strutturata di ingestione PDF e tabelle — disaccoppiamo la sintesi analitica dal passaggio finale di estrazione strutturata.

3. Validità sintattica non significa validità di dominio: guardrail a doppio livello nel codice

Anche un oggetto JSON conforme allo schema resta il prodotto probabilistico di un modello neurale. Tra «conforme allo schema JSON» e «idoneo alla scrittura su PostgreSQL» permane uno scarto critico in cui emergono tre classi di errore: identificativi di fonte inventati, violazione di invarianti contabili o relazionali tra campi e automazione impropria in presenza di bassa confidenza.

Anche qui manteniamo una distinzione trasparente tra la nostra architettura aziendale di destinazione per output strutturati e l'essenziale assistente di riferimento (ragbot) nel codice di codlab.de (la cui demo pubblica di chat è spenta da ottobre 2026, mentre codice e dati restano conservati): in ragbot/services.py la chiamata viene eseguita con max_tokens=450 e temperature=0.2 restituendo prosa libera senza JSON Schema, mentre i vincoli commerciali sono applicati in modo deterministico dal modulo price_policy.py su tre confini (domanda utente, frammenti estratti e risposta finale ripulita da marcatori Markdown ed entità HTML). Per un dialogo informativo circoscritto quel filtro è adeguato; per transazioni applicative strutturate occorre invece un controllo tipizzato.

Nell'architettura aziendale abbiniamo sempre il decoding vincolato a un validatore deterministico di dominio in Python che verifica integrità referenziale rispetto ai chunk effettivamente estratti, corrispondenza letterale delle citazioni e soglie di passaggio alla revisione umana prima di qualsiasi salvataggio:

ALLOWED_ACTIONS = {"route_support", "request_clarification", "needs_human_review"}

def validate_ticket_decision(payload: dict, retrieved_chunks: dict[str, str], min_quote_len=24):
    """Deterministic post-schema guardrail checking provenance and policy invariants."""
    action = payload.get("action")
    if action not in ALLOWED_ACTIONS:
        raise ValueError(f"Unsupported action enum: {action}")
    conf = float(payload.get("confidence", 0.0))
    if not (0.0 <= conf <= 1.0):
        raise ValueError("Confidence outside [0.0, 1.0]")
    if conf < 0.75 and action != "needs_human_review":
        action = "needs_human_review"
        payload = {**payload, "action": action}
    citations = payload.get("citations") or []
    if action != "needs_human_review" and not citations:
        raise ValueError("Missing verbatim evidence")
    for ref in citations:
        chunk_text = retrieved_chunks.get(ref.get("chunk_id", ""))
        quote = (ref.get("verbatim_quote") or "").strip()
        if not chunk_text or len(quote) < min_quote_len or quote not in chunk_text:
            raise ValueError("Citation fails verbatim provenance check")
    return payload

Se un controllo fallisce, il payload non viene mai salvato silenziosamente: la pipeline scarta l'oggetto, tenta al massimo una singola correzione confinata con l'errore esplicito oppure passa in modo deterministico la pratica a needs_human_review.

4. Confini di sicurezza: perché JSON Schema da solo non neutralizza la Prompt Injection

Un equivoco diffuso nei team di sviluppo consiste nel ritenere che uno schema rigoroso con additionalProperties: false neutralizzi automaticamente gli attacchi di iniezione del prompt. In realtà il vincolo grammaticale impedisce all'attaccante di rompere la sintassi JSON o di aggiungere chiavi non dichiarate, ma non impedisce che contenuti esterni manipolati orientino i valori inseriti nei campi consentiti.

L'Ufficio federale tedesco per la sicurezza informatica descrive nel rischio R28 (Indirect Prompt Injection) come istruzioni malevole annidate in fonti esterne possano condizionare il comportamento dei modelli generativi (BSI, Generative KI-Modelle, Versione 2.0, 17.01.2025). Analogamente, il profilo sull'IA generativa del NIST annovera nella sezione 2.9 (Information Security) la prompt injection diretta e indiretta tra gli attacchi che ampliano la superficie d'attacco dei sistemi di IA generativa (NIST AI 600-1, Generative Artificial Intelligence Profile, 2024). Se un allegato esterno contiene una direttiva nascosta, il modello può comunque emettere un JSON formalmente impeccabile ma contenente una coda di destinazione alterata, un testo manipolato o un identificativo fittizio.

Nella nostra architettura di destinazione per backend Django gli output strutturati seguono perciò tre regole di sicurezza:

  • Enumerazioni chiuse al posto di parametri eseguibili: azioni di workflow, nomi di strumenti e code di smistamento usano esclusivamente insiemi chiusi enum, mai nomi di funzioni liberi, frammenti SQL o URL generati dal modello.
  • Verifica lato server di tenant e permessi su ogni ID: qualunque identificativo di record proposto dal modello viene controllato rispetto al queryset Django autorizzato per il tenant corrente prima di eseguire letture o scritture.
  • Escaping contestuale dei campi stringa nelle viste UI: le stringhe libere nei JSON validati restano dati non attendibili nel browser; la difesa da Cross-Site Scripting (XSS) poggia sull'auto-escaping rigoroso dei template Django (senza mai usare |safe o mark_safe sui valori del modello), mentre gate distinti come Playwright + axe-core come gate di rilascio verificano layout e accessibilità.

5. Protocollo sperimentale riproducibile per pipeline di estrazione e instradamento

Nota metodologica: lo scenario seguente è sintetico e illustra il metodo di ricerca applicata; non descrive incarichi né metriche di clienti.

Supponiamo che un'azienda manifatturiera voglia pre-strutturare tramite un modello linguistico le richieste di assistenza tecnica in tre lingue (tedesco, inglese, italiano), allegando i passaggi pertinenti dei manuali e indirizzando il ticket al reparto corretto in Django. Per stabilire in modo oggettivo se l'accoppiata modello-schema sia pronta per l'esercizio, misuriamo un catalogo di 50 richieste sintetiche su 5 esecuzioni ripetute per ciascun caso (secondo il metodo esposto nello studio sulla valutazione dell'IA stocastica su esecuzioni multiple e nella nota valutazione RAG come test di regressione):

  1. Tasso di conformità sintattica allo schema: quota di risposte conformi sia a RFC 8259 sia al JSON Schema definito senza riparazioni testuali, inclusi casi limite vicini al tetto di token.
  2. Tasso di superamento degli invarianti di dominio e citazione: quota di oggetti sintatticamente validi i cui riferimenti chunk_id e le cui citazioni letterali superano la verifica deterministica delle sottostringhe in Python.
  3. Test di ablazione sull'ordine di emissione: confronto diretto di accuratezza sui medesimi casi tra emissione del verdetto prima delle prove ed emissione delle prove prima del verdetto.
  4. Calibrazione dell'escalation prudenziale: verifica su richieste ambigue o incomplete della capacità della pipeline di attivare in modo affidabile needs_human_review anziché produrre uno smistamento errato.

Ulteriori dettagli sui criteri di verifica backend sono nelle CODLAB Engineering Notes. Per integrare modelli linguistici nei processi gestionali con interfacce verificate anziché semplici chat, scriveteci tramite Contatto e richiesta progetto.

Approfondimenti nella serie di ricerca: per esaminare come macchine a stati e permessi minimi governino assistenti multi-passaggio rimandiamo allo studio su agenti IA e guardrail ristretti; per le metriche statistiche sulla stabilità tra esecuzioni ripetute si veda l'analisi su valutazione su esecuzioni multiple.

Fonti primarie verificate

Domande frequenti (FAQ)

Il decoding vincolato tramite JSON Schema garantisce automaticamente risultati corretti sul piano applicativo?

No. Il decoding guidato da grammatica garantisce soltanto che la risposta sia JSON sintatticamente valido e rispetti tipi di dato e campi obbligatori. Verificare che le citazioni esistano davvero nelle fonti, che i calcoli tornino e che le regole aziendali siano rispettate richiede un validatore deterministico nel codice.

Perché l’ordine di emissione dei campi può contare negli output LLM anche se gli oggetti JSON non sono ordinati?

JSON Schema definisce le proprietà degli oggetti come non ordinate, ma molti motori di decoding emettono le chiavi nell’ordine dichiarato. Anche se le fonti sono già nel prompt, il decoding autoregressivo genera i token da sinistra a destra: emettere il verdetto prima di citazioni e sintesi omette passaggi espliciti nell’output, perciò verifichiamo l’ordine dei campi con test di ablazione.

Uno schema JSON rigoroso protegge dagli attacchi di Indirect Prompt Injection?

Impedisce rotture della sintassi JSON e l’aggiunta di chiavi non previste, ma non la manipolazione dei contenuti. Istruzioni ostili presenti in documenti esterni (rischio BSI R28) possono comunque alterare i valori dei campi ammessi, che non devono mai finire senza controlli in query, permessi o comandi di sistema.

Come deve comportarsi il backend quando un oggetto JSON non supera la validazione di dominio?

Gli oggetti non conformi non devono mai essere salvati silenziosamente. Nelle architetture di produzione si consente al massimo un singolo tentativo confinato di correzione con il dettaglio dell’errore, passando altrimenti la pratica in modo deterministico alla revisione umana.

Guida operativa correlata (in tedesco): KI im Unternehmen einführen: Vom Arbeitsauftrag zur überprüfbaren Freigabe.

Condividi questo articolo

Commenti

Nessun commento ancora. Sii il primo a commentare!

Lascia un commento

Non sarà pubblicata

Articoli Correlati

Hai un progetto in mente?

Sviluppiamo software personalizzato e soluzioni IA. Iniziamo insieme il tuo prossimo progetto.

Primo colloquio gratuito