Eseguire esempi di codice Amazon Bedrock Flows

I seguenti esempi di codice presuppongono che tu abbia soddisfatto i seguenti prerequisiti:

Configura un ruolo per acquisire le autorizzazioni per le azioni di Amazon Bedrock. Se non lo hai già fatto, consulta Nozioni di base su Amazon Bedrock.
Configura le tue credenziali per utilizzare l’API AWS. Se non lo hai già fatto, consulta Iniziare a utilizzare l’API.
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.

Per creare un flusso, invia una richiesta CreateFlow con un endpoint in fase di build di Agent per Amazon Bedrock. Per l’esempio di codice, consulta Eseguire esempi di codice Amazon Bedrock Flows

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.

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.
customerEncryptionKeyArn	Per crittografare la risorsa con una chiave KMS. Per ulteriori informazioni, consulta Crittografia delle risorse Amazon Bedrock Flows.
clientToken	Per garantire che la richiesta API venga completata solo una volta. Per ulteriori informazioni, consulta Garanzia di idempotenza.

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.

Per provare alcuni esempi di codice per Amazon Bedrock Flows, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:

Python

Crea un flusso utilizzando una richiesta CreateFlow con un endpoint in fase di build di Agent per Amazon Bedrock 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")

Elenca i flussi nel tuo account, incluso quello appena creato, eseguendo il seguente frammento di codice per effettuare una richiesta ListFlows con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.list_flows()
```
Ottieni informazioni sul flusso che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta GetFlow con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.get_flow(flowIdentifier=flow_id)
```
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 con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.prepare_flow(flowIdentifier=flow_id)
```
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 con un endpoint in fase di build di Agent per Amazon Bedrock:
```
response = client.create_flow_version(flowIdentifier=flow_id)
                                
flow_version = response.get("version")
```
2. Elenca tutte le versioni del flusso eseguendo il seguente frammento di codice per effettuare una richiesta ListFlowVersions con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.list_flow_versions(flowIdentifier=flow_id)
```
3. Ottieni informazioni sulla versione eseguendo il seguente frammento di codice per effettuare una richiesta GetFlowVersion con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
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 con un endpoint in fase di build di Agent per Amazon Bedrock:
```
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")
```
2. Elenca tutti gli alias del flusso eseguendo il seguente frammento di codice per effettuare una richiesta ListFlowAliass con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
3. Ottieni informazioni sull’alias che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta GetFlowAlias con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```

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 con un endpoint di runtime Agent per Amazon Bedrock:


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.

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 con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
2. Elimina la versione eseguendo il seguente frammento di codice per effettuare una richiesta DeleteFlowVersion con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
3. Elimina il flusso eseguendo il seguente frammento di codice per effettuare una richiesta DeleteFlow con un endpoint in fase di build di Agent per Amazon Bedrock:
```
client.delete_flow(flowIdentifier=flow_id)
```

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Conversare con un flusso

Eliminare un flusso