Progettare uno schema JSON
Modelli l’output esattamente secondo le sue esigenze.
Progettare uno schema JSON è una lezione Claude Architect gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Claude Architect, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Claude Architect include 4 lezioni in totale.
Perché un output conforme allo schema
Quando serve la risposta di Claude in una struttura precisa, non analizzi il testo libero sperando che vada tutto bene. Abbini tool_use a uno JSON Schema: Claude compila l'input_schema di uno strumento e l'API garantisce JSON valido con la presenza dei campi richiesti.
In questo modo si eliminano due intere categorie di errori: gli errori di sintassi (virgole mancanti, virgolette non precedute da escape) e i campi mancanti. Lo schema È il contratto: lo progetti bene e il codice a valle non dovrà mai gestire strutture malformate.
Lo strumento è lo schema
Uno "strumento" per l'output strutturato non deve necessariamente chiamare qualcosa. È semplicemente un contenitore denominato il cui input_schema descrive la struttura che si desidera ottenere. Lo definisci, poi leggi ciò che Claude ha inserito nella chiamata allo strumento.
Assegna allo strumento un nome e una descrizione chiari: continuano a determinare la selezione. Il lavoro vero, però, si trova nelle properties dello schema e nell'elenco required.
extract_invoice = {
"name": "extract_invoice",
"description": "Record the structured fields parsed from an invoice document.",
"input_schema": {
"type": "object",
"properties": {
"invoice_number": {"type": "string"},
"total": {"type": "number"},
},
"required": ["invoice_number", "total"],
},
}Forzare la struttura con tool_choice
Se desideri un output strutturato garantito, non lasciare la scelta al caso. Imposta tool_choice per forzare una chiamata allo strumento:
"auto"— il modello sceglie tra testo e strumento"any"— il modello DEVE chiamare uno strumento (garantisce un output strutturato){"type":"tool","name":"X"}— forza l'uso di uno strumento specifico
Per l'estrazione con un singolo schema, forzare lo strumento esatto tramite il nome è il modo più semplice per ottenere una struttura deterministica.
resp = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
tools=[extract_invoice],
tool_choice={"type": "tool", "name": "extract_invoice"},
messages=[{"role": "user", "content": invoice_text}],
)Required significa sempre presente
La regola più importante dello schema: contrassegna un campo come required SOLO se è sempre presente nella fonte. Non rendere mai obbligatorio un campo che potrebbe essere assente.
Perché? Un campo obbligatorio costringe il modello a produrre un valore. Se il dato non è presente, Claude ne inventerà uno per rispettare il contratto. Un campo facoltativo ma assente è onesto; un campo obbligatorio ma mancante favorisce le allucinazioni.
Campi facoltativi, nel modo corretto
Per i campi che possono comparire oppure no — una riga di sconto, un contatto secondario, una data di scadenza — non inserirli in required. Descrivili chiaramente, così Claude li compilerà solo quando i dati esistono davvero.
Una buona descrizione indica al modello il formato dell'input e la regola per l'assenza, così il campo viene omesso invece di essere inventato.
"properties": {
"invoice_number": {"type": "string"},
"total": {"type": "number"},
"due_date": {
"type": "string",
"description": "ISO 8601 date (YYYY-MM-DD). Omit entirely if no due date is stated."
},
},
"required": ["invoice_number", "total"]Gli enum vincolano l'output
Quando un campo ha un vocabolario fisso — stato, categoria, priorità — usa un enum. In questo modo il testo libero e disordinato ("paid", "PAID", "settled") viene ricondotto a un unico valore canonico su cui il codice può eseguire uno switch.
Gli enum riducono anche le allucinazioni: il modello deve scegliere dall'insieme elencato invece di inventare un'etichetta.
"status": {
"type": "string",
"enum": ["draft", "sent", "paid", "overdue", "void"],
"description": "Current invoice status."
}Progettare enum estendibili
Gli enum rigidi si rompono quando la realtà introduce un nuovo caso. Il modello adottato dagli architetti consiste nell'aggiungere un valore "other" all'enum E un campo detail di testo libero, per registrare ciò che era effettivamente "altro".
In questo modo lo schema rimane valido anche per input imprevisti, non si perdono informazioni e si può analizzare il campo detail per decidere se sia opportuno aggiungere un nuovo valore all'enum.
"category": {
"type": "string",
"enum": ["hardware", "software", "services", "other"]
},
"category_detail": {
"type": "string",
"description": "If category is 'other', describe it here. Omit otherwise."
}Le descrizioni insegnano
Le descrizioni dei campi sono mini-prompt. Chiavi vaghe producono output vaghi. Specifica il formato, fornisci un esempio e indica la gestione dei casi limite direttamente nello schema.
È l'equivalente, per l'output strutturato, del principio secondo cui criteri espliciti sono migliori di istruzioni vaghe: "data ISO 8601, ometti se assente" è sempre preferibile a un semplice due_date: string.
"line_items": {
"type": "array",
"description": "One object per billed line. Empty array if none.",
"items": {
"type": "object",
"properties": {
"sku": {"type": "string", "description": "e.g. 'ABC-1024'"},
"qty": {"type": "integer"},
"unit_price": {"type": "number"}
},
"required": ["qty", "unit_price"]
}
}Integrare l'autoverifica
Gli schemi ben progettati aiutano a individuare gli errori. Per verificare i calcoli, estrai SIA un valore calcolato SIA un valore dichiarato, poi confrontali nel codice.
Ad esempio, acquisisci stated_total (stampato sul documento) insieme alle voci che puoi sommare autonomamente. Una discrepanza segnala un errore di estrazione o del documento prima che si propaghi ai sistemi a valle.
"stated_total": {
"type": "number",
"description": "The grand total exactly as printed on the invoice."
}
# In code:
# calc = sum(li['qty'] * li['unit_price'] for li in items)
# if abs(calc - data['stated_total']) > 0.01: flag_discrepancy()Convalidare, poi riprovare con feedback
Lo schema garantisce la struttura del JSON, non la correttezza rispetto alla logica aziendale. Aggiungi una convalida in stile Pydantic. Quando rileva un errore di formato, strutturale o aritmetico, riprova, ma comunica al modello che cosa non ha funzionato.
Invia il documento originale, l'output errato e l'errore di convalida esatto. Questo è il retry con feedback. Nota: riprovare NON aiuta quando l'informazione è semplicemente assente nella fonte: nessuna richiesta ripetuta può far comparire dati mancanti.
messages = [
{"role": "user", "content": original_doc},
{"role": "assistant", "content": wrong_output},
{"role": "user", "content":
f"Validation failed: {error}. Re-emit corrected JSON."},
]
# Retry fixes format/arithmetic bugs, not missing facts.Acquisire la provenienza nello schema
Per le estrazioni che dovrai difendere in seguito, progetta campi che conservino la provenienza: l'origine di ogni informazione. Mantieni le associazioni tra affermazioni e fonti: nome della fonte, citazione, pagina o data.
In questo modo un'estrazione a scatola nera diventa verificabile, e puoi annotare valori in conflitto (spesso una differenza di data) invece di sceglierne uno in silenzio.
"items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"value": {"type": "string"},
"source_quote": {"type": "string",
"description": "Verbatim text supporting this value."},
"source_page": {"type": "integer"}
},
"required": ["value", "source_quote"]
}
}Verifica rapida: campo facoltativo
Stai estraendo ordini di acquisto. Alcuni ordini contengono un discount_code, ma la maggior parte no. Come dovrebbe gestire lo schema discount_code?
Riepilogo: dare forma all'output
Punti chiave per progettare uno JSON Schema:
- tool_use + JSON Schema elimina gli errori di sintassi e impone la presenza dei campi richiesti.
- Forza la struttura con
tool_choice:"any"per un qualsiasi strumento,{"type":"tool","name":"X"}per uno specifico. - Indica un campo come
requiredSOLO se è sempre presente: rendere obbligatorio un campo assente provoca invenzioni. - Usa gli enum per i vocabolari fissi; aggiungi
"other"e un campo detail per consentire estensioni. - Le descrizioni insegnano formato, esempi e gestione dei casi limite.
- Estrai sia i valori calcolati SIA quelli dichiarati per l'autoverifica; convalida, poi riprova con feedback per gli errori di formato, non per le informazioni assenti.
- Acquisisci la provenienza per ottenere un'estrazione verificabile e difendibile.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 26
- Lezioni
- 104
Domande Frequenti
La lezione «Progettare uno schema JSON» è gratuita?
Sì — il testo completo di «Progettare uno schema JSON» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Claude Architect, passa a CoddyKit PRO. Il corso Claude Architect include 4 lezioni in totale.
Cosa imparerò in «Progettare uno schema JSON»?
Modelli l’output esattamente secondo le sue esigenze. Eserciti Claude Architect con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Claude Architect?
Non è richiesta alcuna esperienza precedente. Claude Architect su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Progettare uno schema JSON»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Claude Architect?
Sì. Ogni lezione Claude Architect include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- tool_use per una struttura garantita
- Progettare uno schema JSON
- Campi obbligatori vs facoltativi/nullable
- Enum con «other» per l’estensibilità