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à.
# Crea un flusso di lavoro AI end-to-end generativo con Amazon Bedrock Flows
Amazon Bedrock Flows ti offre la possibilità di utilizzare modelli di base supportati (FMs) per creare flussi di lavoro collegando prompt, modelli di base e altri servizi per creare soluzioni. AWS end-to-end
Con i flussi, puoi creare rapidamente flussi di lavoro di intelligenza artificiale generativa complessi utilizzando un visual builder, integrarti facilmente con le offerte di Amazon Bedrock come FMs le knowledge base e altri AWS servizi, ad esempio AWS Lambda trasferendo dati tra di loro, e distribuire flussi di lavoro immutabili per passare dal test alla produzione in pochi clic.
Per ulteriori informazioni su Amazon Bedrock Flows, consulta le seguenti risorse:
+ I prezzi di Amazon Bedrock Flows dipendono dalle risorse utilizzate. Ad esempio, se invochi un flusso con un nodo prompt che utilizza un modello Amazon Titan, ti sarà addebitato un importo per l’invocazione di quel modello. Per maggiori informazioni, consulta [Prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
+ Per vedere le quote per i flussi, consulta gli [endpoint e le quote di Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html) in Riferimenti generali di AWS.
Di seguito sono riportati alcuni esempi di attività per cui è possibile creare un flusso in Amazon Bedrock:
+ **Creare e inviare un invito via e-mail**: crea un flusso che collega un nodo prompt, un nodo knowledge base e un nodo funzione Lambda. Inserisci il seguente prompt per generare il testo di un’e-mail: **Send invite to John Smith’s extended team for in-person documentation read for an hour at 2PM EST next Tuesday**. Dopo aver elaborato il prompt, il flusso interroga una knowledge base per cercare gli indirizzi e-mail del team esteso di John Smith, quindi invia l’input a una funzione Lambda per inviare l’invito a tutti i membri del team in elenco.
+ **Risolvere i problemi utilizzando il messaggio di errore e l’ID della risorsa che causa l’errore**: il flusso cerca le possibili cause dell’errore da una knowledge base della documentazione, estrae i log di sistema e altre informazioni pertinenti sulla risorsa e aggiorna le configurazioni e i valori difettosi per la risorsa.
+ **Generare report**: crea un flusso per generare metriche per i prodotti principali. Il flusso cerca le metriche di vendita in un database, aggrega le metriche, genera un report di riepilogo per i principali acquisti di prodotti e pubblica il report sul portale specificato.
+ **Inserire dati da un set di dati specificato**: inserisci un prompt come il seguente: **Start ingesting new datasets added after 3/31 and report failures**. Il flusso inizia a preparare i dati per l’importazione e continua a inviare report sullo stato. Dopo aver completato la preparazione dei dati, il flusso avvia il processo di importazione filtrando i dati non validi. Dopo aver completato l’importazione dei dati, il flusso riepiloga gli errori e pubblica un rapporto sugli errori.
Flows for Amazon Bedrock semplifica il collegamento di modelli di base (FMs), prompt e altri AWS servizi per creare, testare ed eseguire rapidamente i flussi. Puoi gestire i flussi utilizzando il visual builder nella console Amazon Bedrock o tramite. APIs
Le operazioni generali per creare, testare e distribuire un flusso sono le seguenti:
**Creare il flusso:**
1. Specifica il nome, la descrizione e le autorizzazioni IAM appropriate.
1. Progetta il flusso decidendo i nodi da utilizzare.
1. Crea o definisci tutte le risorse necessarie per ciascun nodo. Ad esempio, se intendi utilizzare una AWS Lambda funzione, definisci le funzioni necessarie affinché il nodo completi la sua attività.
1. Aggiungi nodi al flusso, configurali e crea connessioni tra i nodi collegando l’output di un nodo all’input di un altro nodo nel flusso.
**Testare il flusso:**
1. Prepara il flusso in modo che le ultime modifiche si applichino alla *bozza di lavoro* del flusso, una versione del flusso da utilizzare per testare e aggiornare il flusso in modo iterativo
1. Testa il flusso invocandolo con input di esempio per vedere gli output che produce.
1. Quando la configurazione di un flusso ti soddisfa, puoi crearne un’istantanea pubblicando una *versione*. La versione conserva la definizione del flusso come si presentava al momento della creazione. Le versioni sono immutabili perché fungono da istantanea del flusso al momento della creazione.
**Implementare il flusso.**
1. Crea un alias che punta alla versione del flusso da utilizzare nell’applicazione.
1. Configura l’applicazione per effettuare richieste `InvokeFlow` all’alias. Se devi ripristinare una versione precedente o eseguire l’upgrade a una versione più recente, puoi modificare la configurazione di routing dell’alias.
**Topics**
+ [Come funziona Amazon Bedrock Flows](flows-how-it-works.md)
+ [Regioni e modelli supportati per i flussi](flows-supported.md)
+ [Prerequisiti per Amazon Bedrock Flows](flows-prereq.md)
+ [Creare e progettare un flusso in Amazon Bedrock](flows-create.md)
+ [Visualizzare informazioni sui flussi in Amazon Bedrock](flows-view.md)
+ [Modificare un flusso in Amazon Bedrock](flows-modify.md)
+ [Includere i guardrail nel flusso in Amazon Bedrock](flows-guardrails.md)
+ [Testare un flusso in Amazon Bedrock](flows-test.md)
+ [Eseguire flussi di Amazon Bedrock in modo asincrono con le esecuzioni del flusso](flows-create-async.md)
+ [Implementare un flusso nella tua applicazione utilizzando versioni e alias](flows-deploy.md)
+ [Richiama una AWS Lambda funzione da un flusso Amazon Bedrock in un altro account AWS](flow-cross-account-lambda.md)
+ [Conversare con un flusso Amazon Bedrock](flows-multi-turn-invocation.md)
+ [Eseguire esempi di codice Amazon Bedrock Flows](flows-code-ex.md)
+ [Eliminare un flusso in Amazon Bedrock](flows-delete.md)
# Come funziona Amazon Bedrock Flows
Amazon Bedrock Flows consente di creare flussi di lavoro di IA generativa collegando nodi, ognuno dei quali corrisponde a una fase del flusso che invoca Amazon Bedrock o una risorsa correlata. Per definire gli input e gli output dai nodi, usi le espressioni per specificare come viene interpretato l’input. Per comprendere meglio questi concetti, esamina i seguenti argomenti:
**Topics**
+ [Definizioni principali per Amazon Bedrock Flows](key-definitions-flow.md)
+ [Usare le espressioni per definire gli input estraendo la parte pertinente di un intero input in Amazon Bedrock Flows](flows-expressions.md)
+ [Tipi di nodo per il flusso](flows-nodes.md)
# Definizioni principali per Amazon Bedrock Flows
Di seguito vengono elencati i concetti di base di Amazon Bedrock Flows.
+ **Flusso**: un flusso è un costrutto costituito da un nome, una descrizione, autorizzazioni, una raccolta di nodi e le connessioni tra i nodi. Quando un flusso viene invocato, l’input dell’invocazione viene inviato attraverso ogni nodo del flusso fino a raggiungere un nodo di output. La risposta dell’invocazione restituisce l’output finale.
+ **Nodo**: un nodo è un passaggio all’interno di un flusso. Per ogni nodo, se ne configura il nome, la descrizione, l’input, l’output e qualsiasi configurazione aggiuntiva. La configurazione di un nodo varia in base al tipo del nodo stesso. Per ulteriori informazioni sui diversi tipi di nodi, consulta [Tipi di nodo per il flusso](flows-nodes.md).
+ **Connessione**: in Amazon Bedrock Flows esistono due tipi di connessioni.
+ Una **connessione dati** viene stabilita tra l’output di un nodo (*nodo di origine*) e l’input di un altro nodo (*nodo di destinazione*) e consente di inviare dati da un nodo upstream a un nodo downstream. Nella console Amazon Bedrock, le connessioni dati sono linee grigie continue.
+ Una **connessione condizionale** viene stabilita tra una condizione in un nodo di condizione e un nodo downstream e consente di inviare i dati dal nodo che precede quello di condizione a un nodo downstream se la condizione è soddisfatta. Nella console Amazon Bedrock, le connessioni condizionali sono linee viola tratteggiate.
+ **Espressioni**: un’espressione definisce il modo in cui estrarre un singolo valore di input dall’intero input di un nodo. Per informazioni sulla scrittura delle espressioni, consulta [Usare le espressioni per definire gli input estraendo la parte pertinente di un intero input in Amazon Bedrock FlowsDefinire gli input con le espressioni](flows-expressions.md).
+ **Generatore di flussi**: strumento nella console Amazon Bedrock che consente di creare e modificare flussi tramite un’interfaccia visiva. in cui è possibile trascinare i nodi e configurarne input e output per definire il flusso.
+ Nelle sezioni seguenti, useremo i termini seguenti:
+ **Input completo**: intero input inviato dal nodo precedente a quello corrente.
+ **Upstream**: si riferisce ai nodi che si trovano all’inizio del flusso.
+ **Downstream**: si riferisce ai nodi successivi nel flusso.
+ **Input**: un nodo può avere più input. Le espressioni vengono utilizzate per estrarre le parti pertinenti dell’input completo da utilizzare per ogni singolo input. Nel generatore di flussi della console Amazon Bedrock, un input appare come un cerchio sul bordo sinistro di un nodo. Connettere ogni input all’output pertinente di un nodo upstream.
+ **Output**: un nodo può avere più output. Nel generatore di flussi della console Amazon Bedrock, un output viene visualizzato come un cerchio sul bordo destro di un nodo. Connettere ogni uscita ad almeno un input in un nodo downstream.
+ **Ramo**: se un output di un nodo viene inviato a più di un nodo o se è incluso un nodo condizionale, il percorso di un flusso viene suddiviso in più rami. Ogni ramo può potenzialmente produrre un altro output nella risposta all’invocazione del flusso.
# Usare le espressioni per definire gli input estraendo la parte pertinente di un intero input in Amazon Bedrock Flows
Quando configuri gli input per un nodo, devi definirlo in relazione all’intero input che entrerà nel nodo. L’intero input può essere una stringa, un numero, un valore booleano, un array o un oggetto. Per definire un input in relazione all’intero input, devi utilizzare un sottoinsieme di espressioni supportate basate su [JsonPath](https://github.com/json-path/JsonPath). Tutte le espressioni devono iniziare con `$.data`, che si riferisce all’intero input. Per l’utilizzo delle espressioni, tieni presente quanto segue:
+ Se l’intero input è una stringa, un numero o un valore booleano, l’unica espressione che puoi usare per definire un singolo input è `$.data`
+ Se l’intero input è un array o un oggetto, puoi estrarne una parte per definire un singolo input.
Come esempio per capire come usare le espressioni, supponiamo che l’intero input sia il seguente oggetto JSON:
```
{
"animals": {
"mammals": ["cat", "dog"],
"reptiles": ["snake", "turtle", "iguana"]
},
"organisms": {
"mammals": ["rabbit", "horse", "mouse"],
"flowers": ["lily", "daisy"]
},
"numbers": [1, 2, 3, 5, 8]
}
```
Puoi utilizzare le seguenti espressioni per estrarre una parte dell’input (gli esempi si riferiscono a ciò che verrebbe restituito dall’oggetto JSON precedente):
****
| Espressione | Significato | Esempio | Risultato dell’esempio |
| --- | --- | --- | --- |
| \$1.data | L’intero input. | \$1.data | L’intero oggetto |
| .name | Il valore di un campo detto name in un oggetto JSON. | \$1.data.numbers | [1, 2, 3, 5, 8] |
| [int] | Il membro all’indice specificato da int in un array. | \$1.data.animals.reptiles[2] | iguana |
| [int1, int2, ...] | I membri degli indici specificati da ciascun int in un array. | \$1.data.numbers [0, 3] | [1, 5] |
| [int1:int2] | Un array costituito dagli elementi negli indici compresi tra int1 (inclusivo) e int2 (esclusivo) in un array. L’omissione di int1 o int2 equivale a contrassegnare l’inizio o la fine dell’array. | \$1.data.organisms.mammals[1:] | [“cavallo”, “topo”] |
| \$1 | Un carattere jolly utilizzabile al posto di name o int. Se sono presenti più risultati, i risultati vengono restituiti in un array. | \$1.data.\$1.mammals | [[“gatto”, “cane”], [“coniglio”, “cavallo”, “topo”]] |
# Tipi di nodo per il flusso
Amazon Bedrock Flows offre i seguenti tipi di nodo per creare il flusso. Quando si configura un nodo, è necessario compilare i campi riportati di seguito:
+ Nome: inserisci un nome per il nodo.
+ Tipo: nella console, trascina il tipo di nodo da utilizzare. Nell'API, usa il `type` campo e il corrispondente [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)nel `configuration` campo.
+ Input: fornisci le seguenti informazioni per ciascun input:
+ Nome: un nome per l’input. Alcuni nodi hanno nomi o tipi predefiniti che è necessario utilizzare. Per sapere quali hanno nomi predefiniti, consulta [Tipi di nodi logici](#flows-nodes-logic-table).
+ Espressione: consente di definire la parte dell’intero input da utilizzare come input individuale. Per ulteriori informazioni, consulta [Usare le espressioni per definire gli input estraendo la parte pertinente di un intero input in Amazon Bedrock FlowsDefinire gli input con le espressioni](flows-expressions.md).
+ Tipo: il tipo di dati per l’input. Quando questo nodo viene raggiunto durante il runtime, Amazon Bedrock applica l’espressione all’intero input e verifica che il risultato corrisponda al tipo di dati.
+ Output: fornisce le seguenti informazioni per ciascun output:
+ Nome: il nome dell’output. Alcuni nodi hanno nomi o tipi predefiniti che è necessario utilizzare. Per sapere quali hanno nomi predefiniti, consulta [Tipi di nodi logici](#flows-nodes-logic-table).
+ Tipo: il tipo di dati per l’output. Quando questo nodo viene raggiunto durante il runtime, Amazon Bedrock verifica che l’output del nodo corrisponda al tipo di dati.
+ Configurazione: nella console puoi definire i campi specifici del nodo all’inizio del nodo stesso. Nell'API, utilizza l'appropriato [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)e compila i relativi campi.
Ogni tipo di nodo è descritto di seguito ed è fornita la relativa struttura nell’API. Espandi una sezione per saperne di più sul tipo di nodo in questione.
## Nodi per il controllo della logica di flusso
Utilizzare i seguenti tipi di nodo per controllare la logica di flusso.
### Nodo di input del flusso
Ogni flusso contiene un solo nodo di input del flusso e deve iniziare da esso. Il nodo di input del flusso ottiene il `content` dalla richiesta `InvokeFlow`, convalida il tipo di dati e lo invia al nodo successivo.
Di seguito viene illustrata la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto di input nell'API:
```
{
"name": "string",
"type": "Input",
"outputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
}
],
"configuration": {
"input": CONTEXT-DEPENDENT
}
}
```
### Nodo di output del flusso
Un nodo di output del flusso estrae i dati di input dal nodo precedente, in base all’espressione definita, e li restituisce. Nella console, l’output è la risposta restituita dopo aver scelto **Esegui** nella finestra di test. Nell’API, l’output viene restituito nel campo `content` di `flowOutputEvent` della risposta `InvokeFlow`. Un flusso può avere più nodi di output.
Un flusso può avere più nodi di output del flusso, se vi sono più rami nel flusso.
Quanto segue mostra la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto di output:
```
{
"name": "string",
"type": "Output",
"inputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"output": CONTEXT-DEPENDENT
}
}
```
### Nodo di condizione
Un nodo di condizione invia i dati dal nodo precedente a nodi diversi, in base alle condizioni definite. Un nodo di condizione può ricevere più input.
Per vedere un esempio, consulta [Creare un flusso con un nodo di condizione](flows-ex-condition.md).
**Come definire un nodo di condizione**
1. Aggiungi tutti gli input necessari per valutare le condizioni che intendi specificare.
1. Inserisci un nome per ogni input, specifica il tipo previsto e scrivi un’espressione per estrarre la parte rilevante dell’intero input.
1. Collega ogni input all’output pertinente di un nodo a monte.
1. Aggiungi tutte le condizioni necessarie.
1. Per ogni condizione:
1. Inserisci un nome per la condizione.
1. Utilizza operatori relazionali e logici per definire una condizione che confronti gli input tra loro o con una costante.
**Nota**
Le condizioni vengono valutate nell’ordine specificato. Se viene soddisfatta più di una condizione, ha precedenza quella precedente.
1. Collega ciascuna condizione al nodo a valle a cui inviare i dati quando la condizione è soddisfatta.
#### Espressioni di condizione
Per definire una condizione, fai riferimento a un input tramite il relativo nome e confrontalo con un valore utilizzando uno dei seguenti operatori relazionali.
****
| Operatore | Significato | Tipi di dati supportati | Esempio di utilizzo | Esempio di significato |
| --- | --- | --- | --- | --- |
| == | Uguale a (anche il tipo di dati deve corrispondere) | String, Number, Boolean | A == B | Se A è uguale a B |
| \$1= | Non uguale a | String, Number, Boolean | A \$1= B | Se A non è uguale a B |
| > | Greater than | Numero | A > B | Se A è maggiore di o uguale a B |
| >= | Maggiore o uguale a | Numero | A >= B | Se A è maggiore di o uguale a B |
| < | Less than | Numero | A < B | Se A è minore di B |
| <= | Minore o uguale a | Numero | A <= B | Se A è minore o uguale a B |
È possibile confrontare gli input con altri input o con una costante in un’espressione condizionale. Ad esempio, se è presente un input numerico chiamato `profit` e un altro denominato `expenses`, sia **profit > expenses** che **profit <= 1000** sono due espressioni valide.
È possibile utilizzare gli operatori logici seguenti per combinare espressioni e creare condizioni più complesse. Si consiglia di utilizzare le parentesi per evitare ambiguità nel raggruppamento delle espressioni:
****
| Operatore | Significato | Esempio di utilizzo | Esempio di significato |
| --- | --- | --- | --- |
| and | Entrambe le espressioni sono vere | (A < B) and (C == 1) | Se entrambe le espressioni sono vere: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-nodes.html) |
| or | Almeno un’espressione è vera | (A \$1= 2) or (B > C) | Se una delle due espressioni è vera: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-nodes.html) |
| not | L’espressione non è vera | not (A > B) | Se A non è maggiore di B (equivalente a A <= B) |
Nell'API, definisci quanto segue nel `definition` campo quando invii una [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)or:
1. Un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto condizionale nell'`nodes`array. Il formato generale è il seguente (notare che i nodi di condizione non includono`outputs`):
```
{
"name": "string",
"type": "Condition",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"condition": {
"conditions": [
{
"name": "string",
"expression": "string"
},
...
]
}
}
}
```
1. Per ogni input nel nodo di condizione, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)oggetto nell'`connections`array. Includi un [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)oggetto nel `configuration` campo dell'`FlowConnection`oggetto. Il formato generale dell’oggetto `FlowConnection` è il seguente:
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Data",
"configuration": {
"data": {
"sourceOutput": "string",
"expression": "string"
}
}
}
```
1. Per ogni condizione (inclusa la condizione predefinita) nel nodo condizione, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)oggetto nell'`connections`array. Includi un [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)oggetto nel `configuration` campo dell'`FlowConnection`oggetto. Il formato generale dell'[FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)oggetto è il seguente:
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Conditional",
"configuration": {
"conditional": {
"condition": "string"
}
}
}
```
Utilizza gli operatori relazionali e logici per definire la `condition` che collega questo nodo di condizione `source` a un nodo `target` a valle. Per la condizione predefinita, specifica la condizione come **default**.
### Nodo iteratore
Un nodo iteratore accetta un array e restituisce i relativi elementi in modo iterativo come output al nodo a valle. Gli input del nodo iteratore vengono elaborati uno per uno e non in parallelo. Il nodo di output del flusso restituisce il risultato finale per ogni input in una risposta distinta. Puoi utilizzare anche un nodo raccoglitore a valle del nodo iteratore per raccogliere le risposte iterate e restituirle come array, insieme alle dimensioni dell’array.
Quanto segue mostra la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto iteratore:
```
{
"name": "string",
"type": "Iterator",
"inputs": [
{
"name": "array",
"type": "Array",
"expression": "string"
}
],
"outputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
},
{
"name": "arraySize",
"type": "Number"
}
],
"configuration": {
"iterator": CONTEXT-DEPENDENT
}
}
```
### Nodo di raccolta
Un nodo di raccolta accetta un input iterato, oltre alla dimensione dell’array, e lo restituisce come array. Puoi utilizzare un nodo di raccolta a valle di un nodo iteratore per raccogliere gli elementi iterati dopo averli inviati attraverso alcuni nodi.
Di seguito viene illustrata la struttura generale di un oggetto raccoglitore [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html):
```
{
"name": "string",
"type": "Collector",
"inputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "arraySize",
"type": "Number"
}
],
"outputs": [
{
"name": "collectedArray",
"type": "Array"
},
],
"configuration": {
"collector": CONTEXT-DEPENDENT
}
}
```
### DoWhile nodo loop
Un nodo DoWhile loop esegue ripetutamente una sequenza di nodi finché una condizione specificata rimane vera. Il loop viene eseguito almeno una volta prima di valutare la condizione, il che lo rende ideale per gli scenari in cui è necessario eseguire un’azione e quindi verificare se deve essere ripetuta in base al risultato.
Il nodo DoWhile loop prende i dati di input e li trasmette attraverso il corpo del loop. Dopo ogni iterazione, la condizione viene valutata per determinare se continuare il loop o uscire. Il loop continua finché la condizione restituisce true o `maxIterations` non viene superato.
Quanto segue mostra la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto DoWhile loop:
```
{
"name": "string",
"type": "DoWhile",
"inputs": [
{
"name": "loopInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"outputs": [
{
"name": "loopOutput",
"type": "String | Number | Boolean | Object | Array"
},
{
"name": "iterationCount",
"type": "Number"
}
],
"configuration": {
"doWhile": {
"condition": "string",
"maxIterations": "number"
}
}
}
```
Nella configurazione:
+ `condition`: un’espressione booleana che determina se continuare il loop. Utilizza gli stessi operatori relazionali e logici dei nodi di condizione. La condizione viene valutata dopo ogni iterazione.
+ `maxIterations`: il numero massimo di iterazioni. Il valore predefinito è 10. È necessario specificare un numero positivo. Questo parametro consente di evitare loop infiniti.
**Nota**
Il parametro `maxIterations` ha un valore predefinito di 10 e accetta solo numeri positivi. Il loop termina quando la condizione restituisce false o viene raggiunto il numero massimo di iterazioni.
## Nodi per la gestione dei dati nel flusso
Utilizza i seguenti tipi di nodi per gestire i dati nel flusso:
### Nodo prompt
Un nodo del prompt definisce un prompt da utilizzare nel flusso. È possibile utilizzare un prompt di Gestione dei prompt o definirne uno in linea nel nodo. Per ulteriori informazioni, consulta [Creare e archiviare prompt riutilizzabili con Gestione dei prompt in Amazon Bedrock](prompt-management.md).
Per vedere un esempio, consulta [Provare flussi di esempio](flows-ex.md).
Gli input del nodo del prompt sono valori per compilare le variabili. L’output è la risposta generata dal modello.
Di seguito viene illustrata la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto prompt:
```
{
"name": "string",
"type": "prompt",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
],
"configuration": {
"prompt": {
"sourceConfiguration": [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html) object (see below),
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
L'[PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)oggetto dipende se si utilizza un prompt di Prompt management o se lo si definisce in linea:
+ Se utilizzi un prompt di Gestione dei prompt, l’oggetto deve avere la seguente struttura generale:
```
{
"resource": {
"promptArn": "string"
}
}
```
+ Se definisci un prompt in linea, segui le indicazioni per la definizione di una variante nella scheda API di [Creare un prompt utilizzando Gestione prompt](prompt-management-create.md) (tuttavia, in questo oggetto non è presente alcun campo `name`). L’oggetto che usi deve avere la seguente struttura generale:
```
{
"inline": {
"modelId": "string",
"templateType": "TEXT",
"templateConfiguration": {
"text": {
"text": "string",
"inputVariables": [
{
"name": "string"
},
...
]
}
},
"inferenceConfiguration": {
"text": {
"maxTokens": int,
"stopSequences": ["string", ...],
"temperature": float,
"topP": float
}
},
"additionalModelRequestFields": {
"key": "value",
...
}
}
}
```
Per applicare un guardrail di Guardrail per Amazon Bedrock al tuo prompt o alla risposta che genera, includi il campo `guardrailConfiguration` e specifica l’ID o l’ARN del guardrail nel campo `guardrailIdentifier` e la versione del guardrail nel campo `guardrailVersion`.
### Nodo dell’agente
Un nodo agente consente di inviare un prompt a un agente, che orchestra tra le risorse associate per identificare FMs ed eseguire azioni per un utente finale. Per ulteriori informazioni, consulta [Automazione delle attività nella propria applicazione utilizzando agenti IA](agents.md).
Nella configurazione, specifica il nome della risorsa Amazon (ARN) dell’alias dell’agente da utilizzare. Gli input nel nodo sono il prompt dell’agente e qualsiasi [attributo di prompt o sessione](agents-session-state.md) associato. Il nodo restituisce la risposta dell’agente come output.
Un nodo dell’agente può supportare invocazioni a più turni, abilitando conversazioni interattive tra gli utenti e l’agente durante l’esecuzione del flusso. Quando un nodo dell’agente richiede informazioni o chiarimenti aggiuntivi, può mettere in pausa l’esecuzione del flusso e richiedere un input specifico all’utente. Una volta che l’utente fornisce le informazioni richieste, il nodo dell’agente continua l’elaborazione con il nuovo input. Questa operazione continua finché il nodo dell’agente non dispone di tutte le informazioni necessarie per completare l’esecuzione
Di seguito viene illustrata la struttura generale di un oggetto agente: [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)
```
{
"name": "string",
"type": "Agent",
"inputs": [
{
"name": "agentInputText"
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "promptAttributes"
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes"
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "agentResponse",
"type": "String"
}
],
"configuration": {
"agent": {
"agentAliasArn": "string"
}
}
}
```
### Nodo della knowledge base
Un nodo della knowledge base consente di inviare una query a una knowledge base di Knowledge Base per Amazon Bedrock. Per ulteriori informazioni, consulta [Recupero di dati e generazione di risposte di IA con Knowledge Base per Amazon Bedrock](knowledge-base.md).
Nella configurazione, fornisci almeno `knowledgeBaseId`. È possibile includere i campi riportati di seguito, a seconda del caso d’uso:
+ `modelId`: includi un [ID modello](models-supported.md) da utilizzare se desideri generare una risposta in base ai risultati recuperati. Per restituire i risultati recuperati come array, ometti l’ID modello.
+ `guardrailConfiguration`: includi l’ID o l’ARN del guardrail, definito in Guardrail per Amazon Bedrock nel campo `guardrailIdentifier` e la versione del guardrail nel campo `guardrailVersion`.
**Nota**
Guardrail può essere applicato solo quando si utilizza `RetrieveAndGenerate` in un nodo della knowledge base.
L’input nel nodo è la query della knowledge base. L’output è la risposta del modello, sotto forma di stringa, o un array dei risultati recuperati.
Di seguito viene illustrata la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto della knowledge base:
```
{
"name": "string",
"type": "KnowledgeBase",
"inputs": [
{
"name": "retrievalQuery",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "retrievalResults" | "outputText",
"type": "Array | String"
}
],
"configuration": {
"knowledgeBase": {
"knowledgeBaseId": "string",
"modelId": "string",
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
### Nodo di storage S3
Un nodo di storage S3 consente di archiviare i dati nel flusso verso un bucket Amazon S3. Nella configurazione, specifichi il bucket S3 da utilizzare per l’archiviazione di dati. Gli input nel nodo sono il contenuto da archiviare e la [chiave dell’oggetto.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html) Il nodo restituisce l’URI della posizione S3 come output.
Di seguito viene mostrata la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto di storage S3:
```
{
"name": "string",
"type": "Storage",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Uri",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### Nodo di recupero S3
Un nodo di recupero S3 ti consente di recuperare i dati da una posizione Amazon S3 per introdurli nel flusso. Nella configurazione, specifichi il bucket S3 da cui recuperare i dati. L’input nel nodo è la [chiave oggetto.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html) Il nodo restituisce il contenuto nella posizione S3 come output.
**Nota**
Attualmente, i dati nella posizione S3 devono essere una stringa con codifica UTF-8.
Di seguito viene mostrata la struttura generale di un oggetto di recupero [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)S3:
```
{
"name": "string",
"type": "Retrieval",
"inputs": [
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Content",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### Nodo della funzione Lambda
Un nodo della funzione Lambda consente di chiamare una funzione Lambda in cui è possibile definire il codice per eseguire la logica aziendale. Quando includi un nodo Lambda in un flusso, Amazon Bedrock invia un evento di input alla funzione Lambda specificata.
Nella configurazione, specifica il nome della risorsa Amazon (ARN) della funzione Lambda. Definisci gli input da inviare nell’evento di input Lambda. Puoi scrivere codice basato su questi input e definire cosa restituisce la funzione. La risposta della funzione viene restituita nell’output.
Di seguito viene mostrata la struttura generale di un oggetto funzione [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Lambda:
```
{
"name": "string",
"type": "LambdaFunction",
"inputs": [
{
"name": "codeHookInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "functionResponse",
"type": "String | Number | Boolean | Object | Array"
}
],
"configuration": {
"lambdaFunction": {
"lambdaArn": "string"
}
}
}
```
#### Evento di input Lambda per un flusso
L’evento di input inviato a una funzione Lambda in un nodo Lambda ha il seguente formato:
```
{
"messageVersion": "1.0",
"flow": {
"flowArn": "string",
"flowAliasArn": "string"
},
"node": {
"name": "string",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string",
"value": ...
},
...
]
}
}
```
I campi per ogni input corrispondono ai campi specificati durante la definizione del nodo Lambda, mentre il valore del campo `value` viene popolato con l’intero input nel nodo dopo essere stato risolto dall’espressione. Ad esempio, se l’intero input nel nodo è `[1, 2, 3]` e l’espressione è `$.data[1]`, il valore inviato nell’evento di input alla funzione Lambda sarebbe `2`.
Per ulteriori informazioni, consulta [Concetti Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) nella [Guida per gli sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
#### Risposta Lambda per un flusso
Quando scrivi una funzione Lambda, definisci la risposta da essa restituita. Questa risposta viene restituita al flusso come output del nodo Lambda.
### Nodo di codice inline
Un nodo di codice inline consente di scrivere ed eseguire codice direttamente nel flusso, abilitando trasformazioni di dati, logica personalizzata e integrazioni senza utilizzare una funzione Lambda esterna. Quando includi un nodo di codice in linea nel tuo flusso, Amazon Bedrock esegue il codice in un ambiente isolato e AWS gestito, non condiviso con nessuno e senza accesso a Internet.
**Nota**
Il nodo del codice inline è disponibile in anteprima per Amazon Bedrock ed è soggetto a modifica.
Nella configurazione del nodo, specifica il codice da eseguire insieme al linguaggio di programmazione (attualmente `Python_3` è l’unica opzione). Definisci gli input a cui il tuo codice può accedere come variabili. Il risultato dell’ultima riga eseguita nel codice viene restituito come output del nodo.
L'esempio seguente mostra la struttura generale di un oggetto di codice in linea: [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)
```
{
"name": "string",
"type": "InlineCode",
"inputs": [{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [{
"name": "response",
"type": "String | Number | Boolean | Object | Array"
}],
"configuration": {
"inlineCode": {
"code": "string",
"language": "Python_3"
}
}
}
```
#### Considerazioni su quando utilizzare i nodi di codice inline
Quando usi i nodi di codice inline nel flusso, tieni in considerazione quanto segue:
**Importante**
Ti consigliamo di testare il codice prima di aggiungerlo a un nodo di codice inline.
+ I nodi di codice inline non sono supportati nell’esecuzione [asincrona del flusso](flows-create-async.md).
+ Attualmente, l’unico linguaggio di programmazione supportato dai nodi di codice inline è Python 3.12 (`Python_3)`.
+ Il codice inline si comporta come una sessione Python interattiva. Solo il risultato dell’ultima riga eseguita viene acquisito e restituito come output del nodo.
+ L’output della console Python (ad esempio l’output dalla funzione `print`) non viene acquisito.
+ Gli input per il nodo di codice inline sono disponibili come variabili Python nel codice. Usa il nome esatto dell’input del nodo per farvi riferimento.
+ Configura correttamente i tipi di input e output per evitare errori di runtime. È possibile configurare fino a cinque input per nodi.
+ Puoi avere fino a cinque nodi di codice inline per flusso.
+ È possibile avere un massimo di 25 nodi di codice inline in esecuzione per Account AWS.
+ Il tuo codice non può superare i 5 MB.
#### Input del nodo di codice inline
Gli input che definisci per il nodo di codice inline sono disponibili come variabili Python nel codice. Ad esempio, se definisci un input denominato `userData`, puoi accedervi direttamente nel codice come `userData`.
Il valore di ogni input viene compilato in base all’espressione definita. Ad esempio, se l’input per il nodo è `{"name": "John", "age": 30}` e l’espressione è `$.name`, il valore della variabile di input sarebbe `"John"`.
#### Output del nodo di codice inline
Il risultato dell’ultima riga eseguita nel codice viene restituito come output del nodo di codice inline. Questo output è disponibile per i nodi successivi del flusso.
Ad esempio, il codice seguente restituisce un dizionario come output del nodo:
```
# Process input data
result = {"processed": True, "data": userData}
# The last line's result is returned as the node output
result
```
### Nodo Lex
**Nota**
Il nodo Lex si basa sul servizio Amazon Lex, che può archiviare e utilizzare i contenuti dei clienti per lo sviluppo e il miglioramento continuo di altri AWS servizi. In qualità di AWS cliente, puoi scegliere di non far archiviare o utilizzare i tuoi contenuti per migliorare il servizio. Per informazioni su come implementare una policy di non adesione per Amazon Lex, consulta le [policy di non adesione ai servizi di IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).
Un nodo Lex consente di chiamare un bot Amazon Lex per elaborare un enunciato utilizzando l’elaborazione del linguaggio naturale e identificare un intento, in base alla definizione del bot. Per ulteriori informazioni, consulta [Guida per gli sviluppatori di Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
Nella configurazione, specifica il nome della risorsa Amazon (ARN) dell’alias del bot da utilizzare e della locale da utilizzare. Gli input nel nodo sono l’enunciato e gli eventuali [attributi di richiesta](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) o [attributi di sessione associati](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html). Il nodo restituisce l’intento identificato come output.
**Nota**
Attualmente, il nodo Lex non supporta le conversazioni a più turni. Un nodo Lex può elaborare un solo enunciato.
Quanto segue mostra la struttura generale di un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)oggetto Lex:
```
{
"name": "string",
"type": "Lex",
"inputs": [
{
"name": "inputText",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "requestAttributes",
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes",
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "predictedIntent",
"type": "String"
}
],
"configuration": {
"lex": {
"botAliasArn": "string",
"localeId": "string"
}
}
}
```
## Tabelle riassuntive per i tipi di nodi
Le tabelle seguenti riassumono gli input e gli output consentiti per ogni tipo di nodo. Tenere presente quanto segue:
+ Se un nome è contrassegnato come **Any**, puoi fornire qualsiasi stringa come nome. In caso contrario, dovrai usare il valore specificato nella tabella.
+ Se un tipo è contrassegnato come **Any**, è possibile specificare uno dei seguenti tipi di dati: String, Number, Boolean, Object, Array. In caso contrario, dovrai usare il tipo specificato nella tabella.
+ È possibile definire più input per i nodi **Condizione**, **Prompt**, **Funzione Lambda** e **Codice inline**.
**Tipi di nodi logici**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-nodes.html)
**Tipi di nodi di elaborazione dei dati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-nodes.html)
# Regioni e modelli supportati per i flussi
Amazon Bedrock Flows è supportato nei seguenti paesi: Regioni AWS
+ ap-northeast-1
+ ap-northeast-2
+ ap-northeast-3
+ ap-south-1
+ ap-south-2
+ ap-southeast-1
+ ap-southeast-2
+ ca-central-1
+ eu-central-1
+ eu-central-2
+ eu-north-1
+ eu-south-1
+ eu-south-2
+ eu-west-1
+ eu-west-2
+ eu-west-3
+ sa-east-1
+ us-east-1
+ us-east-2
+ us-gov-east-1
+ us-gov-west-1
+ us-west-2
I modelli supportati in Amazon Bedrock Flows dipendono dai nodi utilizzati nel flusso:
+ Nodo prompt: puoi utilizzare Gestione dei prompt con qualsiasi modello di testo supportato per l’API [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html). Per un elenco dei modelli supportati, consulta [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md).
+ Nodo agente: per un elenco di modelli supportati, consulta [Regioni supportate per Agent per Amazon Bedrock](agents-supported.md).
+ Nodo knowledge base: per un elenco dei modelli supportati, consulta [Regioni e modelli supportati per Knowledge Base per Amazon Bedrock](knowledge-base-supported.md).
Per una tabella dei modelli supportati e delle relative Regioni, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
# Prerequisiti per Amazon Bedrock Flows
Prima di creare un flusso, esamina i seguenti prerequisiti e determina quali soddisfare:
1. Definisci o crea risorse per uno o più nodi da aggiungere al flusso:
+ Per un nodo prompt: crea un prompt utilizzando Gestione dei prompt. Per ulteriori informazioni, consulta [Creare e archiviare prompt riutilizzabili con Gestione dei prompt in Amazon Bedrock](prompt-management.md). Se prevedi di definire i prompt in linea durante la creazione del nodo nel flusso, non è necessario creare un prompt in Gestione dei prompt.
+ Per un nodo knowledge base: crea una knowledge base da utilizzare nel flusso. Per ulteriori informazioni, consulta [Recupero di dati e generazione di risposte di IA con Knowledge Base per Amazon Bedrock](knowledge-base.md).
+ Per un nodo agente: crea un agente da utilizzare nel flusso. Per ulteriori informazioni, consulta [Automazione delle attività nella propria applicazione utilizzando agenti IA](agents.md).
+ Per un nodo di archiviazione S3: crea un bucket S3 per archiviare un output da un nodo nel flusso.
+ Per un nodo di recupero S3: crea un oggetto S3 in un bucket da cui recuperare i dati per il flusso. L’oggetto S3 deve essere una stringa codificata UTF-8.
+ Per un nodo Lambda: definisci una AWS Lambda funzione per la logica aziendale che intendi implementare nel flusso. Per ulteriori informazioni, consulta la [Guida per gli sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
+ Per un nodo Amazon Lex: crea un bot Amazon Lex per individuare gli intenti. Per ulteriori informazioni, consulta la [Guida per gli sviluppatori di Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
1. Per utilizzare i flussi, devi avere due ruoli diversi:
1. **Ruolo utente**: il ruolo IAM che utilizzi per accedere Console di gestione AWS o effettuare chiamate API deve disporre delle autorizzazioni per eseguire azioni relative ai flussi.
Se al tuo ruolo è associata la [AmazonBedrockFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockFullAccess)policy, non è necessario configurare autorizzazioni aggiuntive per questo ruolo. Per limitare le autorizzazioni di un ruolo solo alle azioni utilizzate per i flussi, collega la seguente policy basata sull’identità al ruolo IAM:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FlowPermissions",
"Effect": "Allow",
"Action": [
"bedrock:CreateFlow",
"bedrock:UpdateFlow",
"bedrock:GetFlow",
"bedrock:ListFlows",
"bedrock:DeleteFlow",
"bedrock:ValidateFlowDefinition",
"bedrock:CreateFlowVersion",
"bedrock:GetFlowVersion",
"bedrock:ListFlowVersions",
"bedrock:DeleteFlowVersion",
"bedrock:CreateFlowAlias",
"bedrock:UpdateFlowAlias",
"bedrock:GetFlowAlias",
"bedrock:ListFlowAliases",
"bedrock:DeleteFlowAlias",
"bedrock:InvokeFlow",
"bedrock:TagResource",
"bedrock:UntagResource",
"bedrock:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
Puoi limitare ulteriormente le autorizzazioni omettendo [azioni](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions) o specificando [risorse](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-resources) e [chiavi di condizione](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys). Un’identità IAM può chiamare operazioni API su risorse specifiche. Se specifichi un’operazione API che non può essere utilizzata sulla risorsa specificata nella policy, Amazon Bedrock restituisce un errore.
1. **Ruolo di servizio**: un ruolo che consente ad Amazon Bedrock di eseguire azioni per tuo conto. È necessario specificare questo ruolo durante la creazione o l’aggiornamento di un flusso. Puoi creare un [ruolo di servizio AWS Identity and Access Management [ personalizzato](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role)](flows-permissions.md).
**Nota**
Se prevedi di utilizzare la console Amazon Bedrock per creare automaticamente un ruolo quando crei un flusso, non è necessario configurare manualmente il ruolo.
# Creare e progettare un flusso in Amazon Bedrock
In questa sezione scopri come creare e progettare flussi con la console Amazon Bedrock. Per aiutarti a iniziare, i flussi creati con la console sono configurati per essere eseguiti con un singolo nodo di prompt. Questa sezione include anche altri esempi e modelli per creare diversi tipi di flussi.
Se desideri utilizzare l’SDK AWS per creare un flusso, consulta [Eseguire esempi di codice Amazon Bedrock Flows](flows-code-ex.md).
**Topics**
+ [Creare il primo flusso in Amazon Bedrock](flows-get-started.md)
+ [Progettare un flusso in Amazon Bedrock](flows-design.md)
+ [Provare flussi di esempio](flows-ex.md)
+ [Usare un modello per creare un flusso Amazon Bedrock](flows-templates.md)
# Creare il primo flusso in Amazon Bedrock
Ogni volta che crei un flusso, la console Amazon Bedrock crea automaticamente un flusso di avvio. Il flusso include un nodo di **Input del flusso**, un nodo **Prompt** e un nodo di **Output del flusso**. Quando si esegue il flusso, si inserisce un argomento per il flusso che utilizza il nodo prompt per riepilogare l’argomento. Prima di poter eseguire i flussi, è necessario impostare il modello per il prompt.
Per creare un flusso, devi inserire un nome e una descrizione per il flusso. Per impostazione predefinita, Amazon Bedrock crea un ruolo di servizio con le autorizzazioni appropriate. Facoltativamente, puoi specificare un ruolo di servizio esistente.
Amazon Bedrock esegue la crittografia dei dati a riposo. Per impostazione predefinita, Amazon Bedrock crittografa questi dati utilizzando una chiave gestita da AWS. Facoltativamente, puoi crittografare i dati di esecuzione del flusso utilizzando una chiave gestita dal cliente. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon Bedrock Flows](encryption-flows.md).
Dopo aver terminato il flusso di avvio, o se non ti serve, puoi continuare a creare il flusso. Ti consigliamo di leggere [Come funziona Amazon Bedrock Flows](flows-how-it-works.md) per acquisire familiarità con i concetti e i termini di Amazon Bedrock Flows e per conoscere i tipi di nodi disponibili. Per ulteriori informazioni, consulta [Progettare un flusso in Amazon Bedrock](flows-design.md).
**Per creare il primo flusso**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra.
1. Nella sezione **Amazon Bedrock Flows**, scegli **Crea flusso**.
1. Inserisci il **Nome** del flusso e una **Descrizione** facoltativa.
1. Per il **Nome del ruolo di servizio**, scegli una delle seguenti opzioni:
+ **Crea e usa un nuovo ruolo di servizio**: lascia che Amazon Bedrock crei un ruolo di servizio da utilizzare.
+ **Usa un ruolo di servizio esistente**: seleziona un ruolo di servizio personalizzato impostato in precedenza. Per ulteriori informazioni, consulta [Creare un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
1. (Facoltativo) Crittografa il flusso con una chiave gestita dal cliente effettuando le seguenti operazioni:
1. Seleziona **Configurazioni aggiuntive**.
1. In **Selezione chiave KMS**, seleziona **Personalizza le impostazioni di crittografia (avanzate)**. Quindi esegui una delle seguenti operazioni in **Scegli una chiave AWS KMS**:
+ Per utilizzare una chiave già presente, immetti l’ARN o trova la chiave che desideri usare.
+ Per creare una nuova chiave, scegli **Crea una chiave AWS KMS** per aprire la console AWS Key Management Service e [creare la chiave](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html). Quando crei la chiave, prendi nota dell’ARN per la chiave. Tornando alla console Amazon Bedrock, immetti l’ARN per la chiave in **Scegli una chiave AWS KMS**.
Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon Bedrock Flows](encryption-flows.md)
1. Scegli **Crea**. Amazon Bedrock crea il flusso di avvio e ti porta al **Generatore di flussi**.
1. Nella sezione **Generatore di flussi**, nota che il riquadro centrale (visuale) mostra un nodo di **Input del flusso**, un nodo **Prompt** e un **Output del flusso**. I nodi sono già collegati tra loro.
1. Nella visuale, seleziona il nodo **prompt**.
1. Nel riquadro Generatore di flussi, seleziona la sezione **Configurazioni**.
1. In **Nome del nodo**, assicurati che sia selezionato **Definisci nel nodo**.
1. In **Seleziona un modello**, seleziona un modello da usare.
1. Scegli **Salva** per salvare il flusso.
1. Nel riquadro **Testa flusso** a destra, immetti un argomento per il flusso da riepilogare.
1. Per eseguire la query, scegli **Esegui**. Il flusso visualizza l’argomento riepilogato.
# Progettare un flusso in Amazon Bedrock
In questa sezione progetterai un flusso Amazon Bedrock. Prima di progettare un flusso, ti consigliamo di leggere [Come funziona Amazon Bedrock Flows](flows-how-it-works.md) per acquisire familiarità con i concetti e i termini di Amazon Bedrock Flows e per conoscere i tipi di nodi disponibili. Per i flussi di esempio che puoi provare, consulta [Provare flussi di esempio](flows-ex.md).
**Per creare il flusso**
1. Se non sei già nel **generatore di flussi**, procedi come segue:
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, scegli un flusso nella sezione **Amazon Bedrock Flows**.
1. Scegli **Modifica nel Generatore di flussi**.
1. Nella sezione **Generatore di flussi**, il riquadro centrale mostra un nodo di **Input del flusso** e un nodo di **Output del flusso**. Si tratta dei nodi di input e output per il flusso.
1. Per aggiungere e configurare i nodi, procedi come segue:
1. Nel riquadro **Generatore di flussi**, seleziona **Nodi**.
1. Trascina un nodo da utilizzare per la prima fase del flusso e rilascialo nel riquadro centrale.
1. I cerchi sui nodi sono punti di connessione. Per connettere il nodo di input del flusso al secondo nodo, traccia una linea dal cerchio sul nodo dell’**Input del flusso** al cerchio nella sezione **Input** del nodo appena aggiunto.
1. Seleziona il nodo appena aggiunto.
1. Nella sezione **Configura** del riquadro **Generatore di flussi**, fornisci le configurazioni per il nodo selezionato e definisci nomi, tipi di dati ed espressioni per gli input e gli output del nodo.
1. Nel riquadro **Generatore di flussi**, seleziona **Nodi**.
1. Ripeti le fasi per aggiungere e configurare i nodi rimanenti nel flusso.
**Nota**
Se utilizzi un ruolo di servizio che Amazon Bedrock ha creato automaticamente per te, il ruolo sarà aggiornato con le autorizzazioni appropriate man mano che aggiungi nodi. Tuttavia, se utilizzi un ruolo di servizio personalizzato, è necessario aggiungere le autorizzazioni appropriate alla policy allegata al ruolo di servizio consultando [Creare un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
1. Collega l’**Output** dell’ultimo nodo del flusso con l’**Input** del nodo di **Output del flusso**. Puoi avere più nodi di **Output del flusso**. Per aggiungere altri nodi di output del flusso, trascina il nodo di **Output del flusso** e rilascialo accanto al nodo in cui desideri che il flusso si interrompa. Traccia connessioni tra i due nodi.
1. Passa alla procedura successiva per [Testare un flusso in Amazon Bedrock](flows-test.md) o torna in seguito. Scegli **Salva** per procedere con la fase successiva. Per tornare in seguito, scegli **Salva ed esci**.
**Eliminare un nodo o una connessione**
Durante il processo di creazione del flusso, potrebbe essere necessario eliminare un nodo o rimuovere le connessioni dei nodi.
**Per eliminare un nodo**
1. Seleziona il nodo da eliminare.
1. Nel riquadro **Generatore di flussi**, 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)).
**Nota**
Se utilizzi un ruolo di servizio che Amazon Bedrock ha creato automaticamente per te, il ruolo sarà aggiornato con le autorizzazioni appropriate man mano che aggiungi nodi. Tuttavia, se elimini i nodi, le autorizzazioni pertinenti non saranno eliminate. Ti consigliamo di eliminare le autorizzazioni che non ti servono più seguendo la procedura descritta in [Modificare un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html).
**Per rimuovere una connessione**
+ Nella pagina **Generatore di flussi**, passa il mouse sulla connessione da rimuovere finché non si visualizza l’icona di espansione, quindi trascina la connessione lontano dal nodo.
Alla creazione di un flusso si applicano i seguenti requisiti:
+ Il flusso deve avere solo un nodo di input del flusso e almeno un nodo di output del flusso.
+ Non è possibile includere input per un nodo di input del flusso.
+ Non è possibile includere output per un nodo di output del flusso.
+ Tutti gli output in un nodo devono essere collegati a un input in un nodo a valle (nell’API, ciò avviene tramite [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) con [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)).
+ Ogni condizione (inclusa quella predefinita) in un nodo di condizione deve essere connessa a un nodo a valle (nell’API, ciò avviene tramite [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) con [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)).
Alla creazione di un flusso si applicano le seguenti linee guida:
+ Inizia impostando il tipo di dati per l’output del nodo di input del flusso. Il tipo di dati deve corrispondere a quello che prevedi di inviare come input quando invochi il flusso.
+ Quando definisci gli input per un flusso utilizzando le espressioni, verifica che il risultato corrisponda al tipo di dati che scegli per l’input.
+ Se includi un nodo iteratore, includi un nodo collettore a valle dopo aver inviato l’output nei nodi di cui hai bisogno. Il nodo collettore restituirà gli output in un array.
# Provare flussi di esempio
Questo argomento fornisce alcuni flussi di esempio che puoi provare per iniziare a usare Amazon Bedrock Flows. Puoi anche utilizzare modelli per creare un flusso iniziale. Per ulteriori informazioni, consulta [Usare un modello per creare un flusso Amazon Bedrock](flows-templates.md).
Espandi un esempio per scoprire come crearlo nella console Amazon Bedrock:
**Topics**
+ [Creare un flusso con un solo prompt](flows-ex-prompt.md)
+ [Creare un flusso con un nodo di condizione](flows-ex-condition.md)
# Creare un flusso con un solo prompt
L’immagine seguente mostra un flusso costituito da un solo prompt, definito inline nel nodo. Il prompt genera una playlist di brani da un input di un oggetto JSON che include il genere e il numero di brani da includere nella playlist.
![\[Esempio di utilizzo di un nodo prompt con due variabili.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/flows/flows-prompt.png)
**Per creare e testare questo flusso nella console**
1. Crea un flusso seguendo le istruzioni riportate in [Creare il primo flusso in Amazon Bedrock](flows-get-started.md).
1. Configura il nodo prompt effettuando le seguenti operazioni:
1. Seleziona il nodo **Prompt** nel riquadro centrale.
1. Seleziona la scheda **Configura** nel riquadro **Generatore di flussi**.
1. Immetti **MakePlaylist** come **Nome del nodo**.
1. Scegli **Definisci nel nodo**.
1. Imposta le seguenti configurazioni per il prompt:
1. In **Seleziona modello**, seleziona un modello per eseguire l’inferenza sul prompt.
1. Nella casella di testo **Messaggio** inserisci **Make me a \$1\$1genre\$1\$1 playlist consisting of the following number of songs: \$1\$1number\$1\$1.**. Questo crea due variabili che appariranno come input nel nodo.
1. (Facoltativo) Modifica le **Configurazioni di inferenza**.
1. (Facoltativo) Se supportato dal modello, è possibile configurare il **caching** dei prompt per il messaggio di prompt. Per ulteriori informazioni, consulta [Creare e progettare un flusso in Amazon Bedrock](flows-create.md).
1. Espandi la sezione **Input**. I nomi degli input sono precompilati dalle variabili nel messaggio di prompt. Configura gli input come segue:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-ex-prompt.html)
Questa configurazione significa che il nodo prompt prevede un oggetto JSON contenente un campo chiamato `genre` che sarà mappato all’input `genre` e un campo chiamato `number` che sarà mappato all’input `number`.
1. Non è possibile modificare l’**Output**. Sarà la risposta del modello, restituita come stringa.
1. Scegli il nodo di **Input del flusso** e seleziona la scheda **Configura**. Seleziona **Oggetto** come **Tipo**. Ciò significa che l’invocazione del flusso si aspetterà di ricevere un oggetto JSON.
1. Connetti i nodi per completare il flusso effettuando le seguenti operazioni:
1. Trascina una connessione dal nodo di output del nodo di **Input del flusso** all’input **genre** nel nodo prompt **MakePlaylist**.
1. Trascina una connessione dal nodo di output del nodo di **Input del flusso **all’input **number** nel nodo prompt **MakePlaylist**.
1. Trascina una connessione dal nodo di output dell’output **modelCompletion** nel nodo prompt **MakePlaylist** all’input del **documento** nel nodo di **Output del flusso**.
1. Scegli **Salva** per salvare il flusso. A questo punto, il flusso dovrebbe essere pronto per il test.
1. Testa il flusso inserendo il seguente oggetto JSON nel riquadro **Testa flusso** a destra. Scegli **Esegui** e il flusso dovrebbe restituire una risposta del modello.
```
{
"genre": "pop",
"number": 3
}
```
# Creare un flusso con un nodo di condizione
L’immagine seguente mostra che un flusso con un nodo di condizione restituisce uno dei tre valori possibili in base alla condizione soddisfatta:
![\[Esempio di utilizzo di un nodo di condizione con due condizioni.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/flows/flows-condition.png)
**Per creare e testare questo flusso nella console:**
1. Crea un flusso seguendo le istruzioni riportate in [Creare il primo flusso in Amazon Bedrock](flows-get-started.md).
1. Elimina il nodo **Prompt** nel riquadro centrale.
1. Configura il nodo di condizione effettuando le seguenti operazioni:
1. Dal riquadro sinistro del **Generatore di flussi**, seleziona la scheda **Nodi**.
1. Trascina un nodo **Condizione** nel flusso nel riquadro centrale.
1. Seleziona la scheda **Configura** nel riquadro **Generatore di flussi**.
1. Espandi la sezione **Input**. Configura gli input come segue:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/flows-ex-condition.html)
Questa configurazione significa che il nodo di condizione prevede un oggetto JSON che contiene i campi `retailPrice`, `marketPrice` e `type`.
1. Configura le condizioni effettuando le seguenti operazioni:
1. Nella sezione **Condizioni**, puoi modificare facoltativamente il nome della condizione. Quindi aggiungi la seguente condizione nella casella di testo **Condizione**: **(retailPrice > 10) and (type == "produce")**.
1. Puoi aggiungere un’altra condizione scegliendo **Aggiungi condizione**. Puoi anche modificare il nome della seconda condizione. Quindi aggiungi la seguente condizione nella casella di testo **Condizione**: **(retailPrice < marketPrice)**.
1. Scegli il nodo di **Input del flusso** e seleziona la scheda **Configura**. Seleziona **Oggetto** come **Tipo**. Ciò significa che l’invocazione del flusso si aspetterà di ricevere un oggetto JSON.
1. Aggiungi i nodi di output del flusso in modo da averne tre in totale. Configurali come segue nella scheda **Configura** del riquadro **Generatore di flussi** di ciascun nodo di output del flusso:
1. Imposta il tipo di input del primo nodo di output del flusso come **String** e l’espressione come **\$1.data.action[0]** per restituire il primo valore dell’array nel campo `action` dell’oggetto in entrata.
1. Imposta il tipo di input del secondo nodo di output del flusso **String** e l’espressione come **\$1.data.action[1]** per restituire il secondo valore nell’array nel campo `action` dell’oggetto in entrata.
1. Imposta il tipo di input del terzo nodo di output del flusso **String** e l’espressione come **\$1.data.action[2]** per restituire il terzo valore nell’array nel campo `action` dell’oggetto in entrata.
1. Connetti la prima condizione al primo nodo di uscita del flusso, la seconda condizione al secondo nodo di uscita del flusso e la condizione predefinita al terzo nodo di uscita del flusso.
1. Connetti gli input e gli output in tutti i nodi per completare il flusso effettuando le seguenti operazioni:
1. Trascina una connessione dal nodo di output del nodo di **Input del flusso** all’input **retailPrice** nel nodo di condizione.
1. Trascina una connessione dal nodo di output del nodo di **Input del flusso** all’input **marketPrice** nel nodo di condizione.
1. Trascina una connessione dal nodo di output del nodo di **Input del flusso** all’input **tipo** nel nodo di condizione.
1. Trascina una connessione dall’output del nodo di **Input del flusso** all’input **documento** in ciascuno dei tre nodi di output.
1. Scegli **Salva** per salvare il flusso. A questo punto, il flusso dovrebbe essere pronto per il test.
1. Testa il flusso inserendo i seguenti oggetti JSON nel riquadro **Flusso di test** sulla destra. Scegli **Esegui** per ciascun input:
1. L’oggetto seguente soddisfa la prima condizione (`retailPrice` è superiore a 10 e `type`corrisponde a “produci”) e restituisce il primo valore in `action` (“non acquistare”):
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "produce",
"action": ["don't buy", "buy", "undecided"]
}
```
**Nota**
Anche se sono soddisfatte sia la prima che la seconda condizione, la prima condizione ha la precedenza in quanto avviene prima dell’altra.
1. L’oggetto seguente soddisfa la seconda condizione (`retailPrice` è inferiore a `marketPrice`) e restituisce il secondo valore in `action` (“acquista”):
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
1. L’oggetto seguente non soddisfa né la prima condizione (`retailPrice` è superiore a 10, ma `type` non è “produci”) né la seconda condizione (`retailPrice` non è inferiore a`marketPrice`), quindi viene restituito il terzo valore in `action` (“indeciso”):
```
{
"retailPrice": 11,
"marketPrice": 11,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
# Usare un modello per creare un flusso Amazon Bedrock
Per aiutarti a iniziare a definire e orchestrare Amazon Bedrock Flows, puoi utilizzare modelli per creare flussi per una serie di configurazioni del flusso. Ad esempio, puoi utilizzare un modello per visualizzare un flusso che include una knowledge base o un flusso che utilizza condizioni per indirizzare la logica del flusso.
Puoi accedere ai modelli dal repository GitHub di [Esempi di Amazon Bedrock Flows](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file). La console Amazon Bedrock fornisce anche un collegamento al repository dalla pagina canvas per un flusso.
I modelli di flusso vengono forniti come [modelli JSON](https://github.com/aws-samples/amazon-bedrock-flows-samples/tree/main/templates) per ogni definizione di flusso supportata e uno script Python da utilizzare per creare ed eseguire il flusso. Puoi accedere al flusso anche dalla console Amazon Bedrock.
Il repository fornisce i seguenti modelli:
+ [Flusso della knowledge base](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1): mostra come integrare ed eseguire query sulla [knowledge base](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1), tra cui RAG (Retrieval Augmented Generation) e la ricerca e il recupero della knowledge base.
+ [Flusso agente di conversazione multi-turno](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#2-multi-turn-conversation-agent-flow-1): mostra come eseguire conversazioni stateful interattive con un flusso. Per ulteriori informazioni, consulta [Conversare con un flusso Amazon Bedrock](flows-multi-turn-invocation.md).
+ [Flusso di condizioni](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#3-conditions-flow-1): mostra come eseguire la logica condizionale e la ramificazione all’interno di un flusso.
+ [Nodo prompt con flusso Guardrail](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#4-prompt-node-with-guardrail-flow-1): mostra come proteggere un nodo prompt con un guardrail.
+ [Flusso iteratore e collettore](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1): mostra come elaborare più input e risposte aggregate.
+ [Flusso multiagente](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1): mostra diversi flussi di lavoro basati su agenti, tra cui la collaborazione multiagente e la delega delle attività.
Prima di poter eseguire lo script, devi creare le risorse Amazon Bedrock, ad esempio una knowledge base o un agente, utilizzate dal flusso. È tua responsabilità eliminare le risorse quando non sono più necessarie.
Per creare ed eseguire un flusso da un modello, esegui lo script (`flow_manager.py`). Lo script richiede informazioni aggiuntive necessarie, ad esempio il modello di flusso che desideri utilizzare e gli identificatori per le risorse necessarie al modello. Puoi includere un prompt di test da provare con il flusso.
Facoltativamente, puoi impostare la Regione AWS in cui desideri creare il flusso. Lo script crea le risorse necessarie con un set predefinito di [autorizzazioni per il ruolo IAM](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#iam-role-permissions). Inoltre, puoi scegliere di usare un ruolo IAM che hai creato.
Se desideri utilizzare il flusso nella console Amazon Bedrock, non utilizzare il parametro `--cleanup` in quanto questo elimina il flusso dopo che lo script ha eseguito il flusso. Se non usi `--cleanup`, dovrai eliminare il flusso quando non ti serve più.
Per ulteriori informazioni, consulta [https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file\$1how-to-use](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#how-to-use).
# Visualizzare informazioni sui flussi in Amazon Bedrock
Per scoprire come visualizzare le informazioni su un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per visualizzare i dettagli di un flusso**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Amazon Bedrock Flows**, seleziona un flusso.
1. Visualizza i dettagli del flusso nel riquadro **Dettagli del flusso**.
------
#### [ API ]
Per ottenere informazioni su un flusso, invia una richiesta [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`.
Per elencare le informazioni sui tuoi flussi, invia una richiesta [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) a un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). È inoltre possibile specificare i parametri opzionali seguenti:
****
| 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. |
------
# Modificare un flusso in Amazon Bedrock
Per scoprire come modificare un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per modificare i dettagli di un flusso**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Amazon Bedrock Flows**, seleziona un flusso.
1. Nella sezione **Dettagli del flusso**, scegli **Modifica**.
1. Puoi modificare il nome, la descrizione e associare un ruolo di servizio diverso per il flusso.
1. Seleziona **Salva modifiche**.
**Per modificare un flusso**
1. Se non sei già nel **generatore di flussi**, procedi come segue:
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, scegli un flusso nella sezione **Amazon Bedrock Flows**.
1. Scegli **Modifica nel Generatore di flussi**.
1. Aggiungi, rimuovi e modifica nodi e connessioni in base alle esigenze. Per ulteriori informazioni, consulta [Creare e progettare un flusso in Amazon Bedrock](flows-create.md) e [Tipi di nodo per il flusso](flows-nodes.md).
1. Quando hai concluso la modifica del flusso, scegli **Salva** o **Salva ed esci**.
------
#### [ API ]
Per modificare un flusso, invia una richiesta [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Includi sia i campi da mantenere sia i campi da modificare. Per considerazioni sui campi della richiesta, consulta [Creare e progettare un flusso in Amazon Bedrock](flows-create.md).
------
# Includere i guardrail nel flusso in Amazon Bedrock
Amazon Bedrock Flows si integra con Guardrail per Amazon Bedrock per consentirti di identificare e bloccare o filtrare i contenuti indesiderati nel tuo flusso. Per scoprire come applicare i guardrail ai tipi di nodi supportati in un flusso, consulta la tabella seguente:
****
| Tipo di nodo | Console | API |
| --- | --- | --- |
| Nodo prompt | Quando [crei](flows-create.md) o [aggiorni](flows-modify.md) un flusso, seleziona il nodo prompt e specifica il guardrail nella sezione Configura. | Quando definisci il nodo prompt nel campo nodes in una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) o [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), includi un campo guardrailConfiguration in [PromptFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeConfiguration.html). |
| Nodo della knowledge base | Quando [crei](flows-create.md) o [aggiorni](flows-modify.md) un flusso, seleziona il nodo knowledge base e specifica il guardrail nella sezione Configura. È possibile includere un guardrail solo quando si generano risposte basate sui risultati recuperati. | Quando definisci il nodo knowledge base nel campo nodes in una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) o [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), includi un campo guardrailConfiguration in [KnowledgeBaseFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_KnowledgeBaseFlowNodeConfiguration.html). È possibile includere un guardrail solo quando si utilizza RetrieveAndGenerate, quindi è necessario includere modelId. |
Per ulteriori informazioni sui guardrail, consulta [Rilevare e filtrare contenuti dannosi utilizzando Guardrail per Amazon Bedrock](guardrails.md).
Per ulteriori informazioni sui tipi di nodi, consulta [Tipi di nodo per il flusso](flows-nodes.md).
# Testare un flusso in Amazon Bedrock
Dopo aver creato un flusso, avrai una *bozza di lavoro*. La bozza di lavoro è una versione del flusso che puoi sviluppare e testare in modo iterativo. Ogni volta che apporti modifiche al flusso, la bozza di lavoro viene aggiornata.
Quando esegui il test del flusso, Amazon Bedrock verifica innanzitutto quanto segue e genera un’eccezione se la verifica fallisce:
+ Connettività tra tutti i nodi del flusso.
+ È configurato almeno un nodo di output del flusso.
+ I tipi di variabili di input e output vengono abbinati come richiesto.
+ Le espressioni delle condizioni sono valide e viene fornito un risultato predefinito.
Se la verifica fallisce, dovrai correggere gli errori prima di poter testare e convalidare le prestazioni del flusso. Di seguito è riportata la procedura per testare il flusso. Scegli la scheda relativa al tuo metodo preferito, quindi segui la procedura:
------
#### [ Console ]
**Per testare il flusso**
1. Se non sei già nel **Generatore di flussi**, procedi come segue:
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Amazon Bedrock Flows**, seleziona un flusso da testare.
1. Scegli **Modifica nel Generatore di flussi**.
1. Nella **pagina del Generatore di flussi**, nel riquadro a destra, inserisci un input per invocare il flusso. Verifica che il tipo di dati di input corrisponda al tipo di dati di output che hai configurato per il nodo di input del flusso.
1. Scegli **Esegui**.
1. I nodi o le connessioni nella configurazione del flusso che generano errori vengono evidenziati in rosso e quelli che attivano gli avvisi vengono evidenziati in giallo. Leggi i messaggi di errore e gli avvisi, risolvi i problemi identificati, salva il flusso ed esegui nuovamente il test.
**Nota**
Per applicare le modifiche apportate durante il test del flusso, è necessario salvare il flusso.
1. (Facoltativo) Per visualizzare gli input, gli output e la durata di esecuzione per ciascun nodo, scegli **Mostra traccia** nella risposta. Per ulteriori informazioni, consulta [Tenere traccia di ciascuna fase del flusso visualizzandone la traccia in Amazon BedrockTenere traccia di ciascuna fase del flusso visualizzandone la traccia](flows-trace.md). Per tornare al visual builder, scegli **Nascondi traccia** o seleziona l’icona di compressione.
1. Se le prestazioni del flusso ti soddisfano, scegli **Salva ed esci**.
1. Puoi continuare l’iterazione della creazione del flusso. Se il flusso ti soddisfa e vuoi implementarlo in produzione, crea una versione del flusso e un alias per puntare alla versione. Per ulteriori informazioni, consulta [Implementare un flusso nella tua applicazione utilizzando versioni e alias](flows-deploy.md).
------
#### [ API ]
Per testare il flusso, invia una richiesta [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un endpoint di runtime [Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Includi l’ARN o l’ID del flusso nel campo `flowIdentifier` e l’ARN o l’ID dell’alias da utilizzare nel campo `flowAliasIdentifier`.
Per visualizzare gli input e gli output per ciascun nodo, imposta il campo `enableTrace` su `TRUE`. Per ulteriori informazioni, consulta [Tenere traccia di ciascuna fase del flusso visualizzandone la traccia in Amazon BedrockTenere traccia di ciascuna fase del flusso visualizzandone la traccia](flows-trace.md).
Il testo della richiesta specifica l’input per il flusso e presenta il seguente formato:
```
{
"inputs": [
{
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeOutputName": "string"
}
],
"enableTrace": TRUE | FALSE
}
```
Inserisci l’input nel campo `document`, inserisci un nome per l’input nel campo `nodeName` e inserisci un nome per l’input nel campo `nodeOutputName`.
La risposta viene restituita in uno stream. Ciascun evento restituito contiene l’output di un nodo nel campo `document`, il nodo elaborato nel campo `nodeName` e il tipo di nodo nel campo `nodeType`. Questi eventi sono nel seguente formato:
```
{
"flowOutputEvent": {
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeType": "string"
}
}
```
Se il flusso termina, viene restituito anche un campo `flowCompletionEvent` con `completionReason`. Se si verifica un errore, viene restituito il campo di errore corrispondente.
------
# Tenere traccia di ciascuna fase del flusso visualizzandone la traccia in Amazon Bedrock
Quando invochi un flusso, puoi visualizzare la *traccia* per vedere gli input e gli output di ciascun nodo. La traccia consente di tracciare il percorso dall’input alla risposta che restituisce. È possibile utilizzare la traccia per risolvere gli errori che si verificano, per identificare le fasi che portano a un risultato imprevisto o a un rallentamento delle prestazioni e per valutare come è possibile migliorare il flusso.
Per visualizzare la traccia, procedi come indicato di seguito:
+ Nella console, segui le fasi nella scheda **Console** in [Testare un flusso in Amazon Bedrock](flows-test.md) e scegli **Mostra traccia** nella risposta dall’invocazione del flusso.
+ Nell’API, imposta il campo `enableTrace` su `true` in una richiesta [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html). Ciascuno `flowOutputEvent` nella risposta viene restituito insieme a `flowTraceEvent`.
Ciascun evento della traccia include il nome del nodo che ha ricevuto un input o prodotto un output e la data in cui l’input o l’output è stato elaborato. Per maggiori informazioni su un tipo di evento della traccia, seleziona una scheda:
------
#### [ FlowTraceConditionNodeResultEvent ]
Questo tipo di traccia identifica quali condizioni sono soddisfatte per un nodo di condizione e aiuta a identificare il ramo o i rami del flusso che vengono attivati durante l’invocazione. Il seguente oggetto JSON mostra l’aspetto di [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) per il risultato di un nodo di condizione:
```
{
"trace": {
"conditionNodeOutputTrace": {
"nodeName": "string",
"satisfiedConditions": [
{
"conditionName": "string"
},
...
],
"timestamp": timestamp
}
}
}
```
------
#### [ FlowTraceNodeInputEvent ]
Questo tipo di traccia mostra l’input inviato a un nodo. Se l’evento è a valle di un nodo iteratore ma a monte di un nodo collettore, il campo `iterationIndex` indica l’indice dell’elemento nell’array da cui proviene l’input. Il seguente oggetto JSON mostra l’aspetto di [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) per l’input in un nodo.
```
{
"trace": {
"nodeInputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeInputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
#### [ FlowTraceNodeOutputEvent ]
Questo tipo di traccia mostra l’output prodotto da un nodo. Se l’evento è a valle di un nodo iteratore ma a monte di un nodo collettore, il campo `iterationIndex` indica l’indice dell’elemento nell’array da cui proviene l’output. Il seguente oggetto JSON mostra l’aspetto di [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) per l’output di un nodo.
```
{
"trace": {
"nodeOutputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeOutputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
# Eseguire flussi di Amazon Bedrock in modo asincrono con le esecuzioni del flusso
Con le esecuzioni dei flussi, puoi eseguire i flussi di Amazon Bedrock in modo asincrono. Ciò consente ai flussi di durare più a lungo e anche di controllare il rendimento in modo che l’applicazione possa eseguire altre attività.
Quando esegui un flusso utilizzando la console Amazon Bedrock o con l'[InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)operazione, il flusso viene eseguito fino al termine o al timeout di un'ora (a seconda dell'evento che si verifica per primo). Quando effettui l’esecuzione di un flusso, il flusso può durare molto più a lungo: i singoli nodi possono durare fino a cinque minuti e l’intero flusso può durare fino a 24 ore.
**Nota**
La valutazione del modello è in fase di anteprima per Amazon Bedrock ed è soggetta a modifica.
## Autorizzazioni richieste per effettuare le esecuzioni dei flussi
+ Assicurati che il tuo ruolo di servizio di Amazon Bedrock Flows disponga di tutte le autorizzazioni necessarie. Per ulteriori informazioni, consulta [Creare un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
+ (Facoltativo) Crittografa i dati di esecuzione del flusso con una chiave gestita dal cliente. AWS KMS Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon Bedrock Flows](encryption-flows.md).
## Creare e gestire l’esecuzione di un flusso
È possibile creare un'esecuzione del flusso nella console o utilizzando l'[StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)operazione.
------
#### [ Console ]
1. Crea un flusso seguendo le istruzioni riportate in [Creare e progettare un flusso in Amazon Bedrock](flows-create.md).
1. Crea un alias per il flusso seguendo le istruzioni riportate in [Creare un alias di un flusso in Amazon Bedrock](flows-alias-create.md).
1. Se non sei già nel **Generatore di flussi**, procedi come segue:
1. Accedi a Console di gestione AWS con un'identità IAM che dispone delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock in [https://console.aws.amazon.com/bedrock.](https://console.aws.amazon.com/bedrock)
1. Seleziona **Amazon Bedrock Flows** dal riquadro di navigazione a sinistra, quindi scegli il flusso.
1. Scegli la scheda **Esecuzioni**, quindi scegli **Crea esecuzione**.
1. Nella finestra di dialogo **Crea esecuzione**, immetti quanto segue:
1. In **Nome**, immetti un nome per l’esecuzione del flusso.
1. In **Seleziona alias**, scegli l’alias del flusso che desideri utilizzare.
1. Per **Prompt rapido**, inserisci il prompt con cui desideri avviare il flusso.
1. Scegli **Crea** per creare l’esecuzione del flusso e iniziare a eseguirlo.
1. Nella pagina dei dettagli del flusso, scegli la scheda **Esecuzioni** e prendi nota dello stato dell’esecuzione del flusso in **Stato di esecuzione**.
1. (Facoltativo) Scegli un’esecuzione per aprire il flusso e visualizzare il riepilogo dell’esecuzione.
Nell’**Output di esecuzione**, si visualizza l’output del flusso.
1. (Facoltativo) Per interrompere l’esecuzione di un flusso, seleziona l’esecuzione e scegli **Arresta**.
------
#### [ API ]
**Avviare l’esecuzione di un flusso**
Per eseguire l'esecuzione di un flusso, invia una [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)richiesta con un [endpoint di runtime Agents for Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Nella richiesta, specifica l’ID del flusso e l’ID dell’alias di flusso del flusso che desideri eseguire. È anche possibile specificare:
+ **inputs**: un array contenente il nodo di [input](flows-nodes.md#flows-nodes-input) da cui desideri che il flusso inizi a funzionare. Specifica l’input da inviare al nodo di input del flusso del prompt nel campo `content`.
+ **name**: un nome per l’esecuzione del flusso.
```
{
"inputs": [{
"nodeName": "FlowInputNode",
"nodeOutputName": "document",
"content": {
"document": "Test"
}
}],
"name": "MyExecution"
}
```
La risposta è il nome della risorsa Amazon (ARN) dell’esecuzione del flusso. Puoi usare `executionArn` per verificare lo stato corrente del flusso, ad esempio quando termina l’esecuzione del flusso o quando un nodo di condizione ne valuta le condizioni.
```
{
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution"
}
```
**Tieni traccia dello stato di avanzamento dell’esecuzione di un flusso**
Utilizzate l'[GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)operazione per ottenere lo stato corrente di un flusso identificato dal relativo ARN di esecuzione. Lo stato di un flusso è `Running`, `Succeeded`, `Failed`, `TimedOut` o `Aborted`.
```
{
"endedAt": null,
"errors": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"startedAt": "2025-03-20T23:32:28.899221162Z",
"status": "Running"
}
```
Gli errori (come un nodo Lambda che scade) vengono restituiti nell’array `errors` come nell’esempio seguente:
```
"errors": [{
"nodeName": "LambdaNode1",
"errorType": "ExecutionTimedOut",
"message": "Call to lambda function timed out"
}],
```
**Ottenere i risultati dell’esecuzione di un flusso**
Amazon Bedrock scrive gli output di un flusso nei nodi di [output](flows-nodes.md#flows-nodes-output) del flusso. Puoi ottenere gli output dopo aver completato il flusso o mentre il flusso è in esecuzione (a seconda del caso d’uso).
Se desideri che il flusso venga completato per primo, effettua una chiamata a `GetFlowExecution` e assicurati che il valore del campo `status` nella risposta sia `Succeeded`.
Per ottenere un elenco degli eventi di output dall'esecuzione del flusso, effettuate una chiamata a [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html). Nella risposta, verifica la presenza di oggetti `flowOutputEvent` in `flowExecutionEvents`. Ad esempio, puoi ottenere l’output di un flusso nel campo `content`:
```
{
"flowOutputEvent": {
"content": {
"document": "The model response."
},
"nodeName": "FlowOutputNode"
}
}
```
È possibile limitare l’output `ListFlowExecutions` ai soli nodi di input e output impostando il parametro di query `eventType` su `Flow`.
**Visualizzazione di eventi**
Per facilitare il debug dell'esecuzione del flusso, puoi utilizzare l'[ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)operazione per visualizzare gli eventi generati dai nodi mentre il flusso è in esecuzione. Imposta il parametro di query `eventType` su `Node` per vedere gli input e gli output di tutti i nodi (compresi i nodi intermedi) nella risposta simile all’esempio seguente:
```
{
"flowExecutionEvents": [{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "document"
}],
"nodeName": "FlowInputNode",
"timestamp": "2025-05-05T18:38:56.637867516Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "book"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:38:57.434600163Z"
}
},
{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "modelCompletion"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:39:06.034157077Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "document"
}],
"nodeName": "FlowOutputNode",
"timestamp": "2025-05-05T18:39:06.453128251Z"
}
}
]
}
```
**Ottenere un’istantanea dell’esecuzione del flusso**
Amazon Bedrock scatta automaticamente una snapshot della definizione di flusso e dei metadati all’avvio dell’esecuzione del flusso. Questo fa sì che un flusso possa essere aggiornato mentre è in esecuzione in modo asincrono. Per recuperare questa istantanea, chiamate l'operazione. [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html) La risposta include i seguenti campi del flusso:
+ **customerEncryptionKeyArn**: l'ARN della chiave che crittografa AWS KMS il flusso.
+ **definition**: la [definizione](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDefinition.html) del flusso.
+ **executionRoleArn**— L'ARN del ruolo del servizio IAM utilizzato dall'esecuzione del flusso.
+ **flowAliasIdentifier**— L'ID alias del flusso.
+ **flowIdentifier**: l’ID del flusso.
+ **flowVersion**: la versione del flusso.
```
{
"customerEncryptionKeyArn": null,
"definition": "{flow-definition}",
"executionRoleArn": "arn:aws:iam::111122223333:role/name",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT"
}
```
**Elenca le esecuzioni dei flussi**
È possibile ottenere un elenco delle esecuzioni del flusso chiamando l'[ListFlowExecutions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutions.html)operazione. La risposta include un `flowExecutionSummaries` array con informazioni su ciascuna delle esecuzioni di flusso nella corrente Regione AWS per un flusso o un alias di flusso. Ciascun elemento include informazioni come l’ARN di esecuzione, l’ora di inizio e lo stato corrente del flusso.
```
{
"flowExecutionSummaries": [{
"createdAt": "2025-03-11T23:21:02.875598966Z",
"endedAt": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"status": "Running"
}]
}
```
**Interrompere l’esecuzione di un flusso in esecuzione**
Se devi interrompere l'esecuzione di un flusso in esecuzione, chiama l'[StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)operazione e passa l'ID del flusso, l'ID dell'alias del flusso e l'ID di esecuzione del flusso per l'esecuzione che desideri interrompere.
------
## Stati di esecuzione del flusso
L’esecuzione di un flusso può avere uno dei seguenti stati:
+ **In esecuzione**: l’esecuzione del flusso è in corso.
+ **Riuscito**: l’esecuzione del flusso è stata completata correttamente.
+ **Non riuscito**: l’esecuzione del flusso non è riuscita a causa di un errore.
+ **TimedOut**— L'esecuzione del flusso ha superato la durata massima di 24 ore.
+ **Interrotta**: l'esecuzione del flusso è stata interrotta manualmente utilizzando l'[StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)operazione.
Le esecuzioni di un flusso non più attive vengono eliminate automaticamente dopo 90 giorni.
## Best practice per l’esecuzione di un flusso
Durante l’utilizzo di esecuzioni di un flusso, valuta le seguenti informazioni:
+ Esegui regolarmente il polling dello stato di esecuzione del flusso [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)fino a quando il flusso non raggiunge uno stato terminale (che è qualcosa di diverso`Running`).
+ Quando l'esecuzione del flusso raggiunge uno stato terminale, [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)usala per ottenere i risultati del flusso. Ad esempio, puoi utilizzare questi risultati per creare una logica attorno al flusso.
+ Ottieni un'istantanea dell'esecuzione del flusso, utilizzandola [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)per facilitare il debug in caso di problemi durante l'esecuzione.
# Implementare un flusso nella tua applicazione utilizzando versioni e alias
Quando crei un flusso per la prima volta, vengono create una bozza di lavoro (`DRAFT`) e un alias di test (`TSTALIASID`) che rimanda alla versione bozza di lavoro. Quando apporti modifiche al flusso, le modifiche si applicano alla bozza di lavoro, quindi quest’ultima è la versione più recente del flusso. Dovrai continuare con la bozza di lavoro finché il comportamento del flusso non ti sembra soddisfacente. Quindi, puoi configurare il flusso per l’implementazione creando *versioni* del flusso.
Una *versione* è simile a uno snapshot che conserva la risorsa così com’era al momento della creazione. Puoi continuare a modificare la bozza di lavoro e creare versioni del flusso, secondo le esigenze. Amazon Bedrock crea le versioni in ordine numerico, a partire da 1. Le versioni sono immutabili perché fungono da snapshot del flusso al momento della creazione. Per aggiornare un flusso che hai implementato in produzione, devi creare una nuova versione dalla bozza di lavoro ed effettuare chiamate all’alias che punta a quella versione.
Per implementare il flusso, devi creare un *alias* che punti a una versione del flusso. Quindi, fai richieste `InvokeFlow` a quell’alias. Con gli alias, puoi passare comodamente da una versione all’altra del flusso senza tenere traccia della versione. Ad esempio, puoi modificare un alias in modo che punti a una versione precedente del flusso nel caso in cui esistano modifiche da ripristinare rapidamente.
Negli argomenti seguenti viene descritto come creare versioni e alias del flusso.
**Topics**
+ [Creare una versione di un flusso in Amazon Bedrock](flows-version-create.md)
+ [Visualizzazione delle informazioni sulle versioni dei flussi in Amazon Bedrock](flows-version-view.md)
+ [Eliminare una versione di un flusso in Amazon Bedrock](flows-version-delete.md)
+ [Creare un alias di un flusso in Amazon Bedrock](flows-alias-create.md)
+ [Visualizzare informazioni sugli alias dei flussi in Amazon Bedrock](flows-alias-view.md)
+ [Modificare l’alias di un flusso in Amazon Bedrock](flows-alias-modify.md)
+ [Eliminare l’alias di un flusso in Amazon Bedrock](flows-alias-delete.md)
# Creare una versione di un flusso in Amazon Bedrock
Quando la configurazione del flusso ti soddisfa, crea una versione immutabile del flusso a cui puntare con un alias. Per scoprire come creare una versione del flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per creare una versione di Amazon Bedrock Flows**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, scegli un flusso nella sezione **Amazon Bedrock Flows**.
1. Nella sezione **Versioni**, scegli **Pubblica versione**.
1. Dopo la pubblicazione della versione, viene visualizzato un banner per informarti che l’operazione è riuscita.
------
#### [ API ]
Per creare una versione del flusso, invia una richiesta [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`.
La risposta restituisce un ID e un ARN per la versione. Le versioni vengono create in modo incrementale, a partire da 1.
------
# Visualizzazione delle informazioni sulle versioni dei flussi in Amazon Bedrock
Per scoprire come visualizzare le informazioni sulle versioni di un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per vedere le informazioni su una versione di un flusso**
1. Apri la [Console di gestione AWS](https://console.aws.amazon.com/) e accedi all’account. Vai ad Amazon Bedrock.
1. Seleziona **Flussi** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Flussi**, seleziona un flusso che intendi visualizzare.
1. Scegli la versione da visualizzare nella sezione **Versioni**.
1. Per visualizzare i dettagli sui nodi e le configurazioni collegati alla versione del flusso, seleziona il nodo e visualizza i dettagli nel riquadro **Generatore di flussi**. Per apportare modifiche al flusso, usa la bozza di lavoro e crea una nuova versione.
------
#### [ API ]
Per ottenere informazioni su una versione del flusso, invia una richiesta [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`. Nel campo `flowVersion`, specifica il numero di versione.
Per elencare le informazioni per tutte le versioni di un flusso, invia una richiesta [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`. È inoltre possibile specificare i parametri opzionali seguenti:
****
| 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. |
------
# Eliminare una versione di un flusso in Amazon Bedrock
Per scoprire come eliminare una versione di un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per eliminare una versione di un flusso**
1. Apri la [Console di gestione AWS](https://console.aws.amazon.com/) e accedi all’account. Vai ad Amazon Bedrock.
1. Seleziona **Flussi** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Flussi**, seleziona un flusso.
1. Scegli **Elimina**.
1. Viene visualizzata una finestra di dialogo che ti informa delle conseguenze dell’eliminazione. Per confermare l’eliminazione della versione, immetti **delete** nel campo di input e scegli **Elimina**.
1. Viene visualizzato un banner blu per informarti che la versione sta per essere eliminata. Al termine dell’eliminazione, viene visualizzato un banner che notifica la riuscita dell’operazione.
------
#### [ API ]
Per eliminare una versione di un flusso, invia una richiesta [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Specifica l’ARN o l’ID del flusso nel campo `flowIdentifier` e la versione da eliminare nel campo `flowVersion`.
------
# Creare un alias di un flusso in Amazon Bedrock
Per invocare un flusso, devi prima creare un alias che punti a una versione del flusso. Per scoprire come creare un alias, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per creare un alias per Amazon Bedrock Flows**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, scegli un flusso nella sezione **Flussi**.
1. Nella sezione **Alias** scegli **Crea alias**.
1. Inserisci un nome univoco per l’alias e una descrizione facoltativa.
1. Scegli una delle seguenti opzioni:
+ Per creare una nuova versione, scegli **Creare una nuova versione e associarla a questo alias**.
+ Per utilizzare una versione esistente, scegli **Usare una versione esistente per associare questo alias**. Nel menu a discesa, scegli la versione a cui associare l’alias.
1. Seleziona **Crea alias**. Nella parte superiore viene visualizzato un banner per informarti che l’operazione è riuscita.
------
#### [ API ]
Per creare un alias che punti a una versione del flusso, invia una richiesta [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) a un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).
I seguenti campi sono obbligatori:
****
| Campo | Descrizione di base |
| --- | --- |
| flowIdentifier | L’ARN o l’ID del flusso per il quale creare un alias. |
| name | Un nome dell’alias. |
| routingConfiguration | Specifica la versione a cui mappare l’alias nel campo flowVersion. |
I seguenti campi sono facoltativi:
****
| Campo | Caso d’uso |
| --- | --- |
| description | Per inserire una descrizione per l’alias. |
| clientToken | Per impedire la duplicazione della richiesta. |
------
La creazione di un alias produce una risorsa con un identificatore e un nome della risorsa Amazon (ARN) che puoi specificare quando invochi un flusso dalla tua applicazione. Per scoprire come invocare un flusso, consulta [Testare un flusso in Amazon Bedrock](flows-test.md).
# Visualizzare informazioni sugli alias dei flussi in Amazon Bedrock
Per scoprire come visualizzare le informazioni sugli alias di un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per visualizzare i dettagli di un alias**
1. Apri la [Console di gestione AWS](https://console.aws.amazon.com/) e accedi all’account. Vai ad Amazon Bedrock.
1. Seleziona **Flussi** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Flussi**, seleziona un flusso.
1. Scegli l’alias da visualizzare nella sezione **Alias**.
1. Puoi visualizzare il nome e la descrizione dell’alias e dei tag associati all’alias.
------
#### [ API ]
Per ottenere informazioni sull’alias di flusso, invia una richiesta [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`. Nel campo `aliasIdentifier`, specifica l’ID o l’ARN dell’alias.
Per elencare le informazioni per tutti gli alias di un flusso, invia una richiesta [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [endpoint in fase di build Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`. È inoltre possibile specificare i parametri opzionali seguenti:
****
| 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. |
------
# Modificare l’alias di un flusso in Amazon Bedrock
Per scoprire come modificare l’alias di un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per modificare un alias**
1. Apri la [Console di gestione AWS](https://console.aws.amazon.com/) e accedi all’account. Vai ad Amazon Bedrock.
1. Seleziona **Flussi** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Flussi**, seleziona un flusso.
1. Nella sezione **Alias**, scegli il pulsante di opzione accanto all’alias che desideri modificare.
1. Puoi modificare il nome e la descrizione dell’alias. Inoltre, puoi eseguire una delle seguenti operazioni:
+ Per creare una nuova versione e associare l’alias a quella versione, scegli **Creare una nuova versione e associarla all’alias**.
+ Per associare questo alias a una versione esistente diversa, scegli **Usare una versione esistente e associare l’alias**.
1. Seleziona **Salva**.
------
#### [ API ]
Per aggiornare un alias, invia una richiesta [UpdateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Includi nella richiesta sia i campi da mantenere che quelli da modificare.
------
# Eliminare l’alias di un flusso in Amazon Bedrock
Per scoprire come eliminare l’alias di un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per eliminare un alias**
1. Apri la [Console di gestione AWS](https://console.aws.amazon.com/) e accedi all’account. Vai ad Amazon Bedrock.
1. Seleziona **Flussi** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Flussi**, seleziona un flusso.
1. Per scegliere l’alias da eliminare, nella sezione **Alias**, scegli il pulsante di opzione accanto all’alias che desideri eliminare.
1. Scegli **Elimina**.
1. Viene visualizzata una finestra di dialogo che ti informa delle conseguenze dell’eliminazione. Per confermare che desideri eliminare l’alias, immetti **delete** nel campo input, quindi scegli **Elimina**.
1. Viene visualizzato un banner per informarti che l’alias sta per essere eliminato. Al termine dell’eliminazione, viene visualizzato un banner che notifica la riuscita dell’operazione.
------
#### [ API ]
Per eliminare l’alias di un flusso, invia una richiesta [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Specifica l’ARN o l’ID del flusso nel campo `flowIdentifier` e l’ARN o l’ID dell’alias da eliminare nel campo `aliasIdentifier`.
------
# Richiama una AWS Lambda funzione da un flusso Amazon Bedrock in un altro account AWS
Un flusso Amazon Bedrock può richiamare una AWS Lambda funzione che si trova in un AWS account diverso dal flusso. Utilizza la procedura seguente per configurare la funzione Lambda (*Account A*) e il flusso (*Account B*).
**Per configurare un flusso di flusso per chiamare una funzione Lambda in un account diverso AWS**
1. Nell’Account A (funzione Lambda), aggiungi una policy basata sulle risorse alla funzione Lambda, utilizzando il Ruolo di esecuzione del flusso dell’Account B come principale. Per ulteriori informazioni, consulta [Concessione dell’accesso alla funzione Lambda ad altri account](https://docs.aws.amazon.com/lambda/latest/dg/permissions-function-cross-account.html) nella documentazione *AWS Lambda*.
1. Nell’Account B (flusso Amazon Bedrock), aggiungi l’autorizzazione per l’operazione [invocare](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) al ruolo di esecuzione del flusso per l’ARN della funzione Lambda che stai utilizzando. Per ulteriori informazioni, consulta [Aggiornamento delle autorizzazioni per un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) nella documentazione *AWS Identity and Access Management*.
# Conversare con un flusso Amazon Bedrock
**Nota**
La conversazione multi-turno di Amazon Bedrock Flows è in versione di anteprima per Amazon Bedrock ed è soggetta a modifiche.
La conversazione a più turni di Amazon Bedrock Flows consente back-and-forth conversazioni dinamiche tra utenti e flussi, simili a un dialogo naturale. Quando un nodo agente richiede chiarimenti o contesto aggiuntivo, può mettere in pausa in modo intelligente l’esecuzione del flusso e chiedere all’utente informazioni specifiche. Si determina così un’esperienza più interattiva e accurata rispetto al contesto, poiché il nodo può adattare il proprio comportamento in base alle risposte degli utenti. Ad esempio, se una richiesta iniziale dell’utente è ambigua o incompleta, il nodo può porre domande successive per raccogliere i dettagli necessari. Dopo che l’utente ha inviato le informazioni richieste, il flusso riprende senza problemi l’esecuzione con gli input arricchiti, garantendo risultati più accurati e pertinenti. Questa funzionalità è particolarmente utile per scenari complessi in cui una singola interazione potrebbe non essere sufficiente per comprendere e soddisfare appieno le esigenze dell’utente.
**Topics**
+ [Come elaborare una conversazione multi-turno in un flusso](#flows-multi-turn-invocation-how)
+ [Creazione ed esecuzione di un flusso di esempio](#flows-multi-turn-invocation-example-flow)
## Come elaborare una conversazione multi-turno in un flusso
Per utilizzare una conversazione multi-turno in un flusso, è necessario un [nodo agente](flows-nodes.md#flows-nodes-agent) collegato a un agente di Amazon Bedrock. Durante l’esecuzione di un flusso, si ha una conversazione multi-turno quando l’agente necessita di ulteriori informazioni dall’utente prima di poter continuare. Questa sezione descrive un flusso che utilizza un agente con le seguenti istruzioni:
```
You are a playlist creator for a radio station.
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.
```
Per informazioni sulla creazione di un agente, consulta [Automazione delle attività nella propria applicazione utilizzando agenti IA](agents.md).
### Fase 1. Avvio del flusso
Si avvia un flusso chiamando l'[InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)operazione. Includi il contenuto iniziale che desideri inviare al flusso. Nell’esempio seguente, il campo `document` contiene una richiesta *Crea una playlist*. Ogni conversazione ha un identificatore univoco (*ID di esecuzione*) che identifica la conversazione all’interno del flusso. Per ottenere l’ID di esecuzione, non invii il campo `executionID` durante la prima chiamata a `InvokeFlow`. La risposta di `InvokeFlow` include l’ID di esecuzione. Nel codice, usa l’identificatore per tenere traccia di più conversazioni e identificare una conversazione nelle successive chiamate all’operazione `InvokeFlow`.
Di seguito è riportato un esempio JSON di richiesta `InvokeFlow`.
```
{
"flowIdentifier": "XXXXXXXXXX",
"flowAliasIdentifier": "YYYYYYYYYY",
"inputs": [
{
"content": {
"document": "Create a playlist."
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
]
}
```
### Fase 2. Recupero delle richieste dell’agente
Se il nodo agente nel flusso decide che gli servono ulteriori informazioni da parte dell’utente, lo streaming di risposte (`responseStream`) provenienti da `InvokeFlow` include un oggetto evento `FlowMultiTurnInputRequestEvent`. L’evento contiene le informazioni richieste nel campo `content` (`FlowMultiTurnInputContent`). Nell’esempio seguente, la richiesta nel campo `document` riguarda informazioni sul numero di brani, sul genere musicale e sul tema della playlist. Nel codice, è quindi necessario acquisire tali informazioni dall’utente.
Di seguito è riportato un esempio dell’oggetto JSON `FlowMultiTurnInputRequestEvent`.
```
{
"nodeName": "AgentsNode_1",
"nodeType": "AgentNode",
"content": {
"document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
1. How many songs would you like in the playlist?
2. What genre of music do you prefer?
3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
}
}
```
Poiché il flusso non può continuare finché non si riceve ulteriore input, il flusso emette anche un evento `FlowCompletionEvent`. Un flusso emette sempre `FlowMultiTurnInputRequestEvent` prima di `FlowCompletionEvent`. Se il valore di `completionReason` nell’evento `FlowCompletionEvent` è `INPUT_REQUIRED`, il flusso necessita di ulteriori informazioni prima di poter continuare.
Di seguito è riportato un esempio dell’oggetto JSON `FlowCompletionEvent`.
```
{
"completionReason": "INPUT_REQUIRED"
}
```
### Fase 3. Invio della risposta dell’utente al flusso
Invia di nuovo la risposta dell’utente al flusso chiamando nuovamente l’operazione `InvokeFlow`. Assicurati di includere `executionId` nella conversazione.
Di seguito è riportato un esempio JSON per la richiesta `InvokeFlow`. Il campo `document` contiene la risposta dell’utente.
```
{
"flowIdentifier": "AUS7BMHXBE",
"flowAliasIdentifier": "4KUDB8VBEF",
"executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
"inputs": [
{
"content": {
"document": "1. 5 songs 2. Welsh rock music 3. Castles"
},
"nodeName": "AgentsNode_1",
"nodeInputName": "agentInputText"
}
]
}
```
Se necessita di altre informazioni, il flusso crea ulteriori eventi `FlowMultiTurnInputRequestEvent`.
### Fase 4. Fine del flusso
Quando non sono necessarie ulteriori informazioni, il flusso emette un evento `FlowOutputEvent` che contiene la risposta finale.
Di seguito è riportato un esempio dell’oggetto JSON `FlowOutputEvent`.
```
{
"nodeName": "FlowOutputNode",
"content": {
"document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles.
Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems
Description: A 5-song Welsh rock playlist featuring songs about castles
Songs:
1. Castell y Bere - Super Furry Animals
2. The Castle - Manic Street Preachers
3. Caerdydd (Cardiff Castle) - Stereophonics
4. Castell Coch - Catatonia
5. Chepstow Castle - Feeder
This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles.
Enjoy your castle-themed Welsh rock music experience!"
}
}
```
Il flusso emette anche un evento `FlowCompletionEvent`. Il valore di `completionReason` è `SUCCESS`.
Di seguito è riportato un esempio dell’oggetto JSON `FlowCompletionEvent`.
```
{
"completionReason": "SUCCESS"
}
```
Il seguente diagramma di sequenza mostra le fasi di un flusso multi-turno.
![\[Fasi del flusso per una conversazione multi-turno.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png)
## Creazione ed esecuzione di un flusso di esempio
In questo esempio, creerai un flusso che utilizza un agente per creare playlist per una stazione radio. L’agente pone domande chiarificatrici per stabilire il numero di brani, il genere musicale e il tema della playlist.
**Per creare il flusso**
1. Crea un agente nella console Amazon Bedrock seguendo le istruzioni disponibili in [Creazione e configurazione manuale dell’agente](agents-create.md).
+ Per la fase *2.d*, inserisci **You are a playlist creator for a radio station. When asked to create a playlist, ask for the number of songs, the genre of music, and a theme for the playlist.**.
+ Per la fase *2.e*, in **Input dell’utente**, scegli **Abilitato**. In questo modo l’agente può chiedere ulteriori informazioni, se necessario.
1. Crea il flusso seguendo le istruzioni in [Creare e progettare un flusso in Amazon Bedrock](flows-create.md). Assicurati che il flusso abbia un nodo di input, un nodo agente e un nodo di output.
1. Collega il nodo agente all’agente creato nella fase 1. Il risultato sarà simile all’immagine seguente.
![\[Conversazione multi-turno del flusso\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/flows/flows-multi-turn.png)
1. Esegui il flusso nella console Amazon Bedrock. Per i test, puoi tracciare le fasi eseguite dal flusso. Per ulteriori informazioni, consulta [Testare un flusso in Amazon Bedrock](flows-test.md).
Il seguente esempio di codice Python mostra come utilizzare il flusso.
Per eseguire il codice, specifica quanto segue:
+ `region_name`— La AWS regione in cui si esegue il flusso.
+ `FLOW_ID`: l’ID del flusso.
+ `FLOW_ALIAS_ID`: l’ID alias del flusso.
Per informazioni su come ottenere il IDs, vedere[Visualizzare informazioni sui flussi in Amazon Bedrock](flows-view.md). Il codice effettua una richiesta iniziale da inviare al flusso e chiede ulteriore input in base alle esigenze del flusso. Il codice non gestisce altre richieste dell'agente, come le richieste di chiamata a AWS Lambda funzioni. Per ulteriori informazioni, consulta [Come funziona Agent per Amazon Bedrock](agents-how.md). Durante l’esecuzione, il codice genera oggetti `FlowTraceEvent` che è possibile utilizzare per tracciare il percorso dall’input alla risposta restituita dal flusso. Per ulteriori informazioni, consulta [Tenere traccia di ciascuna fase del flusso visualizzandone la traccia in Amazon BedrockTenere traccia di ciascuna fase del flusso visualizzandone la traccia](flows-trace.md).
```
"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime
flow_id: The ID of the flow to invoke
flow_alias_id: The alias ID of the flow
input_data: Input data for the flow
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
if __name__ == "__main__":
session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Replace these with your actual flow ID and alias ID
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
logger.info("Starting flow %s", FLOW_ID)
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", FLOW_ID)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", FLOW_ID)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
```
# Eseguire esempi di codice Amazon Bedrock Flows
I seguenti esempi di codice presuppongono che tu abbia soddisfatto i seguenti prerequisiti:
1. Configura un ruolo per acquisire le autorizzazioni per le azioni di Amazon Bedrock. Se non lo hai già fatto, consulta [Guida introduttiva](getting-started.md).
1. Configura le tue credenziali per utilizzare l’API AWS. Se non lo hai già fatto, consulta [Iniziare a utilizzare l’API](getting-started-api.md).
1. Crea un ruolo di servizio per eseguire azioni relative al flusso per tuo conto. Se non lo hai già fatto, consulta [Creare un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).
Per creare un flusso, invia una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Per l’esempio di codice, consulta [Eseguire esempi di codice Amazon Bedrock Flows](#flows-code-ex)
I seguenti campi sono obbligatori:
****
| Campo | Descrizione di base |
| --- | --- |
| name | Un nome per il flusso. |
| executionRoleArn | L’ARN del [ruolo di servizio con le autorizzazioni per creare e gestire i flussi](flows-permissions.md). |
I seguenti campi sono facoltativi:
****
| Campo | Caso d’uso |
| --- | --- |
| definizione | Contiene i nodes e le connections che compongono il flusso. |
| description | Per descrivere il flusso. |
| tag | Per associare tag al flusso. Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse Amazon Bedrock](tagging.md). |
| customerEncryptionKeyArn | Per crittografare la risorsa con una chiave KMS. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon Bedrock Flows](encryption-flows.md). |
| clientToken | Per garantire che la richiesta API venga completata solo una volta. Per ulteriori informazioni, consulta [Garanzia di idempotenza](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). |
Sebbene il campo `definition` sia facoltativo, è necessario per il funzionamento del flusso. Puoi scegliere di creare prima un flusso senza la definizione e aggiornare il flusso in un secondo momento.
Per ogni nodo dell’elenco `nodes`, specifica il tipo di nodo nel campo `type` e fornisci la configurazione corrispondente del nodo nel campo `config`. Per informazioni dettagliate sulla struttura API dei diversi tipi di nodi, consulta [Tipi di nodo per il flusso](flows-nodes.md).
Per provare alcuni esempi di codice per Amazon Bedrock Flows, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Python ]
1. Crea un flusso utilizzando una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) con i seguenti nodi:
+ Un nodo di input.
+ Un nodo prompt con un prompt definito inline che crea una playlist musicale utilizzando due variabili (`genre` e `number`).
+ Un nodo di output che restituisce il completamento del modello.
Esegui il seguente frammento di codice per caricare AWS SDK per Python (Boto3), crea un client Agent per Amazon Bedrock e crea un flusso con i nodi (sostituisci il campo `executionRoleArn` con l’ARN del ruolo di servizio che hai creato per il flusso):
```
# Import Python SDK and create client
import boto3
client = boto3.client(service_name='bedrock-agent')
# Replace with the service role that you created. For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-permissions.html
FLOWS_SERVICE_ROLE = "arn:aws:iam::123456789012:role/MyFlowsRole"
# Define each node
# The input node validates that the content of the InvokeFlow request is a JSON object.
input_node = {
"type": "Input",
"name": "FlowInput",
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
# This prompt node defines an inline prompt that creates a music playlist using two variables.
# 1. {{genre}} - The genre of music to create a playlist for
# 2. {{number}} - The number of songs to include in the playlist
# It validates that the input is a JSON object that minimally contains the fields "genre" and "number", which it will map to the prompt variables.
# The output must be named "modelCompletion" and be of the type "String".
prompt_node = {
"type": "Prompt",
"name": "MakePlaylist",
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": "amazon.nova-lite-v1:0",
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
# The output node validates that the output from the last node is a string and returns it as is. The name must be "document".
output_node = {
"type": "Output",
"name": "FlowOutput",
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow input node and each input of the prompt node
for input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"], input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
# Create the flow from the nodes and connections
response = client.create_flow(
name="FlowCreatePlaylist",
description="A flow that creates a playlist given a genre and number of songs to include in the playlist.",
executionRoleArn=FLOWS_SERVICE_ROLE,
definition={
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
)
flow_id = response.get("id")
```
1. Elenca i flussi nel tuo account, incluso quello appena creato, eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flows()
```
1. Ottieni informazioni sul flusso che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow(flowIdentifier=flow_id)
```
1. Prepara il flusso in modo che vengano applicate le ultime modifiche della bozza di lavoro e in modo che sia pronto per la versione. Esegui il seguente frammento di codice per effettuare una richiesta [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.prepare_flow(flowIdentifier=flow_id)
```
1. Crea una versione della bozza di lavoro del flusso per creare una snapshot statica del flusso e poi recuperare le informazioni relative con le seguenti azioni:
1. Crea una versione eseguendo il seguente frammento di codice per effettuare una richiesta [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
response = client.create_flow_version(flowIdentifier=flow_id)
flow_version = response.get("version")
```
1. Elenca tutte le versioni del flusso eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flow_versions(flowIdentifier=flow_id)
```
1. Ottieni informazioni sulla versione eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Crea un alias per indicare la versione del flusso che hai creato, quindi recupera le informazioni su di esso con le seguenti azioni:
1. Crea un alias e puntalo alla versione che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
response = client.create_flow_alias(
flowIdentifier=flow_id,
name="latest",
description="Alias pointing to the latest version of the flow.",
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
flow_alias_id = response.get("id")
```
1. Elenca tutti gli alias del flusso eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
1. Ottieni informazioni sull’alias che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Esegui il seguente frammento di codice per creare un client di runtime di Agent per Amazon Bedrock e invocare un flusso. La richiesta inserisce le variabili nel prompt del flusso e restituisce la risposta del modello per effettuare una richiesta [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un [endpoint di runtime Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt):
```
client_runtime = boto3.client('bedrock-agent-runtime')
response = client_runtime.invoke_flow(
flowIdentifier=flow_id,
flowAliasIdentifier=flow_alias_id,
inputs=[
{
"content": {
"document": {
"genre": "pop",
"number": 3
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
]
)
result = {}
for event in response.get("responseStream"):
result.update(event)
if result['flowCompletionEvent']['completionReason'] == 'SUCCESS':
print("Flow invocation was successful! The output of the flow is as follows:\n")
print(result['flowOutputEvent']['content']['document'])
else:
print("The flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])
```
La risposta dovrebbe restituire una playlist di musica pop con tre brani.
1. Elimina l’alias, la versione e il flusso che hai creato con le seguenti azioni:
1. Elimina l’alias eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [endpoint in fase di build di Agent per Amazon Bedrock:](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt)
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Elimina la versione eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Elimina il flusso eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):
```
client.delete_flow(flowIdentifier=flow_id)
```
------
# Eliminare un flusso in Amazon Bedrock
Se un flusso non ti serve più, puoi eliminarlo. I flussi eliminati vengono mantenuti nei server AWS per un massimo di quattordici giorni. Per scoprire come eliminare un flusso, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:
------
#### [ Console ]
**Per eliminare un flusso**
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 **Amazon Bedrock Flows** nel riquadro di navigazione a sinistra. Quindi, nella sezione **Amazon Bedrock Flows**, seleziona un flusso da eliminare.
1. Scegli **Elimina**.
1. Viene visualizzata una finestra di dialogo che ti informa delle conseguenze dell’eliminazione. Per confermare l’eliminazione del flusso, immetti **delete** nel campo di input e scegli **Elimina**.
1. Viene visualizzato un banner per informarti che il flusso sta per essere eliminato. Al termine dell’eliminazione, viene visualizzato un banner che notifica la riuscita dell’operazione.
------
#### [ API ]
Per eliminare un flusso, invia una richiesta [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) e specifica l’ARN o l’ID del flusso come `flowIdentifier`.
------