Latest / M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano / Azure AI Foundry Threads: come rendere la tua IA pronta per l’azienda (Doppiaggio IA)

Transcript

Azure AI Foundry Threads: come rendere la tua IA pronta per l’azienda (Doppiaggio IA) · M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano

• 0:00
  Ecco la parte sconvolgente che nessuno ti dice.
• 0:02
  Quando distribuisci un IA in Azure Foundry non stai solo avviando un modello sovradimensionato.
• 0:06
  La inserisci in un runtime gestito dove ogni azione rilevante, messaggio, chiamata strumenti e fase di esecuzione viene registrata e tracciata.
• 0:12
  Vedrai come thread, esecuzioni e passaggi formano la traccia cartacea che rende gli esperimenti verificabili e pronti per l'impresa.
• 0:17
  Questo trasforma l'IA da un elemento incontrollato a un sistema disciplinato che poi...
• 0:21
  Una volta che la struttura è in atto, la vera domanda è...
• 0:24
  Chi guida questa squadra digitale?
• 0:27
  Ti presento il caposquadra?
• 0:28
  Quando ne configuro in Foundry non stai semplicemente aprendo una finestra di chat.
• 0:31
  Stai nominando un caposquadra?
• 0:33
  Non è un tirocinante che gioca con l'autocompletamento.
• 0:35
  È un capitano da campo costruito per missioni basate su un design chiaro.
• 0:39
  E quel design si riduce a tre ingranaggi fondamentali.
• 0:41
  Il modello, le istruzioni, gli strumenti.
• 0:44
  Modello cervello.
• 0:45
  Gestisce il ragionamento e il linguaggio, la parte che può analizzare parole umane, pianificare passaggi e ridigere risposte.
• 0:51
  Le istruzioni sono gli ordini di missione.
• 0:52
  Impediscono al cervello di divagare ancorandolo ai risultati di cui hai realmente bisogno.
• 0:56
  E gli strumenti sono l'attrezzatura al suo fianco, esecuzione di codice, connettore di ricerca, API di reportistica o qualsiasi sistema di terze parti collegato.
• 1:04
  Un agente di Azure AI è costruito esplicitamente su questa triade.
• 1:07
  Senza di essa non ottieni riproducibilità o verificabilità.
• 1:10
  Ottieni solo generazioni di testo senza alcuna prova.
• 1:12
  Traduciamo tutto ciò in un esempio sul campo di battaglia.
• 1:15
  Il modello è l'addestramento e il combattimento del tuo capitano.
• 1:17
  Sa come brandire una spada o formulare una frase.
• 1:18
  Le istruzioni sono il briefing della missione, proteggere il convoglio, estrarre dati da un set di contratto, riportare i risultati in un formato specifico.
• 1:25
  Questo mantiene il capitano allineato e prevedibile.
• 1:27
  Poi gli strumenti aggiungono specializzazione.
• 1:29
  Un rampino per scalare le mure è come un interprete di codice per eseguire analisi.
• 1:33
  Una radio sicura è come un connettore SharePoint, un MCP personalizzato che alimenta il piano con dati in tempo reale.
• 1:38
  Quando questi tre elementi si uniscono la gente non sta improvvisando.
• 1:40
  Sta eseguendo una missione con log e checkpoint.
• 1:43
  Foundry rende tutto questo meccanismo pratico.
• 1:45
  Nella maggior parte delle app di chat tieni solo il modello on-prom.
• 1:48
  E una volta che inizi a parlare non c'è un senso formale di ordine e orchestrazione degli strumenti.
• 1:52
  È come lanciare il tuo capitano sul campo senza un piano o un equipaggiamento.
• 1:55
  Al contrario, il servizio agente di Foundry garantisce che tutti e tre i livelli siano presenti.
• 2:00
  Ancora meglio, non sei legato a un unico cervello.
• 2:02
  Puoi passare da un modello all'altro nel catalogo di Foundry.
• 2:05
  GPT4 per strategie complesse, magari un modello più snello per compiti leggeri o persino l'integrazione di Mistral o di Psyc.
• 2:10
  Scegli tu ciò che si adatta alla missione.
