Ejecución de ejemplos de código de Flujos de Amazon Bedrock

Cree un flujo mediante una CreateFlowsolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock con los siguientes nodos:

Ejecute el siguiente fragmento de código para cargar AWS SDK para Python (Boto3), crear un cliente de Amazon Bedrock Agents y crear un flujo con los nodos (sustituya el executionRoleArn campo por el ARN de la función de servicio que creó para el flujo):

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

Enumere los flujos de su cuenta, incluido el que acaba de crear, ejecutando el siguiente fragmento de código para realizar una ListFlowssolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock:

client.list_flows()

Para obtener información sobre el flujo que acaba de crear, ejecute el siguiente fragmento de código para realizar una GetFlowsolicitud en un punto final de tiempo de compilación de Agents for Amazon Bedrock:

client.get_flow(flowIdentifier=flow_id)

Prepare el flujo para que se apliquen los cambios más recientes del borrador de trabajo y esté listo para la versión. Ejecute el siguiente fragmento de código para realizar una PrepareFlowsolicitud con un punto final en tiempo de compilación de Agents for Amazon Bedrock:

client.prepare_flow(flowIdentifier=flow_id)

Cree la versión del borrador de trabajo del flujo para crear una instantánea estática del flujo y, a continuación, obtenga la información sobre el trabajo mediante las siguientes acciones:

1. Cree una versión ejecutando el siguiente fragmento de código para realizar una CreateFlowVersionsolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock:

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

2. Enumere todas las versiones de su flujo ejecutando el siguiente fragmento de código para realizar una ListFlowVersionssolicitud en un punto final de tiempo de compilación de Agents for Amazon Bedrock:

   client.list_flow_versions(flowIdentifier=flow_id)

3. Para obtener información sobre la versión, ejecute el siguiente fragmento de código para realizar una GetFlowVersionsolicitud en un punto final de tiempo de compilación de Agents for Amazon Bedrock:

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

Cree un alias que apunte a la versión del flujo creado y, a continuación, recupere la información del flujo realizando las siguientes acciones:

1. Cree un alias y apúntelo a la versión que acaba de crear ejecutando el siguiente fragmento de código para realizar una CreateFlowAliassolicitud con un punto final en tiempo de compilación de Agents for 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. Enumere todos los alias de su flujo ejecutando el siguiente fragmento de código para realizar una ListFlowAliasssolicitud en un punto final de tiempo de compilación de Agents for Amazon Bedrock:

   client.list_flow_aliases(flowIdentifier=flow_id)

3. Para obtener información sobre el alias que acaba de crear, ejecute el siguiente fragmento de código para realizar una GetFlowAliassolicitud en un punto final de tiempo de compilación de Agents for Amazon Bedrock:

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

Ejecute el siguiente fragmento de código para crear un cliente de tiempo de ejecución para agentes de Amazon Bedrock e invoque un flujo. La solicitud rellena las variables de la solicitud de su flujo y devuelve la respuesta del modelo para realizar una InvokeFlowsolicitud con un punto final de ejecución de 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 respuesta debería devolver una lista de reproducción de música pop con tres canciones.

Elimine el alias, la versión y el flujo que ha creado con las siguientes acciones:

1. Elimine el alias ejecutando el siguiente fragmento de código para realizar una DeleteFlowAliassolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock:

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

2. Elimine la versión ejecutando el siguiente fragmento de código para realizar una DeleteFlowVersionsolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock:

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

3. Elimine el flujo ejecutando el siguiente fragmento de código para realizar una DeleteFlowsolicitud con un punto final de tiempo de compilación de Agents for Amazon Bedrock:

   client.delete_flow(flowIdentifier=flow_id)