Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di gruppi di operazioni per definire le azioni che l’agente deve eseguire
Un gruppo di operazioni definisce le azioni la cui esecuzione può essere semplificata dall’agente. Ad esempio, puoi definire un gruppo di operazioni chiamato `BookHotel` che aiuta gli utenti a eseguire azioni che è possibile definire come:
+ `CreateBooking`: aiuta gli utenti a prenotare un hotel.
+ `GetBooking`: aiuta gli utenti a ottenere informazioni sull’hotel che hanno prenotato.
+ `CancelBooking`: aiuta a cancellare una prenotazione.
Crea un gruppo di operazioni attenendoti alla seguente procedura:
1. Definisci i parametri e le informazioni che l’agente deve ottenere dall’utente per ogni azione inclusa nel gruppo di operazioni da eseguire.
1. Stabilisci come l’agente gestisce i parametri e le informazioni che riceve dall’utente e dove invia le informazioni che ha richiesto.
Per scoprire di più sui componenti di un gruppo di operazioni e su come crearne uno dopo averlo configurato, seleziona uno dei seguenti argomenti:
**Topics**
+ [Definizione delle azioni nel gruppo di azioni](action-define.md)
+ [Gestione dell’adempimento dell’azione](action-handle.md)
+ [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md)
+ [Visualizzazione di informazioni su un gruppo di operazioni](agents-action-view.md)
+ [Modifica di un gruppo di operazioni](agents-action-edit.md)
+ [Eliminazione di un gruppo di operazioni](agents-action-delete.md)
# Definizione delle azioni nel gruppo di azioni
Puoi definire gruppi di azioni in uno dei seguenti modi (puoi utilizzare metodi diversi per gruppi di azioni diversi):
+ [Imposta uno schema OpenAPI](agents-api-schema.md) con descrizioni, struttura e parametri che definiscono ogni azione nel gruppo di azioni come un’operazione API. Con questa opzione, puoi definire le azioni in modo più esplicito e mapparle alle operazioni API del sistema. Puoi aggiungere lo schema API al gruppo di azioni in uno dei seguenti modi:
+ Carica lo schema creato in un bucket Amazon Simple Storage Service (Amazon S3).
+ Scrivi lo schema nell’editor di schema OpenAPI in linea nella Console di gestione AWS quando aggiungi il gruppo di azioni. Questa opzione è disponibile solo dopo che l’agente a cui appartiene il gruppo di azioni è già stato creato.
+ [Imposta i dettagli della funzione](agents-action-function.md) con i parametri che l’agente deve richiedere all’utente. Con questa opzione puoi semplificare il processo di creazione dei gruppi di azioni e configurare l’agente in modo che solleciti una serie di parametri definiti dall’utente. Puoi quindi passare i parametri all’applicazione e personalizzare il modo in cui utilizzarli per eseguire l’azione nei tuoi sistemi.
Continuando con l’esempio precedente, puoi definire l’azione `CreateBooking` in uno dei seguenti modi:
+ Utilizzando uno schema API, `CreateBooking` potrebbe essere un’operazione API con un corpo di richiesta che include campi come `HotelName`, `LengthOfStay` e `UserEmail` e un corpo di risposta che restituisce `BookingId`.
+ Utilizzando i dettagli della funzione, `CreateBooking` potrebbe essere una funzione definita con parametri come `HotelName`, `LengthOfStay` e `UserEmail`. Dopo che il tuo agente ha sollecitato i valori di questi parametri, puoi trasmetterli ai sistemi.
Quando l’agente interagisce con l’utente, determinerà quale azione all’interno di un gruppo di azioni deve invocare. L’agente solleciterà quindi i parametri e le altre informazioni necessarie per completare la richiesta API o che sono contrassegnate come *obbligatorie* per la funzione.
Seleziona un argomento per scoprire come definire un gruppo di azioni con metodi diversi.
**Topics**
+ [Definizione dei dettagli della funzione per i gruppi di operazioni dell’agente in Amazon Bedrock](agents-action-function.md)
+ [Definire schemi OpenAPI per i gruppi di operazioni dell’agente in Amazon Bedrock](agents-api-schema.md)
# Definizione dei dettagli della funzione per i gruppi di operazioni dell’agente in Amazon Bedrock
Quando crei un gruppo di operazioni in Amazon Bedrock, devi definire i dettagli della funzione per specificare i parametri che l’agente deve invocare dall’utente. I dettagli della funzione consistono in un elenco di parametri definiti in base al nome, al tipo di dati (per un elenco dei tipi di dati supportati, consulta [ParameterDetail](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ParameterDetail.html)) e all’eventuale obbligatorietà. L’agente utilizza queste configurazioni per stabilire quali informazioni deve ottenere dall’utente.
Ad esempio, è possibile definire una funzione chiamata **BookHotel** contenente i parametri che l’agente deve invocare dall’utente per prenotare un hotel per suo conto. È possibile definire i seguenti parametri della funzione:
****
| Parametro | Descrizione | Tipo | Richiesto |
| --- | --- | --- | --- |
| HotelName | Nome dell’hotel | stringa | Sì |
| CheckinDate | Data di check-in | stringa | Sì |
| NumberOfNights | Numero di notti di soggiorno | numero intero | No |
| Email | Un indirizzo e-mail per contattare l’utente | stringa | Sì |
| AllowMarketingEmails | Se consentire l’invio di e-mail promozionali all’utente | booleano | Sì |
La definizione di questo set di parametri aiuta l’agente a stabilire che deve richiedere almeno il nome dell’hotel che l’utente desidera prenotare, la data di check-in, l’indirizzo e-mail dell’utente e se desidera consentire l’invio di e-mail promozionali al suo indirizzo e-mail.
Se l’utente dichiara **"I want to book Hotel X for tomorrow"**, l’agente può determinare i parametri `HotelName` e `CheckinDate`, passando successivamente ai parametri rimanenti ponendo domande come:
+ “Qual è il tuo indirizzo e-mail?”
+ “Vuoi consentire all’hotel di inviarti e-mail promozionali?”
Una volta che l’agente ha stabilito tutti i parametri richiesti, li invia a una funzione Lambda definita per eseguire l’azione o li restituisce nella risposta all’invocazione dell’agente.
Per informazioni su come definire una funzione durante la creazione del gruppo di operazioni, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
# Definire schemi OpenAPI per i gruppi di operazioni dell’agente in Amazon Bedrock
Quando crei un gruppo di operazioni in Amazon Bedrock, devi definire i parametri che l’agente deve invocare dall’utente. Puoi anche definire operazioni API che l’agente può invocare utilizzando questi parametri. Per definire le operazioni API, crea uno schema OpenAPI in formato JSON o YAML. È possibile creare file di schemi OpenAPI e caricarli su Amazon Simple Storage Service (Amazon S3). In alternativa, è possibile utilizzare l’editor di testo OpenAPI nella console, che convaliderà lo schema. Dopo aver creato un agente, puoi utilizzare l’editor di testo quando aggiungi un gruppo di operazioni all’agente o modifichi un gruppo di operazioni esistente. Per ulteriori informazioni, consulta [Modifica di un agente](agents-edit.md).
L’agente utilizza lo schema per determinare l’operazione API da invocare e i parametri necessari per effettuare la richiesta API. Questi dettagli vengono quindi inviati tramite una funzione Lambda definita per eseguire l’azione o restituiti nella risposta all’invocazione dell’agente.
Per ulteriori informazioni sugli schemi API, consulta le seguenti risorse:
+ Per ulteriori dettagli sugli schemi OpenAPI, consulta [Specifiche OpenAPI](https://swagger.io/specification/) sul sito web di Swagger.
+ Per le best practice relative alla scrittura di schemi API, consulta [Best practice per la progettazione delle API](https://swagger.io/resources/articles/best-practices-in-api-design/) sul sito web di Swagger.
Di seguito è riportato il formato generale di uno schema OpenAPI per un gruppo di operazioni.
```
{
"openapi": "3.0.0",
"paths": {
"/path": {
"method": {
"description": "string",
"operationId": "string",
"parameters": [ ... ],
"requestBody": { ... },
"responses": { ... },
"x-requireConfirmation": ENABLED | DISABLED
}
}
}
}
```
Nell’elenco seguente vengono descritti i campi presenti nello schema OpenAPI:
+ `openapi`: (obbligatorio) la versione di OpenAPI in uso. Affinché il gruppo di operazioni funzioni, questo valore deve essere `"3.0.0"`.
+ `paths`: (obbligatorio) contiene percorsi relativi ai singoli endpoint. Ogni nome di percorso deve iniziare e terminare con una barra (`/`).
+ `method`: (obbligatorio) definisce il metodo da utilizzare.
+ `x-requireConfirmation`: (facoltativo) specifica se è richiesta la conferma dell’utente prima di invocare l’azione. Abilita questo campo per richiedere la conferma all’utente prima che l’azione venga invocata. Richiedere la conferma dell’utente prima di invocare l’azione può impedire all’applicazione di intraprendere azioni causate da iniezioni di prompt dannose. Se questo campo non viene specificato, per impostazione predefinita la conferma dell’utente è `DISABLED`.
Ogni metodo richiede almeno i seguenti campi:
+ `description`: una descrizione dell'operazione API. Utilizza questo campo per indicare all’agente quando chiamare questa operazione API e cosa fa l’operazione.
+ `operationId`: una stringa univoca che identifica un’operazione in un’API, ad esempio il nome di una funzione. Questo è un campo obbligatorio per tutti i nuovi modelli basati su toolUse come Anthropic, Claude 3.5 Sonnet e Meta Llama. Assicurati che l’identificatore (Id) che fornisci sia univoco per tutte le operazioni e segua un semplice pattern alfanumerico in cui i separatori sono solo trattini o trattini bassi.
+ `responses`: contiene le proprietà che l’agente restituisce nella risposta dell’API. L’agente utilizza le proprietà di risposta per creare prompt, elaborare accuratamente i risultati di una chiamata API e determinare una serie di fasi corrette per eseguire un’attività. L’agente può utilizzare i valori di risposta di un’operazione come input per le fasi successive dell’orchestrazione.
I campi all'interno dei due oggetti seguenti forniscono ulteriori informazioni affinché l'agente possa sfruttare efficacemente il gruppo di operazioni. Imposta il valore dei campi `required` su `true` se obbligatori e su `false` se facoltativi.
+ `parameters`: contiene informazioni sui parametri che possono essere inclusi nella richiesta.
+ `requestBody`: contiene i campi nel corpo della richiesta per l'operazione. Non includere questo campo per i metodi `GET` e `DELETE`.
Per ulteriori informazioni su una struttura, seleziona una delle seguenti schede.
------
#### [ responses ]
```
"responses": {
"200": {
"content": {
"": {
"schema": {
"properties": {
"": {
"type": "string",
"description": "string"
},
...
}
}
}
},
},
...
}
```
Ogni chiave dell’oggetto `responses` è un codice di risposta che descrive lo stato della risposta. Il codice di risposta è mappato su un oggetto che contiene le seguenti informazioni per la risposta:
+ `content`: (obbligatorio per ogni risposta) il contenuto della risposta.
+ **: il formato del corpo della risposta. Per ulteriori informazioni, consulta [Tipi di contenuti multimediali](https://swagger.io/docs/specification/media-types/) sul sito web di Swagger.
+ `schema`: (obbligatorio per ogni tipo di supporto) definisce il tipo di dati del corpo della risposta e dei relativi campi.
+ `properties`: (obbligatorio se nello schema sono presenti `items`) l'agente utilizza le proprietà definite nello schema per determinare le informazioni che deve restituire all'utente finale per eseguire un'attività. Ogni proprietà contiene i campi seguenti:
+ `type`: (obbligatorio per ogni proprietà) il tipo di dati del campo di risposta.
+ `description`: (facoltativo) descrive la proprietà. L’agente può utilizzare queste informazioni per determinare quelle da restituire all’utente finale.
------
#### [ parameters ]
```
"parameters": [
{
"name": "string",
"description": "string",
"required": boolean,
"schema": {
...
}
},
...
]
```
L’agente utilizza i seguenti campi per determinare le informazioni che deve ottenere dall’utente finale per soddisfare i requisiti del gruppo di operazioni.
+ `name`: (obbligatorio) il nome del parametro.
+ `description`: (obbligatorio) una descrizione del parametro. Utilizza questo campo per aiutare l'agente a capire come ottenere questo parametro dall'utente dell'agente o per determinare che abbia già quel valore di parametro in base alle azioni precedenti o alla richiesta dell'utente all'agente.
+ `required`: (facoltativo) se il parametro è necessario per la richiesta API. Utilizza questo campo per indicare all’agente se questo parametro è necessario per ogni invocazione o se è opzionale.
+ `schema`: (facoltativo) la definizione dei tipi di dati di input e output. Per ulteriori informazioni, consulta [Modelli di dati (Schemi)](https://swagger.io/docs/specification/data-models/) sul sito web di Swagger.
------
#### [ requestBody ]
Di seguito è riportata la struttura generale di un campo `requestBody`:
```
"requestBody": {
"required": boolean,
"content": {
"": {
"schema": {
"properties": {
"": {
"type": "string",
"description": "string"
},
...
}
}
}
}
}
```
Nell’elenco seguente è descritto ciascun campo:
+ `required`: (facoltativo) se il corpo della richiesta è necessario per la richiesta API.
+ `content`: (obbligatorio) il contenuto del corpo della richiesta.
+ **: (facoltativo) il formato del corpo della richiesta. Per ulteriori informazioni, consulta [Tipi di contenuti multimediali](https://swagger.io/docs/specification/media-types/) sul sito web di Swagger.
+ `schema`: (facoltativo) definisce il tipo di dati del corpo della richiesta e dei relativi campi.
+ `properties`: (facoltativo) l’agente utilizza le proprietà definite nello schema per determinare le informazioni che deve ottenere dall’utente finale per effettuare la richiesta API. Ogni proprietà contiene i campi seguenti:
+ `type`: (facoltativo) il tipo di dati del campo della richiesta.
+ `description`: (facoltativo) descrive la proprietà. L'agente può utilizzare queste informazioni per determinare quelle da restituire all'utente finale.
------
Per informazioni su come aggiungere lo schema OpenAPI creato durante la creazione del gruppo di operazioni, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
## Esempi di schemi API
L’esempio seguente fornisce uno schema OpenAPI semplice in formato YAML che ottiene informazioni sul meteo di una determinata località in gradi Celsius.
```
openapi: 3.0.0
info:
title: GetWeather API
version: 1.0.0
description: gets weather
paths:
/getWeather/{location}/:
get:
summary: gets weather in Celsius
description: gets weather in Celsius
operationId: getWeather
parameters:
- name: location
in: path
description: location name
required: true
schema:
type: string
responses:
"200":
description: weather in Celsius
content:
application/json:
schema:
type: string
```
Il seguente esempio di schema API definisce un gruppo di operazioni API che semplificano la gestione delle richieste di indennizzo assicurativo. Le tre API sono definite come segue:
+ `getAllOpenClaims`: il tuo agente può utilizzare il campo `description` per stabilire se chiamare questa operazione API nel caso in cui sia necessario un elenco di richieste di indennizzo aperte. `properties` in `responses` specifica se restituire l'ID e l'intestatario della polizza e lo stato della richiesta di indennizzo. L'agente restituisce queste informazioni all'utente dell'agente o utilizza alcune o tutte le risposte come input per le successive chiamate API.
+ `identifyMissingDocuments`: l’agente può utilizzare il campo `description` per stabilire che deve chiamare questa operazione API se è necessario identificare i documenti mancanti per una richiesta di indennizzo. I campi `name`, `description` e `required` indicano all'agente che deve richiedere al cliente l'identificativo univoco della richiesta di indennizzo aperta. `properties` in `responses` specificano di restituire gli ID delle richieste di indennizzo assicurativo aperte. L’agente restituisce queste informazioni all’utente finale oppure utilizza alcune o tutte le risposte come input per le chiamate API successive.
+ `sendReminders`: l’agente può utilizzare il campo `description` per stabilire che deve chiamare questa operazione API se è necessario inviare dei promemoria al cliente, ad esempio su documenti in sospeso per le richieste di indennizzo aperte. Le `properties` nel `requestBody` comunicano all’agente che deve trovare gli ID delle richieste di indennizzo e i documenti in sospeso. Le `properties` nelle `responses` specificano di restituire un ID di un promemoria e il relativo stato. L’agente restituisce queste informazioni all’utente finale oppure utilizza alcune o tutte le risposte come input per le chiamate API successive.
```
{
"openapi": "3.0.0",
"info": {
"title": "Insurance Claims Automation API",
"version": "1.0.0",
"description": "APIs for managing insurance claims by pulling a list of open claims, identifying outstanding paperwork for each claim, and sending reminders to policy holders."
},
"paths": {
"/claims": {
"get": {
"summary": "Get a list of all open claims",
"description": "Get the list of all open insurance claims. Return all the open claimIds.",
"operationId": "getAllOpenClaims",
"responses": {
"200": {
"description": "Gets the list of all open insurance claims for policy holders",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"type": "object",
"properties": {
"claimId": {
"type": "string",
"description": "Unique ID of the claim."
},
"policyHolderId": {
"type": "string",
"description": "Unique ID of the policy holder who has filed the claim."
},
"claimStatus": {
"type": "string",
"description": "The status of the claim. Claim can be in Open or Closed state"
}
}
}
}
}
}
}
}
}
},
"/claims/{claimId}/identify-missing-documents": {
"get": {
"summary": "Identify missing documents for a specific claim",
"description": "Get the list of pending documents that need to be uploaded by policy holder before the claim can be processed. The API takes in only one claim id and returns the list of documents that are pending to be uploaded by policy holder for that claim. This API should be called for each claim id",
"operationId": "identifyMissingDocuments",
"parameters": [{
"name": "claimId",
"in": "path",
"description": "Unique ID of the open insurance claim",
"required": true,
"schema": {
"type": "string"
}
}],
"responses": {
"200": {
"description": "List of documents that are pending to be uploaded by policy holder for insurance claim",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"pendingDocuments": {
"type": "string",
"description": "The list of pending documents for the claim."
}
}
}
}
}
}
}
}
},
"/send-reminders": {
"post": {
"summary": "API to send reminder to the customer about pending documents for open claim",
"description": "Send reminder to the customer about pending documents for open claim. The API takes in only one claim id and its pending documents at a time, sends the reminder and returns the tracking details for the reminder. This API should be called for each claim id you want to send reminders for.",
"operationId": "sendReminders",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"claimId": {
"type": "string",
"description": "Unique ID of open claims to send reminders for."
},
"pendingDocuments": {
"type": "string",
"description": "The list of pending documents for the claim."
}
},
"required": [
"claimId",
"pendingDocuments"
]
}
}
}
},
"responses": {
"200": {
"description": "Reminders sent successfully",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"sendReminderTrackingId": {
"type": "string",
"description": "Unique Id to track the status of the send reminder Call"
},
"sendReminderStatus": {
"type": "string",
"description": "Status of send reminder notifications"
}
}
}
}
}
},
"400": {
"description": "Bad request. One or more required fields are missing or invalid."
}
}
}
}
}
}
```
Per altri esempi di schemi OpenAPI, consulta [Descrizioni di API di esempio](https://learn.openapis.org/examples/) sul sito web di OpenAPI.
# Gestione dell’adempimento dell’azione
Quando configuri il gruppo di azioni, devi selezionare anche una delle seguenti opzioni che l’agente utilizzerà per trasmettere le informazioni e i parametri ricevuti dall’utente:
+ Aggiungi l’input dell’utente al gruppo di azioni del tuo agente. Con l’input dell’utente, l’agente può [richiedere all’utente ulteriori informazioni](agents-user-input.md) qualora non disponga di dati sufficienti per completare un’attività.
+ Passa a una [funzione Lambda che crei](agents-lambda.md) per definire la logica di business del gruppo di azioni.
+ Salta l’uso di una funzione Lambda e [restituisci il controllo](agents-returncontrol.md) passando le informazioni e i parametri forniti dall’utente nella risposta `InvokeAgent`. Le informazioni e i parametri possono essere inviati ai propri sistemi per ottenere risultati, i quali possono essere a loro volta inviati nella [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_SessionState.html#bedrock-Type-agent-runtime_SessionState](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_SessionState.html#bedrock-Type-agent-runtime_SessionState) di un’altra richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html).
+ Abilita la conferma dell’utente per un’azione. Abilitando la conferma dell’utente è possibile proteggere l’applicazione da iniezioni di prompt dannose [richiedendo la conferma agli utenti dell’applicazione](agents-userconfirmation.md) prima di invocare la funzione del gruppo di azioni.
Seleziona un argomento per scoprire come configurare le modalità con cui viene gestita l’esecuzione del gruppo di azioni dopo che l’utente ha ricevuto le informazioni necessarie.
**Topics**
+ [Configura le funzioni Lambda per inviare informazioni che un agente di Amazon Bedrock ottiene dall’utente](agents-lambda.md)
+ [Restituzione del controllo allo sviluppatore dell’agente inviando le informazioni richieste in una risposta InvokeAgent](agents-returncontrol.md)
+ [Come ottenere la conferma dell’utente prima di invocare la funzione del gruppo di operazioni](agents-userconfirmation.md)
# Configura le funzioni Lambda per inviare informazioni che un agente di Amazon Bedrock ottiene dall’utente
Puoi definire una funzione Lambda per programmare la logica aziendale per un gruppo di operazioni. Dopo che un agente di Amazon Bedrock ha determinato quale operazione API invocare in un gruppo di operazioni, invia alla funzione Lambda informazioni dallo schema dell’API insieme ai metadati pertinenti come evento di input. Per scrivere una funzione, è necessario conoscere i seguenti componenti della funzione Lambda:
+ **Evento di input**: contiene i metadati pertinenti e i campi compilati del corpo della richiesta dell’operazione API o dei parametri della funzione per l’operazione che l’agente stabilisce debba essere chiamata.
+ **Risposta**: contiene i metadati pertinenti e i campi compilati per il corpo della risposta restituito dall’operazione o dalla funzione dell’API.
Scrivi la tua funzione Lambda per definire come gestire un gruppo di operazioni e per personalizzare il modo in cui desideri che venga restituita la risposta dell’API. Le variabili dell’evento di input vengono utilizzate per definire le funzioni e restituire una risposta all’agente.
**Nota**
Un gruppo di operazioni può contenere fino a 11 operazioni API, ma è possibile scrivere una sola funzione Lambda. Poiché la funzione Lambda può ricevere solo un evento di input e restituire una risposta per un’operazione API alla volta, è necessario scrivere la funzione considerando le diverse operazioni API che possono essere invocate.
Per consentire all’agente di utilizzare una funzione Lambda e fornirgli le autorizzazioni, è necessario allegare alla funzione una policy basata sulle risorse. Per ulteriori informazioni, segui la procedura indicata in [Policy basata sulle risorse per consentire ad Amazon Bedrock di invocare una funzione Lambda del gruppo di operazioni](agents-permissions.md#agents-permissions-lambda). Per ulteriori informazioni sulle politiche basate sulle risorse in Lambda, consulta Using [resource-based policies](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) for Lambda nella Developer Guide. AWS Lambda
Per informazioni su come definire una funzione durante la creazione del gruppo di operazioni, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
**Topics**
+ [Evento di input Lambda da Amazon Bedrock](#agents-lambda-input)
+ [Evento di risposta Lambda ad Amazon Bedrock](#agents-lambda-response)
+ [Esempio di funzioni Lambda del gruppo di operazioni](#agents-lambda-example)
## Evento di input Lambda da Amazon Bedrock
Quando viene richiamato un gruppo di operazioni che utilizza una funzione Lambda, Amazon Bedrock invia un evento di input Lambda nel seguente formato generale. Puoi definire la funzione Lambda in modo che utilizzi uno qualsiasi dei campi degli eventi di input per manipolare la logica aziendale all’interno della funzione per eseguire correttamente l’azione. Per ulteriori informazioni sulle funzioni Lambda, consulta [Event-driven invocation](https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html#event-driven-invocation) nella Developer Guide. AWS Lambda
Il formato dell’evento di input dipende dal fatto che il gruppo di operazioni sia stato definito con uno schema dell’API o con i dettagli della funzione:
+ Se hai definito il gruppo di operazioni con uno schema dell’API, il formato dell’evento di input è il seguente:
```
{
"messageVersion": "1.0",
"agent": {
"name": "string",
"id": "string",
"alias": "string",
"version": "string"
},
"inputText": "string",
"sessionId": "string",
"actionGroup": "string",
"apiPath": "string",
"httpMethod": "string",
"parameters": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
],
"requestBody": {
"content": {
"": {
"properties": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
]
}
}
},
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
}
}
```
+ Se hai definito il gruppo di operazioni con i dettagli della funzione, il formato dell’evento di input è il seguente:
```
{
"messageVersion": "1.0",
"agent": {
"name": "string",
"id": "string",
"alias": "string",
"version": "string"
},
"inputText": "string",
"sessionId": "string",
"actionGroup": "string",
"function": "string",
"parameters": [
{
"name": "string",
"type": "string",
"value": "string"
},
...
],
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
}
}
```
Nella lista riportata di seguito sono descritti i campi dell’evento di input.
+ `messageVersion`: la versione del messaggio che identifica il formato dei dati dell’evento che giungono alla funzione Lambda e il formato previsto della risposta da parte di una funzione Lambda. Amazon Bedrock supporta solo la versione 1.0.
+ `agent`: contiene informazioni su nome, ID, alias e versione dell'agente a cui appartiene il gruppo di operazioni.
+ `inputText`: l'input dell'utente per il turno di conversazione.
+ `sessionId`: l'identificatore univoco della sessione dell'agente.
+ `actionGroup`: il nome del gruppo di azione.
+ `parameters`: contiene un elenco di oggetti. Ogni oggetto contiene il nome, il tipo e il valore di un parametro nell’operazione API, come definito nello schema di OpenAPI o nella funzione.
+ Se hai definito il gruppo di operazioni con uno schema dell’API, l’evento di input contiene i seguenti campi:
+ `apiPath`: il percorso dell’operazione API, come definito nello schema di OpenAPI.
+ `httpMethod`: il metodo dell’operazione API, come definito nello schema di OpenAPI.
+ `requestBody`: contiene il corpo della richiesta e le relative proprietà, come definito nello schema di OpenAPI per il gruppo di operazioni.
+ Se hai definito il gruppo di operazioni con i dettagli della funzione, l’evento di input contiene i seguenti campi:
+ `function`: il nome della funzione come definito nei dettagli della funzione per il gruppo di operazioni.
+ `sessionAttributes`: contiene gli [attributi della sessione](agents-session-state.md) e i relativi valori. Questi attributi vengono archiviati durante una [sessione](advanced-prompts.md#advanced-prompts-terminology) e forniscono un contesto per l’agente.
+ `promptSessionAttributes`: contiene gli [attributi di sessione del prompt](agents-session-state.md) e i relativi valori. Questi attributi vengono archiviati durante un [turno](advanced-prompts.md#advanced-prompts-terminology) e forniscono un contesto per l’agente.
## Evento di risposta Lambda ad Amazon Bedrock
Amazon Bedrock si aspetta una risposta dalla funzione Lambda nel formato seguente. La risposta è costituita da parametri restituiti dall’operazione API. L'agente può utilizzare la risposta della funzione Lambda per un'ulteriore orchestrazione o come aiuto per restituire una risposta al cliente.
**Nota**
La dimensione massima della risposta del payload corrisponde alla dimensione massima di una risposta sincrona della funzione Lambda. [Per ulteriori informazioni, consulta la quota di risorse di *invocation payload* nella Developer Guide.](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution) AWS Lambda
Il formato dell’evento di input dipende dal fatto che il gruppo di operazioni sia stato definito con uno schema dell’API o con i dettagli della funzione:
+ Se hai definito il gruppo di operazioni con uno schema dell’API, il formato della risposta è il seguente:
```
{
"messageVersion": "1.0",
"response": {
"actionGroup": "string",
"apiPath": "string",
"httpMethod": "string",
"httpStatusCode": number,
"responseBody": {
"": {
"body": "JSON-formatted string"
}
}
},
"sessionAttributes": {
"string": "string",
...
},
"promptSessionAttributes": {
"string": "string",
...
},
"knowledgeBasesConfiguration": [
{
"knowledgeBaseId": "string",
"retrievalConfiguration": {
"vectorSearchConfiguration": {
"numberOfResults": int,
"overrideSearchType": "HYBRID | SEMANTIC",
"filter": [RetrievalFilter](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrievalFilter.html) object
}
}
},
...
]
}
```
+ Se hai definito il gruppo di operazioni con i dettagli della funzione, il formato della risposta è il seguente:
```
{
"messageVersion": "1.0",
"response": {
"actionGroup": "string",
"function": "string",
"functionResponse": {
"responseState": "FAILURE | REPROMPT",
"responseBody": {
"": {
"body": "JSON-formatted string"
}
}
}
},
"sessionAttributes": {
"string": "string",
},
"promptSessionAttributes": {
"string": "string"
},
"knowledgeBasesConfiguration": [
{
"knowledgeBaseId": "string",
"retrievalConfiguration": {
"vectorSearchConfiguration": {
"numberOfResults": int,
"filter": {
[RetrievalFilter](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrievalFilter.html) object
}
}
}
},
...
]
}
```
L’elenco fornito di seguito descrive i campi di risposta.
+ `messageVersion`: la versione del messaggio che identifica il formato dei dati dell’evento che giungono alla funzione Lambda e il formato previsto della risposta da parte di una funzione Lambda. Amazon Bedrock supporta solo la versione 1.0.
+ `response`: contiene le seguenti informazioni sulla risposta API.
+ `actionGroup`: il nome del gruppo di azione.
+ Se hai definito il gruppo di operazioni con uno schema dell’API, la risposta può contenere i seguenti campi:
+ `apiPath`: il percorso dell’operazione API, come definito nello schema di OpenAPI.
+ `httpMethod`: il metodo dell’operazione API, come definito nello schema di OpenAPI.
+ `httpStatusCode`: il codice di stato HTTP restituito dall’operazione API.
+ `responseBody`: contiene il corpo della risposta, come definito nello schema di OpenAPI.
+ Se hai definito il gruppo di operazioni con i dettagli della funzione, la risposta può contenere i seguenti campi:
+ `responseState` (facoltativo): imposta uno degli stati indicati di seguito per definire il comportamento dell’agente dopo l’elaborazione dell’operazione.
+ ERRORE: l’agente genera una `DependencyFailedException` per la sessione corrente. Si applica quando l’esecuzione della funzione non riesce a causa di un errore di dipendenza.
+ NUOVO PROMPT: l’agente passa una stringa di risposta al modello per un nuovo prompt. Si applica quando l’esecuzione della funzione non riesce a causa di un input non valido.
+ `responseBody`: contiene un oggetto che definisce la risposta derivante dall’esecuzione della funzione. La chiave è il tipo di contenuto (attualmente è supportato solo `TEXT`) e il valore è un oggetto contenente il `body` della risposta.
+ (Facoltativo) `sessionAttributes`: contiene gli attributi della sessione e i relativi valori. Per ulteriori informazioni, consulta [Attributi della sessione e della sessione di prompt](agents-session-state.md#session-state-attributes).
+ (Facoltativo) `promptSessionAttributes`: contiene gli attributi del prompt e i relativi valori. Per ulteriori informazioni, consulta [Attributi della sessione e della sessione di prompt](agents-session-state.md#session-state-attributes).
+ (Facoltativo) `knowledgeBasesConfiguration`: contiene un elenco di configurazioni di query per le knowledge base collegate all’agente. Per ulteriori informazioni, consulta [Configurazioni di recupero della knowledge base](agents-session-state.md#session-state-kb).
## Esempio di funzioni Lambda del gruppo di operazioni
Di seguito è riportato un esempio minimo di come è possibile definire la funzione Lambda in. Python Seleziona la scheda corrispondente a seconda se hai definito il gruppo di operazioni con uno schema di OpenAPI o con i dettagli della funzione:
------
#### [ OpenAPI schema ]
```
def lambda_handler(event, context):
agent = event['agent']
actionGroup = event['actionGroup']
api_path = event['apiPath']
# get parameters
get_parameters = event.get('parameters', [])
# post parameters
post_parameters = event['requestBody']['content']['application/json']['properties']
response_body = {
'application/json': {
'body': "sample response"
}
}
action_response = {
'actionGroup': event['actionGroup'],
'apiPath': event['apiPath'],
'httpMethod': event['httpMethod'],
'httpStatusCode': 200,
'responseBody': response_body
}
session_attributes = event['sessionAttributes']
prompt_session_attributes = event['promptSessionAttributes']
api_response = {
'messageVersion': '1.0',
'response': action_response,
'sessionAttributes': session_attributes,
'promptSessionAttributes': prompt_session_attributes
}
return api_response
```
------
#### [ Function details ]
```
def lambda_handler(event, context):
agent = event['agent']
actionGroup = event['actionGroup']
function = event['function']
parameters = event.get('parameters', [])
response_body = {
'TEXT': {
'body': "sample response"
}
}
function_response = {
'actionGroup': event['actionGroup'],
'function': event['function'],
'functionResponse': {
'responseBody': response_body
}
}
session_attributes = event['sessionAttributes']
prompt_session_attributes = event['promptSessionAttributes']
action_response = {
'messageVersion': '1.0',
'response': function_response,
'sessionAttributes': session_attributes,
'promptSessionAttributes': prompt_session_attributes
}
return action_response
```
------
# Restituzione del controllo allo sviluppatore dell’agente inviando le informazioni richieste in una risposta InvokeAgent
Anziché inviare le informazioni che l’agente ha ottenuto dall’utente a una funzione Lambda per l’adempimento, puoi scegliere di restituire il controllo allo sviluppatore dell’agente inviando le informazioni nella risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html). È possibile configurare la restituzione del controllo allo sviluppatore dell’agente durante la creazione o l’aggiornamento di un gruppo di operazioni. Tramite l’API, puoi specificare `RETURN_CONTROL` come valore `customControl` nell’oggetto `actionGroupExecutor` in una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html) o [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html). Per ulteriori informazioni, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
Se configuri la restituzione del controllo per un gruppo di operazioni e se l’agente stabilisce che deve chiamare un’azione in tale gruppo, i dettagli dell’API o della funzione richiesti all’utente verranno restituiti nel campo `invocationInputs` della risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html), insieme a un valore `invocationId` univoco. A questo punto puoi effettuare le seguenti operazioni:
+ Configurare l’applicazione per invocare l’API o la funzione che hai definito, a condizione di fornire le informazioni restituite in `invocationInputs`.
+ Inviare i risultati dell’invocazione dell’applicazione in un’altra richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html), nel campo `sessionState`, per fornire un contesto all’agente. È necessario utilizzare gli stessi `invocationId` e `actionGroup` restituiti nella risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html). Queste informazioni possono essere utilizzate come contesto per un’ulteriore orchestrazione, inviate in post-elaborazione affinché l’agente formatti una risposta o utilizzate direttamente nella risposta dell’agente all’utente.
**Nota**
Se includi `returnControlInvocationResults` nel campo `sessionState`, il campo `inputText` verrà ignorato.
Per informazioni su come configurare la restituzione del controllo allo sviluppatore dell’agente durante la creazione del gruppo di operazioni, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
## Esempio di restituzione del controllo allo sviluppatore dell’agente
Ad esempio potrebbero essere presenti i seguenti gruppi di operazioni:
+ Un gruppo di operazioni `PlanTrip` con un’azione `suggestActivities` che aiuta gli utenti a trovare le attività da svolgere durante un viaggio. La `description` di questa azione riporta `This action suggests activities based on retrieved weather information`.
+ Un gruppo di operazioni `WeatherAPIs` con un’azione `getWeather` che aiuta l’utente a consultare le condizioni meteorologiche di una località specifica. I parametri dell’azione richiesti sono `location` e `date`. Il gruppo di operazioni è configurato in modo da restituire il controllo allo sviluppatore dell’agente.
Di seguito è riportata una sequenza ipotetica che potrebbe verificarsi:
1. L’utente pone all’agente la seguente domanda: **What should I do today?** Questa query viene inviata nel campo `inputText` di una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html).
1. L’agente riconosce che l’azione `suggestActivities` deve essere invocata ma, data la descrizione, prevede di dover prima invocare l’azione `getWeather` come contesto per contribuire all’adempimento dell’azione `suggestActivities`.
1. L’agente sa che la `date` corrente è `2024-09-15`, ma per scoprire le condizioni meteorologiche ha bisogno della `location` dell’utente come parametro obbligatorio. Quindi, si rivolge nuovamente all’utente ponendo la domanda “Dove ti trovi?”
1. L’utente risponde **Seattle**.
1. L’agente restituisce i parametri per `getWeather` nella seguente risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html) (seleziona una scheda per consultare gli esempi di un gruppo di operazioni definito con quel metodo):
------
#### [ Function details ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"returnControl": {
"invocationInputs": [{
"functionInvocationInput": {
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172"
}
}
```
------
#### [ OpenAPI schema ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"invocationInputs": [{
"apiInvocationInput": {
"actionGroup": "WeatherAPIs",
"apiPath": "/get-weather",
"httpMethod": "get",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad"
}
```
------
1. L’applicazione è configurata per utilizzare questi parametri allo scopo di ottenere le condizioni meteorologiche di `seattle` in data `2024-09-15`. Viene determinato che il tempo è piovoso.
1. Questi risultati vengono inviati nel campo `sessionState` di un’altra richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html), utilizzando gli stessi `invocationId`, `actionGroup` e `function` della risposta precedente. Seleziona una scheda per consultare esempi di un gruppo di operazioni definito con tale metodo:
------
#### [ Function details ]
```
POST https://bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172",
"returnControlInvocationResults": [{
"functionResult": {
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"responseBody": {
"TEXT": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
#### [ OpenAPI schema ]
```
POST https: //bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad",
"returnControlInvocationResults": [{
"apiResult": {
"actionGroup": "WeatherAPIs",
"httpMethod": "get",
"apiPath": "/get-weather",
"responseBody": {
"application/json": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
1. L’agente prevede di dover chiamare l’azione `suggestActivities`. Basandosi sul contesto secondo cui quel giorno pioverà, nella risposta suggerisce all’utente attività al chiuso anziché all’aperto.
### Esempio di restituzione del controllo all’agente collaboratore
Se utilizzi la [collaborazione multiagente](agents-multi-agent-collaboration.md) e un agente collaboratore sceglie di restituire il controllo inviando le informazioni nella risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html), le informazioni vengono restituite nella risposta dell’agente supervisore con gli identificatori aggiuntivi `agentId` e `collaboratorName`. Seleziona una scheda per consultare esempi di un gruppo di operazioni definito con tale metodo:
------
#### [ Function details ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"returnControl": {
"invocationInputs": [{
"functionInvocationInput": {
"agentId": "AGENTID",
"collaboratorName": "WeatherAgent"
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172"
}
}
```
------
#### [ OpenAPI Schema ]
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: application/json
x-amz-bedrock-agent-session-id: session0
Content-type: application/json
{
"invocationInputs": [{
"apiInvocationInput": {
"actionGroup": "WeatherAPIs",
"agentId": "AGENTID",
"collaboratorName": "WeatherAgent"
"apiPath": "/get-weather",
"httpMethod": "get",
"parameters": [
{
"name": "location",
"type": "string",
"value": "seattle"
},
{
"name": "date",
"type": "string",
"value": "2024-09-15"
}
]
}
}],
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad"
}
```
------
L’invoker dell’agente supervisore invia i risultati del campo `sessionState` all’agente supervisore con i risultati `agentId` corrispondenti, affinché vengano propagati all’agente collaboratore giusto.
------
#### [ Function details ]
```
POST https://bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "79e0feaa-c6f7-49bf-814d-b7c498505172",
"returnControlInvocationResults": [{
"functionResult": {
"agentId": "AGENTID",
"actionGroup": "WeatherAPIs",
"function": "getWeather",
"responseBody": {
"TEXT": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
#### [ OpenAPI Schema ]
```
POST https: //bedrock-agent-runtime.us-east-1.amazonaws.com/agents/AGENT12345/agentAliases/TSTALIASID/sessions/abb/text
{
"enableTrace": true,
"sessionState": {
"invocationId": "337cb2f6-ec74-4b49-8141-00b8091498ad",
"returnControlInvocationResults": [{
"apiResult": {
"agentId": "AGENTID",
"actionGroup": "WeatherAPIs",
"httpMethod": "get",
"apiPath": "/get-weather",
"responseBody": {
"application/json": {
"body": "It's rainy in Seattle today."
}
}
}
}]
}
}
```
------
# Come ottenere la conferma dell’utente prima di invocare la funzione del gruppo di operazioni
È possibile proteggere l’applicazione da iniezioni di prompt dannose richiedendo la conferma agli utenti dell’applicazione prima di invocare la funzione del gruppo di operazioni. Quando un utente finale interagisce con la tua applicazione, Agent per Amazon Bedrock individua l’API o le knowledge base da invocare per automatizzare l’attività per l’utente. Le informazioni dell’API o delle knowledge base potrebbero contenere dati potenzialmente dannosi. Tra un’iterazione e l’altra, l’agente rispetta eventuali istruzioni contenute nella risposta. Se la risposta include istruzioni per consentire al modello di invocare azioni non intenzionali, l’agente procederà di conseguenza. Per garantire che determinate azioni vengano implementate solo dopo il consenso esplicito dell’utente, consigliamo di richiedere la conferma all’utente finale prima di invocare la funzione.
Quando configuri il tuo gruppo di operazioni, puoi scegliere di abilitare la conferma dell’utente per azioni specifiche. Se per un’azione è abilitata la conferma dell’utente, l’agente risponde con una domanda di conferma chiedendo all’utente finale di confermare o rifiutare l’azione. Puoi abilitare la conferma dell’utente nella console, utilizzando la CLI o l’SDK.
Per abilitare la conferma dell’utente di un’azione, consulta [Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock](agents-action-add.md).
## Come funziona la conferma dell’utente
La conferma dell’utente viene configurata per un’azione nel gruppo di operazioni dallo sviluppatore dell’agente. Se l’agente decide di richiedere tale azione, nel campo `invocationInputs` della risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html) verranno restituiti i dettagli dell’API o della funzione forniti dall’utente e la conferma dell’utente configurata dallo sviluppatore dell’agente, insieme a `invocationType` e a un messaggio univoco `invocationId`.
L’agente invoca l’API o la funzione fornita negli `invocationInputs`. Se per la funzione o l’API è abilitata la conferma dell’utente, all’utente vengono presentate due opzioni, **CONFERMA** o **NEGA**, per scegliere l’azione menzionata nella risposta.
I risultati dell’invocazione della funzione o dell’API da parte dell’agente vengono inviati in un’altra richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html) nel campo `sessionState`, per fornire un contesto all’agente. Il parametro di richiesta per `InvokeAgent` utilizza `returnControlInvocationResults`, ovvero un elenco di mappature agli oggetti `apiResult` o `functionResult`. Gli oggetti `apiResult` e `functionResult` hanno un campo di `confirmationState` aggiuntivo, che contiene la risposta della conferma dell’utente.
Se la risposta dell’utente è **CONFERMA**, nella risposta viene implementata la funzione o l’API.
Se la risposta dell’utente è **NEGA**, la funzione o l’API non viene implementata nella risposta.
## Esempi di risposta e richiesta di InvokeAgent
**Risposta**
```
HTTP/1.1 200
x-amzn-bedrock-agent-content-type: contentType
x-amz-bedrock-agent-session-id: sessionId
Content-type: application/json
{
"chunk": {
...
},
...
"returnControl": {
"invocationId": "string",
"invocationInputs": [
{ ... }
]
},
"trace": {
"agentAliasId": "string",
"agentId": "string",
"agentVersion": "string",
"sessionId": "string",
"trace": { ... }
},
}
```
**Richiesta**
```
POST /agents/agentId/agentAliases/agentAliasId/sessions/sessionId/text HTTP/1.1
Content-type: application/json
{
"enableTrace": boolean,
"endSession": boolean,
"inputText": "string",
"sessionState": {
"invocationId": "string",
"promptSessionAttributes": {
"string" : "string"
},
"returnControlInvocationResults": [
{ ... }
],
"sessionAttributes": {
"string" : "string"
}
}
}
```
# Aggiunta di un gruppo di operazioni all’agente in Amazon Bedrock
Dopo aver impostato lo schema OpenAPI e la funzione Lambda per il gruppo di operazioni, è possibile creare il gruppo di operazioni. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
**Nota**
Se stai utilizzando Anthropic Claude 3.5 Sonnet, assicurati che il nome dello strumento visualizzato nel modulo `httpVerb__actionGroupName__apiName` segua il formato del nome dello strumento Anthropic `^[a-zA-Z0-9_-]{1,64}$`. actionGroupName e apiName non devono contenere trattini bassi doppi `'__'`.
------
#### [ Console ]
Quando [crei un agente](agents-create.md), puoi aggiungere gruppi di azioni alla bozza di lavoro.
Una volta creato un agente, è possibile aggiungervi gruppi di operazioni attenendosi alle seguenti fasi:
**Per aggiungere un gruppo di operazioni a un agente**
1. Accedi alla Console di gestione AWS con un’identità IAM che disponga delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all’indirizzo [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Seleziona **Agenti** nel riquadro di navigazione a sinistra. Quindi, scegli un agente nella sezione **Agenti**.
1. Scegli **Modifica in Agente Builder**.
1. Nella sezione **Gruppi di operazioni**, seleziona **Aggiungi**.
1. (Facoltativo) Nella sezione **Dettagli del gruppo di operazioni**, modifica il **nome** generato automaticamente e fornisci una **descrizione** facoltativa per il tuo gruppo di operazioni.
1. Nella sezione **Tipo di gruppo di operazioni**, seleziona uno dei seguenti metodi per definire i parametri che l’agente può richiedere agli utenti per facilitare l’esecuzione delle azioni:
1. **Definisci con i dettagli della funzione**: definisci i parametri che l’agente deve richiedere all’utente per eseguire le azioni. Per ulteriori informazioni sull’aggiunta di funzioni, consulta [Definizione dei dettagli della funzione per i gruppi di operazioni dell’agente in Amazon Bedrock](agents-action-function.md).
1. **Definisci con schemi API**: definisci le operazioni API che l’agente può invocare e i relativi parametri. Utilizza uno schema OpenAPI che hai creato o creane uno con l’editor di testo della console. Per ulteriori informazioni sull’impostazione di uno schema OpenAPI, consulta [Definire schemi OpenAPI per i gruppi di operazioni dell’agente in Amazon Bedrock](agents-api-schema.md).
1. Nella sezione **Invocazione di un gruppo di operazioni**, imposta ciò che fa l’agente dopo aver previsto l’API o la funzione da invocare e aver ricevuto i parametri necessari. Scegli una delle seguenti opzioni:
+ **Crea rapidamente una nuova funzione Lambda (*scelta consigliata*)**: consenti ad Amazon Bedrock di creare per l’agente una funzione Lambda di base che potrai successivamente modificare in AWS Lambda a seconda del tuo caso d’uso. L’agente passerà alla funzione Lambda l’API o la funzione che ha previsto e i relativi parametri, in base alla sessione.
+ **Seleziona una funzione Lambda esistente**: scegli una [funzione Lambda creata in precedenza](agents-lambda.md) in AWS Lambda e la versione della funzione da utilizzare. L’agente passerà alla funzione Lambda l’API o la funzione che ha previsto e i relativi parametri, in base alla sessione.
**Nota**
Per consentire al principale del servizio di Amazon Bedrock di accedere alla funzione Lambda, [collega alla funzione Lambda una policy basata sulle risorse](agents-permissions.md#agents-permissions-lambda).
+ **Controllo del ritorno**: anziché passare alla funzione Lambda i parametri per l’API o la funzione che ha previsto, l’agente restituisce il controllo all’applicazione passando nella risposta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeAgent.html) l’azione che prevede debba essere invocata, oltre ai parametri e alle informazioni per l’azione che ha determinato dalla sessione. Per ulteriori informazioni, consulta [Restituzione del controllo allo sviluppatore dell’agente inviando le informazioni richieste in una risposta InvokeAgent](agents-returncontrol.md).
1. A seconda della scelta del **Tipo di gruppo di operazioni**, verrà visualizzata una delle seguenti sezioni:
+ Se hai selezionato **Definisci con i dettagli della funzione**, verrà visualizzata una sezione **Funzione del gruppo di operazioni**. Per definire la funzione, effettua le seguenti operazioni:
1. Fornisci un **Nome** e una **Descrizione** facoltativa (ma consigliata).
1. Per richiedere la conferma all’utente prima che la funzione venga invocata, seleziona **Abilitata**. Richiedere la conferma prima di invocare la funzione può impedire all’applicazione di intraprendere azioni causate da iniezioni di prompt dannose.
1. Nella sottosezione **Parametri**, scegli **Aggiungi parametro**. Definisci i campi seguenti:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/agents-action-add.html)
1. Per aggiungere un altro parametro, scegli **Aggiungi parametro**.
1. Per modificare un campo in un parametro, selezionalo e apporta le modifiche necessarie.
1. Per eliminare un parametro, scegli l’icona di eliminazione (![\[Trapezoid-shaped diagram showing data flow from source to destination through AWS Transfer Family.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/trash.png)) nella riga contenente il parametro.
Se preferisci definire la funzione utilizzando un oggetto JSON, scegli **Editor JSON** anziché **Tabella**. Il formato dell’oggetto JSON è il seguente (ogni chiave nell’oggetto `parameters` è un nome di parametro fornito dall’utente):
```
{
"name": "string",
"description": "string",
"parameters": [
{
"name": "string",
"description": "string",
"required": "True" | "False",
"type": "string" | "number" | "integer" | "boolean" | "array"
}
]
}
```
Per aggiungere un’ulteriore funzione al gruppo di operazioni definendo un altro set di parametri, scegli **Aggiungi la funzione del gruppo di operazioni**.
+ Se hai selezionato **Definisci con schemi API**, verrà visualizzata una sezione **Schema del gruppo di operazioni** con le seguenti opzioni:
+ Per utilizzare uno schema OpenAPI precedentemente preparato con descrizioni, strutture e parametri delle API per il gruppo di operazioni, scegli **Seleziona lo schema API** e fornisci un link all’URI Amazon S3 dello schema.
+ Per definire lo schema OpenAPI con l’editor di schemi in linea, seleziona **Definizione tramite editor di schemi in linea**. Viene visualizzato uno schema di esempio che puoi modificare.
1. Seleziona il formato per lo schema utilizzando il menu a discesa accanto a **Formato**.
1. Per importare uno schema esistente da S3 per modificarlo, seleziona **Importa schema**, fornisci l'URI S3 e seleziona **Importa**.
1. Per ripristinare lo schema allo schema di esempio originale, seleziona **Reimposta**, quindi conferma il messaggio visualizzato selezionando nuovamente **Reimposta**.
1. Una volta completata la creazione del gruppo di operazioni, scegli **Aggiungi**. Se hai definito uno schema API e non si sono verificati problemi, viene visualizzato un banner verde che notifica la riuscita dell’operazione. In caso di problemi durante la convalida dello schema, viene visualizzato un banner rosso. Sono disponibili le seguenti opzioni:
+ Scorri lo schema per visualizzare le righe in cui è presente un errore o un avviso sulla formattazione. Una X indica un errore di formattazione, mentre un punto esclamativo indica un avviso sulla formattazione.
+ Seleziona **Visualizza dettagli** nel banner rosso per visualizzare un elenco di errori relativi al contenuto dello schema API.
1. **Prepara** l’agente per l’applicazione delle modifiche apportate prima di testarlo.
------
#### [ API ]
Per creare un gruppo di operazioni, invia una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateAgentActionGroup.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). È necessario fornire uno [schema di funzioni](agents-action-function.md) o uno [schema OpenAPI](agents-api-schema.md).
Nell’elenco riportato di seguito sono descritti i campi presenti nella richiesta.
+ I seguenti campi sono obbligatori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/agents-action-add.html)
+ Per definire i parametri per il gruppo di operazioni, è necessario specificare uno dei seguenti campi (non è possibile specificarli entrambi).
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/agents-action-add.html)
Di seguito viene illustrato il formato generale di `functionSchema` e `apiSchema`:
+ Ogni elemento della matrice `functionSchema` è un oggetto [FunctionSchema](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FunctionSchema.html). Per ogni evento, specifica quanto segue:
+ Fornisci un `name` e una `description` facoltativa (ma consigliata).
+ Facoltativamente, specifica `ENABLED` per il campo `requireConfirmation` per richiedere la conferma all’utente prima che la funzione venga invocata. Richiedere la conferma prima di invocare la funzione può impedire all’applicazione di intraprendere azioni causate da iniezioni di prompt dannose.
+ Nell’oggetto `parameters`, ogni chiave è un nome di parametro, mappato ai relativi dettagli in un oggetto [ParameterDetail](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ParameterDetail.html).
Il formato generale di `functionSchema` è il seguente:
```
"functionSchema": [
{
"name": "string",
"description": "string",
"requireConfirmation": ENABLED | DISABLED,
"parameters": {
"": {
"type": "string" | number | integer | boolean | array,
"description": "string",
"required": boolean
},
... // up to 5 parameters
}
},
... // up to 11 functions
]
```
+ [APISchema](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_APISchema.html) può avere uno dei seguenti formati:
1. Per quanto riguarda il formato seguente, è possibile incollare direttamente come valore lo schema OpenAPI in formato YAML o JSON.
```
"apiSchema": {
"payload": "string"
}
```
1. Per quanto riguarda il formato seguente, specifica il nome del bucket Amazon S3 e la chiave oggetto in cui è archiviato lo schema OpenAPI.
```
"apiSchema": {
"s3": {
"s3BucketName": "string",
"s3ObjectKey": "string"
}
}
```
+ Per configurare il modo in cui il gruppo di operazioni gestisce la propria invocazione dopo aver ottenuto i parametri dall’utente, all’interno del campo `actionGroupExecutor` devi specificare uno dei campi indicati di seguito.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/agents-action-add.html)
+ I seguenti campi sono facoltativi:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/agents-action-add.html)
```
def create_agent_action_group(
self, name, description, agent_id, agent_version, function_arn, api_schema
):
"""
Creates an action group for an agent. An action group defines a set of actions that an
agent should carry out for the customer.
:param name: The name to give the action group.
:param description: The description of the action group.
:param agent_id: The unique identifier of the agent for which to create the action group.
:param agent_version: The version of the agent for which to create the action group.
:param function_arn: The ARN of the Lambda function containing the business logic that is
carried out upon invoking the action.
:param api_schema: Contains the OpenAPI schema for the action group.
:return: Details about the action group that was created.
"""
try:
response = self.client.create_agent_action_group(
actionGroupName=name,
description=description,
agentId=agent_id,
agentVersion=agent_version,
actionGroupExecutor={"lambda": function_arn},
apiSchema={"payload": api_schema},
)
agent_action_group = response["agentActionGroup"]
except ClientError as e:
logger.error(f"Error: Couldn't create agent action group. Here's why: {e}")
raise
else:
return agent_action_group
```
Per ulteriori informazioni, consulta [Agent per Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md).
------
# Visualizzazione di informazioni su un gruppo di operazioni
Per scoprire come visualizzare le informazioni su un gruppo di operazioni, scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi sotto indicati.
------
#### [ Console ]
**Per visualizzare le informazioni su un gruppo di operazioni**
1. Accedi alla Console di gestione AWS con un’identità IAM che disponga delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all’indirizzo [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Seleziona **Agenti** nel riquadro di navigazione a sinistra. Quindi, scegli un agente nella sezione **Agenti**.
1. Scegli un agente nella sezione **Agenti**.
1. Nella sezione **Bozza di lavoro** della pagina dei dettagli dell’agente, scegli la bozza di lavoro.
1. Nella sezione **Gruppi di operazioni**, scegli un gruppo di operazioni di cui visualizzare le informazioni.
------
#### [ API ]
Per ottenere informazioni su un gruppo di operazioni, invia una richiesta [GetAgentActionGroup](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetAgentActionGroup.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica `actionGroupId`, `agentId` e `agentVersion`.
Per elencare le informazioni sui gruppi di operazioni di un agente, invia una richiesta [ListAgentActionGroups](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListAgentActionGroups.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Specifica l’`agentId` e la `agentVersion` di cui desideri visualizzare i gruppi di operazioni. Puoi includere i seguenti parametri facoltativi:
****
| Campo | Breve descrizione |
| --- | --- |
| maxResults | Il numero massimo di risultati da restituire nella risposta. |
| nextToken | Se i risultati sono superiori al numero specificato nel campo maxResults, la risposta restituisce un valore nextToken. Per visualizzare il batch di risultati successivo, invia il valore nextToken in un’altra richiesta. |
```
def list_agent_action_groups(self, agent_id, agent_version):
"""
List the action groups for a version of an Amazon Bedrock Agent.
:param agent_id: The unique identifier of the agent.
:param agent_version: The version of the agent.
:return: The list of action group summaries for the version of the agent.
"""
try:
action_groups = []
paginator = self.client.get_paginator("list_agent_action_groups")
for page in paginator.paginate(
agentId=agent_id,
agentVersion=agent_version,
PaginationConfig={"PageSize": 10},
):
action_groups.extend(page["actionGroupSummaries"])
except ClientError as e:
logger.error(f"Couldn't list action groups. {e}")
raise
else:
return action_groups
```
Per ulteriori informazioni, consulta [Agent per Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md).
------
# Modifica di un gruppo di operazioni
Per scoprire come modificare un gruppo di operazioni, scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi sotto indicati.
------
#### [ Console ]
**Per modificare un gruppo di operazioni**
1. Accedi alla Console di gestione AWS con un’identità IAM che disponga delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all’indirizzo [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Seleziona **Agenti** nel riquadro di navigazione a sinistra. Quindi, scegli un agente nella sezione **Agenti**.
1. Scegli **Modifica in Agente Builder**.
1. Nella sezione **Gruppi di operazioni**, seleziona un gruppo di operazioni da modificare. Quindi scegliere **Edit (Modifica)**.
1. Modifica i campi esistenti in base alle esigenze. Per ulteriori informazioni, consulta [Utilizzo di gruppi di operazioni per definire le azioni che l’agente deve eseguire](agents-action-create.md).
1. Per definire lo schema per il gruppo di operazioni con l’editor di schemi in linea OpenAPI, per **Seleziona lo schema API**, scegli **Definisci con l’editor di schemi OpenAPI in linea**. Viene visualizzato uno schema di esempio che puoi modificare. Puoi configurare le seguenti opzioni:
+ Per importare uno schema esistente da Amazon S3 per modificarlo, seleziona **Importa schema**, fornisci l’URI Amazon S3 e seleziona **Importa**.
+ Per ripristinare lo schema di esempio originale, seleziona **Ripristina**, quindi accetta il messaggio visualizzato selezionando **Conferma**.
+ Per selezionare un formato diverso per lo schema, utilizza il menu a discesa denominato **JSON**.
+ Per modificare l’aspetto visivo dello schema, scegli l’icona a forma di ingranaggio situato sotto lo schema.
1. Per controllare se l’agente può utilizzare il gruppo di operazioni, seleziona **Abilita** o **Disabilita**. Utilizza questa funzione per risolvere i problemi relativi al comportamento dell’agente.
1. Per rimanere nella stessa finestra e testare la modifica, scegli **Salva**. Per tornare alla pagina dei dettagli del gruppo di operazioni, scegli **Salva ed esci**.
1. In assenza di problemi, viene visualizzato un banner che notifica la riuscita dell’operazione. In caso di problemi durante la convalida dello schema, viene visualizzato un banner di errore. Per visualizzare un elenco di errori, scegli **Mostra dettagli** nel banner.
1. Per applicare le modifiche apportate all’agente prima di testarlo, scegli **Prepara** nella finestra **Test** o nella parte superiore della pagina **Bozza di lavoro**.
------
#### [ API ]
Per modificare un gruppo di operazioni, invia una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateAgentActionGroup.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Poiché tutti i campi verranno sovrascritti, includi sia i campi che vuoi aggiornare sia quelli che vuoi mantenere invariati. Devi specificare la `agentVersion` come `DRAFT`. Per ulteriori informazioni sui campi obbligatori e facoltativi, consulta [Utilizzo di gruppi di operazioni per definire le azioni che l’agente deve eseguire](agents-action-create.md).
Per applicare le modifiche alla bozza di lavoro, invia una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Includi `agentId` nella richiesta. Le modifiche si applicano alla versione `DRAFT`, a cui fa riferimento l’alias `TSTALIASID`.
------
# Eliminazione di un gruppo di operazioni
Per scoprire come eliminare un gruppo di operazioni, scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi sotto indicati.
------
#### [ Console ]
**Per eliminare un gruppo di operazioni**
1. Accedi alla Console di gestione AWS con un’identità IAM che disponga delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock all’indirizzo [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Seleziona **Agenti** nel riquadro di navigazione a sinistra. Quindi, scegli un agente nella sezione **Agenti**.
1. Scegli **Modifica in Agente Builder**.
1. Nella sezione **Gruppi di operazioni**, scegli il pulsante di opzione accanto al gruppo di operazioni da eliminare.
1. Viene visualizzata una finestra di dialogo che ti informa delle conseguenze dell’eliminazione. Per confermare che desideri eliminare il gruppo di operazioni, immetti **delete** nel campo di input, quindi seleziona **Elimina**.
1. Al termine dell’eliminazione, viene visualizzato un banner che notifica la riuscita dell’operazione.
1. Per applicare le modifiche apportate all’agente prima di testarlo, scegli **Prepara** nella finestra **Test** o nella parte superiore della pagina **Bozza di lavoro**.
------
#### [ API ]
Per eliminare un gruppo di operazioni, invia una richiesta [DeleteAgentActionGroup](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteAgentActionGroup.html). Specifica l’`actionGroupId` e l’`agentId` e la `agentVersion` da cui eliminarlo. Per impostazione predefinita, il parametro `skipResourceInUseCheck` è `false` e l’eliminazione si arresta se la risorsa è in uso. Se imposti `skipResourceInUseCheck` su `true`, la risorsa verrà eliminata anche se è in uso.
Per applicare le modifiche alla bozza di lavoro, invia una richiesta [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareAgent.html) con un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Includi `agentId` nella richiesta. Le modifiche si applicano alla versione `DRAFT`, a cui fa riferimento l’alias `TSTALIASID`.
------