Claude Architect · Lezione

Formati di input ed esempi

Mostri esempi concreti di input per eliminare ogni ambiguità.

Lezione 4 di 413 passaggi

Formati di input ed esempi è una lezione Claude Architect gratuita su CoddyKit. Questa è la lezione 4 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é i formati di input sono importanti

La descrizione di uno strumento è il meccanismo principale che Claude utilizza per decidere quando e come chiamarlo. I soli nomi non forniscono un segnale sufficiente. Una descrizione efficace comprende lo scopo, i valori restituiti, i casi limite, i limiti di applicabilità e, soprattutto, i formati di input.

Questa lezione si concentra su una tecnica molto efficace: mostrare esempi concreti di input, così il modello non deve mai indovinare l'aspetto che dovrebbe avere un parametro.

L'ambiguità è il nemico

Immagini uno strumento con un parametro chiamato date. Deve essere 2026-06-10? 06/10/2026? June 10? Un timestamp Unix? Senza un esempio, Claude deve dedurre il formato, ed è proprio nell'inferenza in condizioni ambigue che nascono le chiamate agli strumenti con formato errato.

Uno schema ambiguo non genera un errore evidente. Fallisce silenziosamente, producendo input che il backend rifiuta. Gli esempi concreti eliminano l'ambiguità alla fonte.

Dove inserire gli esempi

Può inserire esempi di input in due punti complementari:

  • Nel testo della descrizione dello strumento (esempi di utilizzo complessivi).
  • Nella description di ogni parametro all'interno dello JSON Schema (formato del singolo campo).

Entrambi alimentano lo stesso motore di selezione e formattazione. Inserisca le indicazioni sul formato il più vicino possibile al campo a cui si applicano e aggiunga un esempio completo della chiamata.

search_orders = {
    "name": "search_orders",
    "description": (
        "Search a customer's orders by date range. "
        "Dates use ISO 8601 (YYYY-MM-DD). "
        "Example call: search_orders(start='2026-01-01', end='2026-03-31')."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "start": {
                "type": "string",
                "description": "Inclusive start date, ISO 8601. Example: '2026-01-01'."
            },
            "end": {
                "type": "string",
                "description": "Inclusive end date, ISO 8601. Example: '2026-03-31'."
            }
        },
        "required": ["start", "end"]
    }
}

Una descrizione debole e una efficace a confronto

Le confronti. La versione debole costringe a indovinare; quella efficace mostra esattamente quale aspetto debba avere un input valido.

  • Debole: "Cerca un cliente."
  • Efficace: scopo + formato di input + esempio + valori restituiti + casi limite.

Le descrizioni minime e ambigue sono un classico anti-pattern che causa errori di instradamento degli strumenti e argomenti con formato errato.

# Weak: model must guess the id format
bad = {
    "name": "get_customer",
    "description": "Look up a customer."
}

# Strong: shows the exact format with an example
good = {
    "name": "get_customer",
    "description": (
        "Fetch a verified customer profile by account ID. "
        "account_id is the 8-char alphanumeric code from the "
        "welcome email, e.g. 'A1B2C3D4' (not the email address). "
        "Returns name, tier, and verified flag. "
        "Returns isError if no match — ask for more identifiers, never guess."
    )
}

Mostrare la struttura degli input strutturati

Quando un parametro è un oggetto o un array, un singolo esempio vale più di un paragrafo di prosa. Mostri al modello la struttura letterale che deve produrre.

Questo è particolarmente utile per i filtri annidati, gli elementi di una lista o qualsiasi campo la cui struttura non sia evidente dal solo tipo.

filter_param = {
    "type": "object",
    "description": (
        "Structured filter. Example: "
        '{"status": "shipped", "min_total": 50, '
        '"tags": ["priority", "gift"]}. '
        "Omit a key to leave that dimension unfiltered."
    ),
    "properties": {
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered"]},
        "min_total": {"type": "number"},
        "tags": {"type": "array", "items": {"type": "string"}}
    }
}

Per insiemi fissi, gli enum sono migliori del testo libero

Quando un campo ha un insieme noto e finito di valori validi, li codifichi come enum invece di descriverli in prosa. In questo modo lo schema vincola direttamente il modello.

Per garantire l'estensibilità, aggiunga un valore enum "other" e un campo di dettaglio a testo libero, così i nuovi casi non costringeranno il modello a inventare un valore non valido.

reason = {
    "type": "object",
    "properties": {
        "category": {
            "type": "string",
            "enum": ["defective", "wrong_item", "late", "other"],
            "description": "Refund reason. Use 'other' for anything unlisted."
        },
        "detail": {
            "type": "string",
            "description": "Free text. Required only when category is 'other'."
        }
    },
    "required": ["category"]
}

Gli esempi riducono gli input allucinati

Gli esempi few-shot sono uno degli strumenti di prompting più affidabili. Con 2–4 esempi mirati per ogni ambiguità, il modello generalizza lo schema invece di limitarsi a ripeterlo.

