Ejecute ejemplos de código de Amazon Bedrock Flows

En los siguientes ejemplos de código se supone que cumple los siguientes requisitos previos:

Configurar un rol para tener permisos para las acciones de Amazon Bedrock. Si no lo tiene, consulte Introducción a Amazon Bedrock.
Configure sus credenciales para usar la AWS API. Si no lo ha hecho, consulte Introducción a la API de .
Cree un rol de servicio para llevar a cabo acciones relacionadas con el flujo en su nombre. Si no lo ha hecho, consulte Cree un rol de servicio para Amazon Bedrock Flows en Amazon Bedrock.

Para probar algunos ejemplos de código para Amazon Bedrock Flows, elija la pestaña del método que prefiera y, a continuación, siga los pasos:

Python

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

un nodo de entrada,
un nodo de petición con una petición definida en línea que crea una lista de reproducción de música con dos variables (genre y number),
un nodo de salida que devuelva la finalización del modelo.

Ejecute el siguiente fragmento de código para cargar AWS SDK for 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.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")

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()
```
Obtenga información sobre el flujo que acaba de crear ejecutando 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 una versión del borrador de trabajo del flujo para crear una instantánea estática del flujo y, a continuación, recupere la información sobre el flujo 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 que ha creado y, a continuación, recupere información sobre ella con 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="FLOW123456",
    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 creó 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)
```

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Converse con un flujo

Eliminar un flujo