Executar exemplos de código do recurso Fluxos do Amazon Bedrock

Crie um fluxo usando uma solicitação CreateFlow com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock com os seguintes nós:

Execute o seguinte trecho de código para carregar o AWS SDK para Python (Boto3), crie um cliente para agentes do Amazon Bedrock e crie um fluxo com os nós (substitua o campo executionRoleArn pelo ARN do perfil de serviço que você criou para o fluxo):

# 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")

Liste os fluxos em sua conta, inclusive o que você acabou de criar, executando o seguinte trecho de código para fazer uma solicitação ListFlows com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

client.list_flows()

Obtenha informações sobre o fluxo que você acabou de criar executando o seguinte trecho de código para fazer uma solicitação GetFlow com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

client.get_flow(flowIdentifier=flow_id)

Prepare o fluxo para que as alterações mais recentes do rascunho de trabalho sejam aplicadas e para que ele esteja pronto para a versão. Execute o seguinte trecho de código para fazer uma solicitação PrepareFlow com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

client.prepare_flow(flowIdentifier=flow_id)

Crie uma versão do rascunho de trabalho do fluxo para criar um snapshot estático do fluxo e recuperar informações sobre ele com as seguintes ações:

1. Crie uma versão executando o seguinte trecho de código para fazer uma solicitação CreateFlowVersion com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   response = client.create_flow_version(flowIdentifier=flow_id)
                                   
   flow_version = response.get("version")

2. Liste todas as versões do fluxo executando o seguinte trecho de código para fazer uma solicitação ListFlowVersions com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.list_flow_versions(flowIdentifier=flow_id)

3. Obtenha informações sobre a versão executando o seguinte trecho de código para fazer uma solicitação GetFlowVersion com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)

Crie um alias para apontar para a versão do fluxo que você criou e recupere as informações sobre ele com as seguintes ações:

1. Crie um alias e aponte-o para a versão que você acabou de criar executando o seguinte trecho de código para fazer uma solicitação CreateFlowAlias com um endpoint de tempo de compilação do recurso Agentes para 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. Liste todos os aliases do fluxo executando o seguinte trecho de código para fazer uma solicitação ListFlowAlias com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.list_flow_aliases(flowIdentifier=flow_id)

3. Obtenha informações sobre o alias que você acabou de criar executando o seguinte trecho de código para fazer uma solicitação GetFlowAlias com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)

Execute o trecho de código a seguir para criar um cliente do Amazon Bedrock Agents Runtime e invoque um fluxo. A solicitação preenche as variáveis no prompt no fluxo e exibe a resposta do modelo para fazer uma solicitação InvokeFlow com um endpoint de runtime do recurso Agentes para 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'])

A resposta deve apresentar uma playlist com três músicas pop.

Exclua o alias, a versão e o fluxo que você criou com as seguintes ações:

1. Exclua o alias executando o seguinte trecho de código para fazer uma solicitação DeleteFlowAlias com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)

2. Exclua a versão executando o seguinte trecho de código para fazer uma solicitação DeleteFlowVersion com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)

3. Exclua o fluxo executando o seguinte trecho de código para fazer uma solicitação DeleteFlow com um endpoint de tempo de compilação do recurso Agentes para Amazon Bedrock:

   client.delete_flow(flowIdentifier=flow_id)