• 2:12
  Questa flessibilità è la differenza tra un tirocinante generico e un comandante capace di adattarsi.
• 2:16
  Ora, considera la posta in gioco se questi livelli mancano.
• 2:19
  Gli output diventano incoerenti.
• 2:21
  Un riassunto di contratto viene letto in un modo e il successivo lo contraddice sottilmente.
• 2:24
  Si perde la tracciabilità perché nessun log strutturato registra come si giunte alla risposta.
• 2:28
  Il debug diventa una congettura poiché gli sviluppatori non possono ripercorrere la catena di ragionamento.
• 2:32
  In un'azienda non si tratta di un fastidio minuto.
• 2:34
  È un rischio reale che blocca la fiducia e l'adozione.
• 2:37
  Found risolve questo problema in modo diretto.
• 2:38
  I guardrail sono integrati nell'agente.
• 2:40
  Le istruzioni fungono da regolamento fisso che deve essere seguito.
• 2:43
  Il set di strumenti può essere limitato rigorosamente e ampliato in base al caso d'uso.
• 2:46
  Il modello può essere sostituito liberamente, ma sempre all'interno della struttura che impone responsabilità.
• 2:52
  Insieme, questa triade fornisce un caposquadra disciplinato, output prevedibili, passaggi visibili e passaggi visibili,
• 2:57
  la capacità di estendersi in modo responsabile con connettori aziendali e personalizzati.
• 3:00
  Non si tratta di presentare l'IAC come una conversazione magica.
• 3:03
  Si tratta di mostrare che la tua organizzazione ottiene un ufficiale esperto che gestisce log,
• 3:06
  segui gli ordini e porti all'attrezzatura giusta.
• 3:09
  E come ogni buon capitano, mantieni un registro accurato di ciò che è accaduto in ogni missione.
• 3:12
  Perché quando i sistemi vengono controllati, un'esecuzione fallisce e ha bisogno del diario.
• 3:16
  In Foundry quel diario ha un nome.
• 3:17
  Si chiama Thread.
• 3:19
  I Thread, registro delle fonti di batteria.
• 3:21
  I Thread sono dove il registro di missione inizia a prendere forma.
• 3:23
  In Azure Foundry un Thread non è una finestra di chat casuale che svanisce quando la chiudi.
• 3:27
  È una sessione di conversazione per sistemi.
• 3:29
  Ogni scambio tra te e l'agente viene archiviato qui, che provenga da te e dall'agente,
• 3:33
  o persino da un altro agente in una configurazione multiagente.
• 3:36
  Questo è il registro del fronte di battaglia che mantiene una cronologia a duratura delle interazioni
• 3:39
  che può essere vista molto tempo dopo la fine della chat.
• 3:41
  Il vero punto di forza è che i Thread non sono solo trascrizioni statiche.
• 3:44
  Sono contenitori strutturati che gestiscono automaticamente il troncamento,
• 3:48
  mantenendo il contesto attivo entro i limiti del modello, pur preservando una traccia di controllo completa.
• 3:52
  Ciò significa che l'agente continua a comprendere la conversazione in corso,
• 3:56
  mentre le aziende mantengono un registro permanente e revisionabile.
• 3:58
  A differenza della maggior parte delle app di chat, non lo svanisce niente.
• 4:02
  Ottieni continuità per l'agente e governance per l'azienda.
• 4:04
  Le voci in cui il registro sono costruite dai messaggi.
• 4:06
  Un messaggio non è limitato al solo test.
• 4:08
  Può contenere un'immagine, un file di foglio di calcolo o un blocco di codice generato.
• 4:12
  Ognuno è dotato di timestamp e contrassegnato con un ruolo, utente o assistente.
• 4:16
  Quindi, quando esamini un Thread, non vedi solo cosa è stato detto,
• 4:19
  ma anche chi l'ha detto, quando e che tipo di contenuto è stato coinvolto.
• 4:23
  Immagina un responsabile della conformità che apre un registro
• 4:26
  e vede l'esatta richiesta testuale inviata ieri.
• 4:28
  Il grafico prodotto dalla gente in risposta e l'orario di entrambi gli eventi.
• 4:33
  È più di una memoria, un registro reale completo.