Applicati agli input degli strumenti, gli esempi sono ideali per garantire coerenza, gestire i casi limite, definire il formato dell'output e ridurre le allucinazioni: esattamente i casi di errore che producono argomenti non validi per gli strumenti.

phone = {
    "type": "string",
    "description": (
        "Phone in E.164 format. "
        "Examples: '+14155552671', '+442071838750'. "
        "Do NOT include spaces, dashes, or parentheses."
    )
}

Contrassegnare come obbligatorio solo ciò che è sempre presente

Gli esempi indicano al modello l'aspetto di un input valido; l'array required gli indica cosa deve comparire. Una regola fondamentale: contrassegni un campo come obbligatorio solo se è sempre presente.

Se rende obbligatorio un campo che potrebbe mancare nella fonte, il modello inventerà un valore per soddisfare lo schema. Un campo facoltativo ma ben esemplificato è preferibile a uno obbligatorio ma talvolta assente.

schema = {
    "type": "object",
    "properties": {
        "order_id": {"type": "string", "description": "e.g. 'ORD-90412'"},
        "coupon_code": {
            "type": "string",
            "description": "Optional. e.g. 'SAVE10'. Omit if none on the order."
        }
    },
    # coupon_code is NOT required — it may be absent.
    "required": ["order_id"]
}

Indicare i casi limite nell'esempio

Le buone descrizioni specificano i limiti di applicabilità: cosa fa lo strumento e cosa NON gestisce. Incorpori questi limiti negli esempi, così il modello riconoscerà quando un input è fuori ambito.

In questo modo si evita di instradare erroneamente gli strumenti sovrapposti, perché l'esempio chiarisce a quale strumento appartenga ogni forma di input.

lookup_order = {
    "name": "lookup_order",
    "description": (
        "Look up ONE order by its order ID. "
        "order_id format: 'ORD-' + 5 digits, e.g. 'ORD-90412'. "
        "Does NOT search by customer name or email — "
        "use search_orders for that. "
        "Returns isError (category='validation') if the ID is malformed."
    )
}

Associare gli esempi di input agli errori strutturati

Anche con ottimi esempi, alcuni input saranno non validi. Il contratto degli errori dello strumento deve essere altrettanto esplicito, affinché il modello possa recuperare.

Restituisca errori strutturati: un flag isError, oltre a errorCategory (transient / validation / business / permission), isRetryable, un messaggio e attempted_query. Un generico "Operation failed" impedisce il recupero; gli errori strutturati consentono un instradamento intelligente e un nuovo tentativo corretto.

{
  "isError": true,
  "errorCategory": "validation",
  "isRetryable": true,
  "message": "start must be ISO 8601 (YYYY-MM-DD); got '06/10/2026'.",
  "attempted_query": {"start": "06/10/2026", "end": "2026-03-31"},
  "partial_results": null
}

Esempi + nuovo tentativo con feedback

Quando l'input di uno strumento restituisce un formato non valido, utilizzi retry-with-feedback: invii al modello la richiesta originale, l'output errato e l'errore di convalida esatto. È proprio questo il tipo di problema che questa tecnica risolve.

Noti il limite: il retry è utile quando l'input è formattato in modo errato, non quando l'informazione necessaria è semplicemente assente nella fonte. Gli esempi prevengono il primo tipo di errore; nulla può inventare i dati mancanti.

messages.append({
    "role": "user",
    "content": (
        "Your tool call failed validation. "
        "start must match YYYY-MM-DD. "
        "You sent '06/10/2026'. "
        "Reissue the call with the corrected format."
    )
})
# Resend full history; the model keeps no state between turns.

Verifica rapida

Applichi la lezione a una decisione progettuale reale.

Riepilogo: renda gli input non ambigui

Punti chiave:

  • Le descrizioni degli strumenti guidano la selezione e la formattazione, quindi investa su di esse, non solo sui nomi.
  • Mostri esempi concreti di input a livello di campo e un esempio di chiamata completa nella descrizione.
  • Utilizzi gli enum (con un campo 'other' + dettaglio) per gli insiemi fissi; mostri la struttura letterale di oggetti e array.
  • Contrassegni un campo come obbligatorio solo se è sempre presente; altrimenti il modello inventa dati.
  • Supporti gli esempi con errori strutturati (errorCategory, isRetryable, attempted_query), in modo che retry-with-feedback possa correggere gli errori di formato, anche se non può fornire dati assenti.

Gli esempi concreti sono il modo più economico e incisivo per impedire chiamate agli strumenti malformate prima che si verifichino.

Gratis per iniziare

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 «Formati di input ed esempi» è gratuita?

Sì — il testo completo di «Formati di input ed esempi» è 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 «Formati di input ed esempi»?

Mostri esempi concreti di input per eliminare ogni ambiguità. 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 4 di 4.

Quanto tempo richiede la lezione «Formati di input ed esempi»?

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

  1. La selezione degli strumenti dipende dalle descrizioni
  2. Anatomia di una descrizione efficace
  3. Evitare strumenti sovrapposti
  4. Formati di input ed esempi
← Torna a Claude Architect