Mappature tra affermazioni e fonti
Conservi URL, nomi dei documenti, citazioni e date insieme alle affermazioni.
Mappature tra affermazioni e fonti è una lezione Claude Architect gratuita su CoddyKit. Questa è la lezione 1 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é la provenienza è importante
In un sistema di ricerca multi-agente, il coordinatore aggrega i risultati dei subagenti, ciascuno dei quali ha ricavato fatti da documenti diversi. La risposta aggregata è affidabile solo se ogni affermazione può essere ricondotta alla sua origine.
Una mappatura tra affermazione e fonte collega ogni dichiarazione fattuale alla propria origine: l'URL, il nome del documento, la citazione esatta e la data di pubblicazione. Senza questo collegamento, si dispone di un'affermazione che nessun revisore umano può verificare e nessun agente a valle può sottoporre ad audit.
Per l'esame Architect, la provenienza rientra nel Domain 4 (Prompt Engineering & Structured Output) e ricorre nello Scenario 3 (Multi-Agent Research) e nello Scenario 6 (Structured Data Extraction).
I quattro elementi di ancoraggio di una fonte
Una mappatura della fonte dovrebbe sempre contenere quattro elementi di ancoraggio, così che una persona o un altro agente possano ritrovare e verificare nuovamente le prove:
- URL — dove si trova il documento (oppure un identificatore stabile).
- Nome del documento — un titolo comprensibile per una persona.
- Citazione — il testo parola per parola che supporta l'affermazione, non una parafrasi.
- Data di pubblicazione — quando la fonte è stata pubblicata o aggiornata l'ultima volta.
La citazione parola per parola consente al revisore di verificare che il modello non abbia inventato informazioni o esagerato il contenuto. La data consente di risolvere successivamente eventuali conflitti, come vedremo.
Modellare la mappatura come output strutturato
Non chieda al modello di inserire le citazioni nel testo discorsivo, dove è facile ometterle. Imponga invece una struttura definita con un JSON Schema tramite uno strumento. L'associazione di tool_use a uno schema elimina gli errori di sintassi e garantisce la presenza dei campi obbligatori.
Ogni affermazione diventa un oggetto che contiene i propri elementi di ancoraggio della fonte. Questa è la base di un record di provenienza verificabile.
extract_claims = {
"name": "record_claims",
"description": "Record each factual claim with its full source provenance.",
"input_schema": {
"type": "object",
"properties": {
"claims": {
"type": "array",
"items": {
"type": "object",
"properties": {
"claim": {"type": "string"},
"source_url": {"type": "string"},
"document_name": {"type": "string"},
"quote": {"type": "string"},
"publication_date": {"type": "string"}
},
"required": ["claim", "quote", "document_name"]
}
}
},
"required": ["claims"]
}
}Campi obbligatori: solo quelli sempre presenti
Una regola sottile ma fondamentale per l'esame: contrassegni un campo come obbligatorio solo se è sempre presente nella fonte. Se rende obbligatorio un campo che potrebbe mancare, il modello inventa un valore per soddisfare lo schema.
Un post di un blog potrebbe non avere una publication_date formale; un PDF interno potrebbe non avere un source_url. Pertanto claim, quote e document_name sono obbligatori (sono sempre disponibili), mentre source_url e publication_date restano facoltativi. Una data vuota è onesta; una data inventata è un errore di provenienza.
Forzare l'output strutturato con tool_choice
Per garantire di ricevere l'oggetto di provenienza invece di testo discorsivo libero, vincoli il modello con tool_choice. Impostando {"type": "tool", "name": "record_claims"} si forza l'uso di quello specifico strumento, così ogni risposta arriva come JSON convalidato dallo schema.
Usare "any" garantirebbe che venga chiamato un qualsiasi strumento; forzare lo strumento indicato per nome offre la garanzia più stringente quando si dispone di un solo strumento di estrazione.
resp = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
tools=[extract_claims],
tool_choice={"type": "tool", "name": "record_claims"},
messages=[{
"role": "user",
"content": (
"Extract every factual claim from the document below. "
"For each, attach the verbatim quote, document name, "
"and the source URL and publication date if present.\n\n"
f"<document>{source_text}</document>"
),
}],
)Le citazioni parola per parola riducono le allucinazioni
Richiedere una citazione parola per parola (non una parafrasi) è un fattore di affidabilità, non solo un adempimento documentale. Quando il modello deve copiare il testo esatto che fornisce il supporto, diventa molto più difficile affermare qualcosa che la fonte non ha mai detto.
Rafforzi questo requisito con criteri espliciti nel prompt e con 2-4 esempi few-shot. Gli esempi few-shot sono particolarmente efficaci per il formato dell'output, i casi limite e la riduzione delle allucinazioni: il modello generalizza lo schema invece di limitarsi a ripetere gli esempi forniti.
PROMPT = (
"Rules:\n"
"- 'quote' MUST be copied verbatim from the document. Never paraphrase.\n"
"- If a claim has no exact supporting sentence, DO NOT emit it.\n"
"- Leave 'publication_date' empty if the document states no date.\n\n"
"Example:\n"
"claim: 'Revenue grew 12% in Q3.'\n"
"quote: 'Third-quarter revenue rose 12% year over year.'\n"
"document_name: 'FY24 Q3 Earnings Release'\n"
)Trasferire la provenienza tra i subagenti
In un sistema di ricerca hub-and-spoke, i subagenti non ereditano la cronologia della conversazione del coordinatore. Ogni subagente deve restituire i propri risultati insieme alle mappature delle fonti, perché il coordinatore non ha altro modo per sapere da dove provenga un fatto.
Il coordinatore aggrega quindi questi oggetti di affermazione autonomi. Se un subagente restituisce una frase isolata senza citazione o nome del documento, quel fatto diventa non verificabile nel momento in cui esce dal contesto del subagente: lo consideri privo di provenienza, non un risultato valido.
# Each subagent returns claim objects, not loose prose.
subagent_result = {
"agent": "market-research",
"claims": [
{
"claim": "EV sales reached 14M units in 2023.",
"quote": "Global EV sales hit 14 million units in 2023.",
"document_name": "IEA Global EV Outlook 2024",
"source_url": "https://iea.org/evo-2024",
"publication_date": "2024-04-23",
}
],
}
# Coordinator aggregates self-contained, traceable claims.
aggregated.extend(subagent_result["claims"])Annotare i conflitti, non scegliere arbitrariamente
Quando due fonti non concordano su una statistica, la scelta sbagliata è selezionarne una in silenzio. La scelta corretta è annotare il conflitto e presentare entrambe le affermazioni con le rispettive fonti.
Spesso la data di pubblicazione risolve l'apparente contraddizione: un dato del 2021 e uno del 2024 non sono contraddittori, ma costituiscono una serie temporale. È proprio per questo che l'elemento data merita di comparire in ogni mappatura. Conservi entrambi i dati, li etichetti e lasci che sia una persona (o una regola consapevole della data) a decidere.
conflict = {
"metric": "global_ev_sales_units",
"values": [
{"value": "6.6M", "document_name": "IEA EV Outlook 2022",
"publication_date": "2022-05-23"},
{"value": "14M", "document_name": "IEA EV Outlook 2024",
"publication_date": "2024-04-23"},
],
"note": "Not contradictory: different reporting years. Dates resolve it.",
}Rilevare le fonti mancanti tramite autocorrezione
L'autocorrezione funziona estraendo due valori che è possibile confrontare. Per la provenienza, chieda al modello di produrre ogni affermazione insieme a un indicatore che specifichi se è stata effettivamente trovata una citazione di supporto, quindi convalidi programmaticamente che ogni affermazione ne contenga una.
Questo rileva il fallimento silenzioso in cui una frase sicura di sé viene fornita senza alcuna prova a sostegno. In questo caso la convalida è strutturale, quindi perfetta per un ciclo di retry.
def validate_provenance(claims):
problems = []
for c in claims:
if not c.get("quote", "").strip():
problems.append(f"No quote: {c['claim']!r}")
if not c.get("document_name"):
problems.append(f"No document_name: {c['claim']!r}")
return problems # empty list == provenance completeRitentare con feedback, conoscendone però i limiti
Se la convalida rileva una lacuna strutturale (citazione mancante, data malformata), utilizzi il retry-with-feedback: invii al modello il documento originale, il suo output errato e l'errore di convalida esatto. Questo corregge in modo affidabile gli errori di formato e di struttura.
Limite fondamentale: il retry non aiuta quando l'informazione è semplicemente assente dalla fonte. Se il documento non contiene realmente alcuna data di pubblicazione, nessun numero di retry potrà farla comparire e non deve consentirlo. Lasci il campo vuoto e proceda, invece di entrare in un ciclo infinito.
problems = validate_provenance(claims)
if problems:
retry = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
tools=[extract_claims],
tool_choice={"type": "tool", "name": "record_claims"},
messages=[
{"role": "user", "content": f"<document>{source_text}</document>"},
{"role": "assistant", "content": prior_output},
{"role": "user", "content":
"These claims lack a verbatim quote or document_name: "
+ "; ".join(problems)
+ ". Add the exact supporting quote, or DROP the claim "
"if no supporting text exists. Do not invent sources."},
],
)Visualizzare la provenienza in base al tipo di contenuto
Una volta mappate le affermazioni, le presenti nel formato più adatto al contenuto. Visualizzi i dati finanziari come tabelle, le notizie come testo discorsivo e i risultati tecnici come elenchi, mostrando in ogni caso i relativi elementi di ancoraggio della fonte.
Per la supervisione umana, una nota a piè di pagina o una colonna finale contenente il nome del documento, la data e un link rende la verifica immediata anziché trasformarla in un'indagine. Una provenienza che non si vede è una provenienza che nessuno controllerà.
| Metric | Value | Source | Date |
|---------------|-------|---------------------------|------------|
| EV sales 2023 | 14M | IEA Global EV Outlook 2024| 2024-04-23 |
| EV sales 2022 | 6.6M | IEA Global EV Outlook 2022| 2022-05-23 |
<!-- Financials -> table. News -> prose. Tech findings -> list. -->Verifica rapida: statistiche in conflitto
Un sistema di ricerca multi-agente aggrega un dato sulle dimensioni del mercato riportato in modo diverso da due subagenti: una fonte primaria indica "$4.2B (report dated 2021)" e un'altra "$7.1B (report dated 2024)". Il coordinatore deve produrre una risposta verificabile per un revisore umano.
Riepilogo: mappature tra affermazioni e fonti
Punti chiave per l'esame e per i sistemi in produzione:
- Colleghi ogni affermazione a quattro elementi di ancoraggio: URL, nome del documento, citazione parola per parola, data di pubblicazione.
- Imponga la struttura con tool_use + JSON Schema e la renda obbligatoria tramite
tool_choice. - Contrassegni un campo come obbligatorio solo se è sempre presente: non renda mai obbligatorio un campo che potrebbe mancare, altrimenti il modello lo inventerà.
- I subagenti non ereditano la cronologia, quindi ciascuno deve restituire affermazioni autonome e tracciabili.
- Annoti i conflitti; lasci che siano le date a risolvere le apparenti contraddizioni, invece di scegliere arbitrariamente.
- Utilizzi il retry-with-feedback per le lacune strutturali, ma accetti che il retry non possa fornire informazioni assenti dalla fonte.
- Visualizzi i contenuti in base al tipo (tabelle/testo discorsivo/elenchi), con le fonti visibili per la supervisione umana.
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 «Mappature tra affermazioni e fonti» è gratuita?
Sì — il testo completo di «Mappature tra affermazioni e fonti» è 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 «Mappature tra affermazioni e fonti»?
Conservi URL, nomi dei documenti, citazioni e date insieme alle affermazioni. 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 1 di 4.
Quanto tempo richiede la lezione «Mappature tra affermazioni e fonti»?
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
- Mappature tra affermazioni e fonti
- Dati e date in conflitto
- Le metriche aggregate nascondono gli errori
- Campionamento stratificato e calibrazione