• 4:35
  Per dirla in termini di gioco, un Thread è come il taccuino di una campagna di Dungeons & Dragons.
• 4:38
  Il Dungeon Master annota quali città avete visitato,
• 4:41
  quali lanci di dadi sono riusciti e quale bottino è stato preso.
• 4:44
  Senza quel registro, i giocatori finiscono per litigare su dettagli dimenticati.
• 4:47
  Con esso, le discussioni svaniscono perché gli eventi sono documentati.
• 4:50
  I Thread fanno lo stesso per gli aziendali.
• 4:52
  Prevengono dispute su ciò che l'agente ha effettivamente fatto,
• 4:54
  perché tutto è catturato in ordine.
• 4:55
  Ora ecco perché quel registro è importante.
• 4:58
  Per l'audit e la conformità, i Thread sono oro puro.
• 5:00
  I regolatori o i team di audit interno possono aprirne uno e vedere immediatamente
• 5:04
  l'intera sequenza, la richiesta dell'utente, la risposta dell'agente,
• 5:06
  gli strumenti usati, gli strumenti usati, quando è successo tutto.
• 5:08
  Per gli sviluppatori, quegli stessi record funzionano come una modalità di debacle.
• 5:11
  Se un agente ha prodotto un frammento di codice errato,
• 5:13
  puoi riavvolgere il Thread fino al punto in cui è stato richiesto
• 5:15
  e vedere esattamente come ci arriva.
• 5:17
  Entrambi i gruppi ottengono visibilità, immagini, entrambi evitano di perdere te.
• 5:20
  Confronta questo con i sistemi che non memorizzano le conversazioni.
• 5:23
  Senza Thread, provi a tracciare il comportamento con screenshot o ricordi confusi.
• 5:28
  Questo non regge quando la conformità chiede prove
• 5:30
  o quando l'assistenza deve riprodurre un bug.
• 5:32
  È come doversi ripetere un boss finale in un gioco
• 5:34
  per poi rendersi conto di non aver mai salvato.
• 5:37
  Nessun registro significa nessuna prova,
• 5:38
  nessuna traccia significa nessuna correzione.
• 5:40
  In caso di fallimento, ti rimane solo da rassicurare le parti interessate con promesse verbali.
• 5:44
  Con i Thread in Foundry eviti questa trappola.
• 5:47
  Ogni conversazione diventa una prova strutturata.
• 5:49
  Se un flusso di lavoro estrae il linguaggio legale,
• 5:51
  il record mostrerà la richiesta originale, la risposta specifica generata
• 5:54
  e se sono stati richiamati strumenti di supporto.
• 5:57
  Se più agenti comunicano tra loro per dividersi i compiti,
• 5:59
  anche il loro scambio viene registrato.
• 6:02
  Le aziende possono dimostrare la conformità,
• 6:04
  gli sviluppatori possono individuare i bug,
• 6:05
  i manager possono fidarsi del fatto che ciò che esce dal sistema è responsabile.
• 6:08
  È a quel punto che i Thread trasformano chat caotiche in qualcosa pronto per la produzione.
• 6:12
  Invece di scambi effime, riproducono una cronologia stabile di missioni e decisioni.
• 6:16
  Una base su cui contare.
• 6:17
  Ma ricorda e registra ancora solo un diario.
• 6:20
  La verazione inizia quando l'agente prende ciò che è scritto nel Thread e lo esegue realmente.
• 6:24
  Questa fase successiva è quella in cui le missioni smettono di essere a punti su carta
• 6:27
  e iniziano ad essere vissute in tempo reale.
• 6:29
  Esecuzioni e passaggi di esecuzione che lanciano i dati.
• 6:31
  Esecuzioni sul momento in cui la missione finalmente inizia.
• 6:33
  In termini di Foundry, un Thread contiene lo storico della conversazione,
• 6:36
  gli ordini, il contesto, le mappe srotolate.
• 6:38
  Un'esecuzione è il trigger che attiva l'agente per prendere quel contesto e metterlo effettivamente in atto.
• 6:43
  I Thread ricordano l'esecuzione al disco.
• 6:45
  Pensa a un'esecuzione come al pulsante di là.
