Progettare agenti di intelligenza artificiale con GitHub Copilot SDK

  • 7 minuti

Sono state esaminate le operazioni che gli agenti di intelligenza artificiale possono eseguire. Si consideri ora come progettare il sistema che li rende funzionanti. Indipendentemente dallo scenario specifico, gli agenti di intelligenza artificiale condividono un progetto architetturale comune. Questa unità illustra i componenti fondamentali, ovvero il modello di intelligenza artificiale, gli strumenti, la pianificazione, la memoria e le protezioni, necessari per ogni sistema agente. La comprensione di questo progetto consente di implementare gli agenti in modo più efficace quando si usa GitHub Copilot SDK.

Componenti di base di un sistema agente di intelligenza artificiale

Ogni agente di intelligenza artificiale, indipendentemente dal fatto che gestisca il supporto clienti o monitori l'infrastruttura IT, venga creato dallo stesso set di blocchi predefiniti dell'architettura.

Motore di ragionamento dell'intelligenza artificiale

Al centro dell'agente è un modello linguistico di grandi dimensioni (LLM), ad esempio GPT-5, che interpreta le istruzioni e genera risposte. Questo LLM è il componente che "ragiona" e decide cosa fare successivamente ad ogni passo. Il training generale dell'LLM gli fornisce la comprensione del linguaggio e la conoscenza generale, mentre il framework dell'agente gli offre la possibilità di intervenire su tale ragionamento.

In GitHub Copilot SDK si seleziona il modello quando si configura una sessione. I diversi modelli offrono compromessi diversi tra velocità, costi e capacità di ragionamento e l'SDK supporta il cambio di modelli tra sessioni.

Tools

Gli strumenti sono funzioni esterne o API che l'agente può richiamare durante il processo di ragionamento. Ogni strumento rappresenta un'azione specifica che l'agente può eseguire, cercando un record di database, chiamando un'API REST, inviando un messaggio di posta elettronica o eseguendo un comando di diagnostica. Gli strumenti sono il modo in cui l'agente si sposta oltre la generazione di testo e interagisce effettivamente con i sistemi reali.

La progettazione del set corretto di strumenti è una decisione critica. Vuoi dare all'agente strumenti sufficienti per essere utile, ma non così tanti che l'agente diventi confuso o sovraccarico. Ogni strumento deve eseguire correttamente un'operazione, con un nome e una descrizione chiari che consentono al modello di intelligenza artificiale di comprendere quando usarlo.

Pianificatore e controllore

Il pianificatore orchestra il ragionamento e l'uso degli strumenti da parte dell'agente. Decide quando richiamare uno strumento, quando porre una domanda di chiarimento e quando produrre una risposta finale. Gli agenti di intelligenza artificiale moderni usano tecniche come il ciclo ReAct (Reason + Act), in cui l'agente alterna il pensiero (l'LLM propone un passaggio) e agisce (chiamando uno strumento).

GitHub Copilot SDK offre questo planner come funzionalità predefinita. Il ciclo dell'agente dell'SDK gestisce l'orchestrazione: si configurano i componenti e l'SDK gestisce il ciclo di esecuzione del piano, dell'azione, dell'osservazione e della ripetizione.

Memoria e contesto

A differenza di una chiamata API senza stato, gli agenti mantengono la memoria contestuale in una sessione. La consapevolezza dell'agente include la cronologia delle conversazioni, gli output degli strumenti e tutti i dati recuperati durante i passaggi precedenti. La memoria è ciò che consente coerenza: quando un utente dice "in realtà, è stato il colore sbagliato", l'agente sa che "esso" fa riferimento all'elemento descritto in precedenza.

GitHub Copilot SDK gestisce automaticamente la memoria a breve termine monitorando la cronologia delle conversazioni all'interno di una sessione. Per le sessioni che potrebbero superare la finestra di contesto del modello, la funzionalità delle sessioni infinite dell'SDK compatta il contesto precedente per impedire l'overflow del token mantenendo al tempo stesso informazioni essenziali.

Criteri e misure di protezione

Poiché gli agenti di intelligenza artificiale esegono azioni autonome, è necessario vincoli per assicurarsi che funzionino in modo sicuro e come previsto. I guardrail rientrano in diverse categorie:

  • Limiti di ambito: definire le operazioni che l'agente può e non può eseguire. Ad esempio, consentire all'agente di elaborare i resi, ma richiedere l'approvazione umana per i rimborsi al di sopra di un importo specifico.
  • Controlli di autorizzazione: usare l'hook dell'SDK per intercettare le chiamate degli strumenti prima dell'esecuzione OnPreToolUse . L'hook restituisce un PermissionDecision valore (Allow, Denyo Ask) che controlla se l'azione procede, è bloccata o richiede la conferma dell'utente.
  • Filtri di sicurezza: indicare all'agente (tramite il prompt di sistema) di rimanere all'interno del dominio ed evitare di rivelare informazioni interne.
  • Fallback ed escalation: progettare cosa succede quando l'agente non riesce a risolvere una richiesta. Questa misura di protezione solitamente implica la trasmissione a un operatore umano con il contesto raccolto dall'agente.

