Exécution d’exemples de code Amazon Bedrock Flows

Créez un flux à l’aide d’une demande CreateFlow avec un point de terminaison de compilation pour agents Amazon Bedrock avec les nœuds suivants :

Exécutez l’extrait de code suivant pour charger le kit AWS SDK pour Python (Boto3), créer un client pour agents Amazon Bedrock et créer un flux avec les nœuds (Remplacez le champ executionRoleArn par l’ARN du rôle de service que vous avez créé pour le flux.) :

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

Répertoriez les flux de votre compte, y compris celui que vous venez de créer, en exécutant l’extrait de code suivant pour effectuer une demande ListFlows avec un point de terminaison de compilation pour agents Amazon Bedrock :

client.list_flows()

Obtenez des informations sur le flux que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande GetFlow avec un point de terminaison de compilation pour agents Amazon Bedrock :

client.get_flow(flowIdentifier=flow_id)

Préparez votre flux de sorte que les modifications les plus récentes de la version préliminaire soient appliquées et qu’il soit prêt à être versionné. Exécutez l’extrait de code suivant pour effectuer une demande PrepareFlow avec un point de terminaison de compilation pour agents Amazon Bedrock :

client.prepare_flow(flowIdentifier=flow_id)

Versionnez la version préliminaire de votre flux pour créer un instantané statique de votre flux, puis récupérez les informations le concernant à l’aide des actions suivantes :

1. Créez une version en exécutant l’extrait de code suivant pour effectuer une demande CreateFlowVersion avec un point de terminaison de compilation pour agents Amazon Bedrock :

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

2. Répertoriez toutes les versions de votre flux en exécutant l’extrait de code suivant pour effectuer une demande ListFlowVersions avec un point de terminaison de compilation pour agents Amazon Bedrock :

   client.list_flow_versions(flowIdentifier=flow_id)

3. Obtenez des informations sur la version en exécutant l’extrait de code suivant pour effectuer une demande GetFlowVersion avec un point de terminaison de compilation pour agents Amazon Bedrock :

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

Créez un alias pour pointer vers la version de votre flux que vous avez créée, puis récupérez les informations le concernant à l’aide des actions suivantes :

1. Créez un alias et pointez-le vers la version que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande CreateFlowAlias avec un point de terminaison de compilation pour agents 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. Répertoriez tous les alias de votre flux en exécutant l’extrait de code suivant pour effectuer une demande ListFlowAliass avec un point de terminaison de compilation pour agents Amazon Bedrock :

   client.list_flow_aliases(flowIdentifier=flow_id)

3. Obtenez des informations sur l’alias que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande GetFlowAlias avec un point de terminaison de compilation pour agents Amazon Bedrock :

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

Exécutez l’extrait de code suivant pour créer un client d’exécution pour agents Amazon Bedrock et invoquer un flux. La demande renseigne les variables de l’invite de votre flux et renvoie la réponse du modèle pour effectuer une demande InvokeFlow avec un point de terminaison d’exécution des agents 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 réponse devrait renvoyer une liste de lecture de musique pop avec trois chansons.

Supprimez l’alias, la version et le flux que vous avez créés à l’aide des actions suivantes :

1. Supprimez l’alias en exécutant l’extrait de code suivant pour effectuer une demande DeleteFlowAlias avec un point de terminaison de compilation pour agents Amazon Bedrock :

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

2. Supprimez la version en exécutant l’extrait de code suivant pour effectuer une demande DeleteFlowVersion avec un point de terminaison de compilation pour agents Amazon Bedrock :

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

3. Supprimez le flux en exécutant l’extrait de code suivant pour effectuer une demande DeleteFlow avec un point de terminaison de compilation pour agents Amazon Bedrock :

   client.delete_flow(flowIdentifier=flow_id)