• 6:47
  Tuo Thread potrebbe dire analizza il file CSV o disegni un grafico a linee.
• 6:50
  Ma l'esecuzione è il momento in cui l'agente elabora quella richiesta tramite le istruzioni del modello e gli strumenti.
• 6:55
  Può cercare dati aggiuntivi, elaborare numeri o richiamare l'interprete di codice per generare un artefatto.
• 7:00
  In termini di giochi di ruolo da tavolo, un Thread è il tuo gruppo che pianifica le mosse attorno al tavolo.
• 7:05
  L'esecuzione è il tiro di iniziativa che dà inizio al combattimento.
• 7:07
  Senza di esso nulla va avanti.
• 7:09
  Ecco ciò che Foundry rende esplicito.
• 7:11
  L'esecuzione non sono una scatola nera.
• 7:12
  Sono esecuzioni monitorate e tracciate nello stato.
• 7:15
  Vedrai tipicamente stati come in coda, in corso, richiede azione, completato, fallito.
• 7:19
  Gli esempi SDK spesso interrogano questi stati in un ciclo, proprio come un game master controlla l'ordine dei turni.
• 7:24
  Questo ti offre visibilità non solo su ciò che viene fatto, ma anche su quando sta accadendo.
• 7:28
  Ecco la preoccupazione maggiore.
• 7:30
  Come fai a sapere cosa è successo davvero all'interno di quell'esecuzione?
• 7:33
  Forse la risposta sembra corretta, ma senza dettagli non puoi sapere se l'agente ha contattato una P esterna,
• 7:37
  ha scritto codice o solo improvvisato del testo.
• 7:39
  Quell'opacità è pericolosa in contesti aziendali.
• 7:42
  È l'equivalente di entrare in una partita a scacchi, vedere una scacchiare a metà gioco e sentirsi dire
• 7:45
  fidati sono state fatte le mosse giuste.
• 7:47
  Non puoi ricciocarla.
• 7:48
  Non sai se la giocata fosse regolare.
• 7:50
  I passaggi di esecuzione sono ciò che linea queste conoscenze.
• 7:52
  Ogni esecuzione viene registrata passo dopo passo.
• 7:54
  Quali output del modello sono stati generati, quali strumenti invocati, quali calcoli eseguiti, quali messaggi prodotti.
• 7:59
  È una notazione scacchistica per l'IA, pedone in E4, cavallo in F6.
• 8:03
  Solo che qui recupero file alle 10.02.
• 8:05
  Esecuzione blocco codice alle 10.03.
• 8:07
  Restituzione grafica alle 10.04.
• 8:10
  Ogni azione viene scritta in ordine così da poterla riprodurre in seguito.
• 8:12
  Questa struttura ha un enorme sollievo per il sviluppatore.
• 8:15
  Senza i passaggi di esecuzione, fissa una risposta finale senza alcuna idea di come sia nata.
• 8:18
  La query di cercare è sbagliata.
• 8:20
  Si è infiltrato un errore matematico.
• 8:21
  Te costruendovi in A, con i passaggi di esecuzione puoi scorrere la timeline, identificare l'esatto errore e correggerlo.
• 8:27
  Il debug smette di essere una congettura e diventa un'attività forense.
• 8:30
  È la differenza tra uno scontro confuso in cui non capisci chi è attaccato,
• 8:33
  è un luogo di combattimento che mostra ogni colpo di spada e incantesimo.
• 8:37
  Anche i team di conformità ne tragono vantaggio.
• 8:39
  Quando i revisori chiedono come è stato generato questo riepilogo esattamente,
• 8:42
  non devi descrivere il ragionamento del modello in termini astratti.
• 8:44
  È le prove in ma.
• 8:45
  La chiamata allo strumento, il passaggio dell'interprete, la risposta composta, tutto con marcatura temporale.
• 8:50
  Questo trasforma le spiegazioni in governance.
• 8:52
  Mostri prove concrete invece di inventare storie.
• 8:54
  E le aziende lo adorano perché trasforma il rischio in responsabilità, offrendo prove anziché promesse.
• 8:59
  E per le operazioni quotidiane, i passaggi di esecuzione creano pattern riproducibili su cui puoi contare.
