Esegui esempi di codice Amazon Bedrock Flows

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

Configura un ruolo per avere le autorizzazioni per le azioni di Amazon Bedrock. Se non l'hai fatto, consulta. Guida introduttiva ad Amazon Bedrock
Configura le tue credenziali per utilizzare l' AWS API. Se non l'hai fatto, fai riferimento a. Nozioni di base sull'API
Crea un ruolo di servizio per eseguire azioni relative al flusso per tuo conto. Se non l'hai fatto, fai riferimento a. Crea un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock

Per provare alcuni esempi di codice per Amazon Bedrock Flows, scegli la scheda corrispondente al tuo metodo preferito, quindi segui i passaggi:

Python

Crea un flusso utilizzando una CreateFlowrichiesta con un endpoint in fase di costruzione di Agents for Amazon Bedrock con i seguenti nodi:

Un nodo di input.
Un nodo prompt con un prompt definito in linea che crea una playlist musicale utilizzando due variabili (genree). number
Un nodo di output che restituisce il completamento del modello.

Esegui il seguente frammento di codice per caricare AWS SDK for Python (Boto3), creare un client Amazon Bedrock Agents e creare un flusso con i nodi (sostituisci il executionRoleArn campo con l'ARN del ruolo di servizio che hai creato per flow):


# 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.titan-text-express-v1",
                    "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 del tuo account, incluso quello appena creato, eseguendo il seguente frammento di codice per effettuare una ListFlowsrichiesta a un endpoint di build di Agents for Amazon Bedrock:
```
client.list_flows()
```
Ottieni informazioni sul flusso che hai appena creato eseguendo il seguente frammento di codice per effettuare una GetFlowrichiesta a un endpoint in fase di costruzione di Agents for 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 PrepareFlowrichiesta con un endpoint di compilazione Agents for Amazon Bedrock:
```
client.prepare_flow(flowIdentifier=flow_id)
```
Modifica la bozza di lavoro del flusso per creare un'istantanea statica del flusso e quindi recupera le informazioni su di esso con le seguenti azioni:
1. Crea una versione eseguendo il seguente frammento di codice per effettuare una CreateFlowVersionrichiesta con un endpoint di build Agents for 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 ListFlowVersionsrichiesta con un endpoint in fase di compilazione di Agents for Amazon Bedrock:
```
client.list_flow_versions(flowIdentifier=flow_id)
```
3. Ottieni informazioni sulla versione eseguendo il seguente frammento di codice per effettuare una GetFlowVersionrichiesta con un endpoint di compilazione di Agents for 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 indirizzalo alla versione che hai appena creato eseguendo il seguente frammento di codice per effettuare una CreateFlowAliasrichiesta con un endpoint di compilazione di Agents for Amazon Bedrock:
```
response = client.create_flow_alias(
    flowIdentifier="FLOW123456",
    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 ListFlowAliassrichiesta con un endpoint in fase di compilazione di Agents for 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 GetFlowAliasrichiesta a un endpoint in fase di costruzione di Agents for Amazon Bedrock:
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```

Esegui il seguente frammento di codice per creare un client Amazon Bedrock Agents Runtime e richiamare un flusso. La richiesta inserisce le variabili nel prompt del flusso e restituisce la risposta del modello per effettuare una InvokeFlowrichiesta con un endpoint di runtime Agents for 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 DeleteFlowAliasrichiesta con un endpoint di compilazione di Agents for 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 DeleteFlowVersionrichiesta con un endpoint di build Agents for 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 DeleteFlowrichiesta con un endpoint di build Agents for 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

Conversate con un flusso

Eliminare un flusso