In GitHub Copilot SDK, le protezioni provengono da tre origini: gli strumenti esposti (che limitano intrinsecamente le operazioni che l'agente può fare), il prompt di sistema (che guida il comportamento) e i controlli a livello di codice nei gestori degli strumenti e negli hook di sessione.

Il flusso di lavoro dell'agente in pratica

Quando un agente riceve una richiesta, segue un flusso di lavoro iterativo:

  1. Ricevere input: l'utente invia un messaggio o un evento attiva l'agente.
  2. Motivo e piano: LLM interpreta l'input, identifica l'obiettivo e decide l'azione da intraprendere per prima.
  3. Act: l'agente chiama uno strumento (ad esempio, cercando un ordine nel database).
  4. Osservare: lo strumento restituisce un risultato e l'agente valuta se contiene informazioni sufficienti per rispondere.
  5. Eseguire l'iterazione o rispondere: se sono necessarie altre informazioni o azioni, l'agente torna alla fase 2. Una volta raggiunto l'obiettivo, produce una risposta finale.

Questo ciclo può essere ripetuto più volte all'interno di una singola richiesta utente. GitHub Copilot SDK gestisce automaticamente questo ciclo tramite il motore di esecuzione dell'agente.

Procedura dettagliata di esempio

Pensa a come un addetto ai resi dell'e-commerce gestisce una richiesta.

  1. Input utente: "Ho ricevuto l'articolo sbagliato, ordine 12345. Voglio restituirlo".
  2. Piano: l'agente identifica due obiettivi: verificare l'ordine e avviare un ritorno.
  3. Chiamata allo strumento: l'agente chiama get_order_details(12345) per recuperare le informazioni sull'ordine.
  4. Osserva: lo strumento restituisce i dettagli dell'ordine, confermando l'articolo e la data di consegna.
  5. Chiamata allo strumento: l'agente chiama process_return(12345) per creare una richiesta di reso.
  6. Osserva: lo strumento restituisce un numero di conferma.
  7. Rispondi: l'agente indica all'utente: "Ho creato RMA-1001 per Order 12345 e ho pianificato un ritiro per domani. Riceverai il rimborso in 3-5 giorni lavorativi."

L'agente ha usato due strumenti e ha ragionato attraverso più passaggi, ma dal punto di vista dell'utente è stata un'unica interazione senza problemi.

Decisioni di progettazione per GitHub Copilot SDK

Quando si progetta un agente per la compilazione con GitHub Copilot SDK, concentrarsi su tre aree:

  • Contesto: quali informazioni sono necessarie all'agente all'inizio di ogni sessione? Il contesto include in genere un prompt di sistema che definisce le linee guida relative al ruolo e al comportamento dell'agente, oltre a tutti i dati specifici dell'utente che consentono risposte personalizzate.
  • Strumenti: quali azioni devono essere eseguite dall'agente? Definire ogni strumento con un nome, una descrizione e uno schema dei parametri chiari. Implementare la logica di business nel gestore degli strumenti.
  • Criteri: quali regole devono essere seguite dall'agente? Codificare i criteri come istruzioni di richiesta di sistema, convalide del gestore degli strumenti o logica hook di sessione.

Occorre anche pianificare le modalità di errore. Se una chiamata allo strumento ha esito negativo, l'agente dovrebbe riprovare, provare un approccio alternativo o procedere con l'escalation? Queste decisioni possono essere codificate nel prompt di sistema ("se uno strumento restituisce un errore, informare l'utente e offrire alternative") o gestite a livello di codice negli hook di gestione degli errori.

Riassunto

La progettazione di un agente di intelligenza artificiale comporta la definizione delle sue funzionalità di ragionamento, gli strumenti che può usare, il modo in cui gestisce il contesto e le protezioni che garantiscono un funzionamento sicuro. GitHub Copilot SDK offre un framework potente per la creazione di agenti con questi componenti. Progettando attentamente la richiesta di sistema, selezionando gli strumenti appropriati e implementando i criteri, è possibile creare agenti che offrono valore aziendale reale mentre operano entro i limiti definiti. Nell'unità successiva si vedrà come applicare questi principi di progettazione in pratica creando un agente di esempio con GitHub Copilot SDK.