• 9:03
  Se un flusso di lavoro deve essere rieseguito, puoi seguire la stessa sequenza.
• 9:06
  Se un risultato viene contestato, puoi riprodurlo.
• 9:08
  Con un risultato ottimale, le esecuzioni con passaggi completi offrono prove verificabili e riproducibili di come sono stati creati gli output.
• 9:14
  Con un risultato pessimo in altri sistemi, otterresti solo un output errato senza alcuna traccia.
• 9:17
  Ecco perché questa parte del ciclo di vita dell'agente è importante.
• 9:20
  Hai il diario nei thread, l'attivazione, l'esecuzione, il log passo dopo passo nei passaggi di esecuzione.
• 9:25
  Insieme trasformano un'IA improvvisata in un collaboratore responsabile le cui azioni puoi tracciare, testare e difendere.
• 9:30
  Naturalmente sapere che tutti questi dettagli esistono è solo una parte del puzzle.
• 9:33
  Avrei bisogno di un modo per interagire con tutto ciò, qualcosa di strutturato per avviare agenti, attivare esecuzioni, leggere i passaggi senza negare in chiamata e picrezza.
• 9:40
  E la parte sorprendente è che non serve una plancia di comando scintillante per farlo.
• 9:44
  La console che usano quasi tutti è qualcosa di familiare, solido, un po' meno appariscente, rete, arsenale e alleanze.
• 9:50
  Arsenale e alleanze sono ciò che trasformano agente da chiacchierone a lavoratore.
• 9:54
  In Azure Foundry quell'arsenale si presenta sotto forma di strumenti e estensioni pratiche che permettono alla gente di passare dalle parole fatti.
• 10:00
  Invece di descrivere semplicemente come controllare un documento o eseguire un calcolo, la gente può farlo davvero e restituire l'output.
• 10:07
  Questa distinzione è ciò che rende la piattaforma preziosa in un'azienda reale anziché solo impressionante in una demo.
• 10:12
  Foundry ti offre tre chiare categorie di funzionalità.
• 10:14
  Le prime sono gli strumenti integrati.
• 10:16
  Questi includono l'interprete di codice, Bing Search, i connettori SharePoint e Microsoft Fabric e Azure AI Search.
• 10:22
  Con questi in gioco la gente può analizzare dati, estrarre file, cercare contenuti aziendali e persino creare grafici o report senza codice personalizzato.
• 10:28
  Ognuno espande il raggio d'azione e dà risposte discorsive a prodotti di lavoro tangibili che puoi ispezionare e riutilizzare.
• 10:34
  In secondo luogo non sei vincolato solo a ciò che Microsoft rilascia.
• 10:37
  Foundry ti permette di registrare strumenti personalizzati tramite specifiche OpenAPI o Modern Context Protocol MCP.
• 10:42
  L'MCP è particolarmente importante perché è trattato come l'USB-C per gli strumenti di A.
• 10:46
  Invece di scrivere manualmente dei wrapper ogni volta che colleghi gli agenti a server MCP remoti, il sistema gestisce automaticamente l'individuazione, il controllo delle versioni, il controllo delle versioni e l'invocazione degli strumenti.
• 10:55
  Ciò riduce notevolmente il carico di integrazione, specialmente quando il tuo ambiente ha dozzine di sistemi da collegare.
• 11:01
  Terzo, ogni chiamata ha uno strumento in Foundry osservabile.
• 11:03
  Le chiamate sono registrate a livello di passaggio con identità, input, output e timestamp.
• 11:08
  Ciò significa che la visione operativa di questi agenti non è una magia basata sulla fiducia.
• 11:10
  È un registro. Puoi osservare esattamente cosa è stato richiamato, confermare che abbia seguito le autorizzazioni corrette e conservare record permanenti per la conformità.
• 11:17
  Per ancorare queste categorie, immagina la demo di Avio.
• 11:19
  Carichi un file CSV con un messaggio in una conversazione?
• 11:22
  L'agente chiama lo strumento interprete di codice nei suoi passaggi di esecuzione, elabora il file e gira un grafico.
• 11:26
  Quell'artefatto ritorna come immagine allegata, visibile, direttamente nel registro della conversazione.
• 11:30
  Non hai scritto tu stesso un parser o una visualizzazione?
• 11:33
  Hai dato un'istruzione?
• 11:34
  L'agente ha selezionato lo strumento, eseguito e restituito il file che poteva inserire in un report.
• 11:38
  Questa non è teoria, è un comportamento documentato negli esempi dell'SDK, dove questo si apre davvero a un'integrazione aziendale.
• 11:45
  Gli strumenti possono collegarsi alle app logiche, il che significa che l'agente può accedere a oltre 1.400 connettori SAS a on-premise esistenti.
• 11:51
  Invece di ricodificare gli adattatori per piattaforme CRM, ERP o ITSM, configura i connettori che l'azienda utilizza già, che l'azienda utilizza già, nella strategia di scala via.
• 11:59
  Un singolo agente può operare in modo sicuro su un ampio panorama senza che tu debba scrivere fragili ponti API.
• 12:04
  La domanda che tutti pongono subito dopo è la sicurezza.
• 12:06
  Fa un drill a fronte alla base.
• 12:08
  Quando gli strumenti si collegano a sistemi aziendali come SharePoint o Fabric, lo fanno utilizzando un'autenticazione per conto di, mediata da Microsoft Entra.
• 12:16
  Se ieri non avevi l'autorizzazione per leggere un file, l'agente non supererà magicamente quel muro oggi.
• 12:20
  L'identità e le autorizzazioni rimangono intatte, che è l'unico modo in cui i team di conformità danno la loro approvazione.
• 12:25
  Ogni chiamata è anche tracciare.
• 12:26
  Chi l'ha richiamato?
• 12:27
  Cosa è stato inviato?
• 12:28
  Cosa è stato ricevuto?
• 12:28
  I team hanno sempre ricevuto.
• 12:30
  Con un risultato perfetto, questo intero kit di strumenti rende la tua squadra di agenti più di una semplice novità.
• 12:34
  Ottieni unità che possono interrogare dati reali, elaborarli e agire entro i limiti già noti all'AT.
• 12:39
  Con un risultato pessimo senza queste opzioni, ti ritrovi con una sessione di chat che fa grandi promesse ma non svolge mai lavoro.
• 12:44
  Ecco perché l'arsenale conta tanto capo squadra.
• 12:46
  Il modello e le istruzioni definiscono il pensiero dell'agente, ma senza strumenti connessi in modo responsabile, registrati affidabilmente e registrati affidabilmente restano una mezza misura.
• 12:53
  Grazie al set integrato di Foundry, MCP, l'estensibilità delle API aperte e la sicurezza di livello enterprise, hai le basi per una forza disciplinata, non semplici tentativi.
• 13:02
  E questo ci porta ad una visionizia.
• 13:04
  Gli agenti in Foundry non sono costruiti per essere aiutanti casuali o giocati.
• 13:07
  Sono progettati come operatori governati, strutturati, con carichi monitorati e dotazioni che li rendono utili in produzione.
• 13:13
  Ecco dove si conclude la campagna.
• 13:14
  E' tempo di trarre le conclusioni.
• 13:16
  Foundry non si limita a lanciare prompt a un modello.
• 13:18
  Ti offre un metodo ripetibile per creare agenti dotati di cervello, regolamento e toolkit.
• 13:22
  Ogni loro azione viene registrata in thread, esecuzioni e passaggi di esecuzione.
• 13:26
  Per i responsabili dello sviluppo e per chi si occupa di conformità il concetto è sempre.
• 13:29
  Un'esecuzione riproducibile e verificabile con SDK come net che ti offre controllo e visibilità sull'intero ciclo di vita.
• 13:36
  Il tuo prossimo passo avvia un progetto di test, crea un agente base, esegui un thread e controlla i passaggi nell'SDK o nel portale.
• 13:42
  E' così che confermi che i tuoi log corrispondono al...
• 13:44
  Se questo ti ha aiutato a fare centro nei tuoi deploy, iscriviti e attiva gli avvisi e avvisi.
• 13:49
  Oppure se abbiamo domato un altro cluster, iscriviti per mantenere la tua flotta in formazione.