Codebeispiele von Amazon Bedrock Flows ausführen

Erstellen Sie einen Flow mithilfe einer CreateFlow-Anfrage mit einem Build-Time-Endpunkt für Agenten für Amazon Bedrock mit den folgenden Knoten:

Führen Sie den folgenden Codeausschnitt aus, um den AWS SDK für Python (Boto3) zu laden, einen Agenten-Client von Amazon Bedrock zu erstellen und einen Flow mit den Knoten zu erstellen (ersetzen Sie das Feld executionRoleArn durch den ARN Ihrer Servicerolle, die Sie für den Flow erstellt haben):

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

Listen Sie die Flows in Ihrem Konto auf, einschließlich des gerade erstellten, indem Sie den folgenden Codeausschnitt ausführen, um eine ListFlows-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

client.list_flows()

Rufen Sie Informationen über den Flow ab, den Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine GetFlow-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

client.get_flow(flowIdentifier=flow_id)

Bereiten Sie Ihren Flow so vor, dass die neuesten Änderungen aus dem Arbeitsentwurf übernommen werden und er bereit für die Version ist. Führen Sie den folgenden Codeausschnitt aus, um eine PrepareFlow-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

client.prepare_flow(flowIdentifier=flow_id)

Versionieren Sie den Arbeitsentwurf Ihres Flows, um einen statischen Snapshot Ihres Flows zu erstellen, und rufen Sie dann mit den folgenden Aktionen Informationen darüber ab:

1. Erstellen Sie eine Version, indem Sie den folgenden Codeausschnitt ausführen, um eine CreateFlowVersion-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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

2. Listen Sie alle Versionen Ihres Flows auf, indem Sie den folgenden Codeausschnitt ausführen, um eine ListFlowVersions-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

   client.list_flow_versions(flowIdentifier=flow_id)

3. Rufen Sie Informationen über die Version ab, indem Sie den folgenden Codeausschnitt ausführen, um eine GetFlowVersion-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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

Erstellen Sie einen Alias, der auf die Version Ihres Flows verweist, die Sie erstellt haben, und rufen Sie dann mit den folgenden Aktionen Informationen darüber ab:

1. Erstellen Sie einen Alias, der auf die Version verweist, die Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine CreateFlowAlias-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

   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. Listen Sie alle Aliase Ihres Flows auf, indem Sie den folgenden Codeausschnitt ausführen, um eine ListFlowAliass-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

   client.list_flow_aliases(flowIdentifier=flow_id)

3. Rufen Sie Informationen über den Alias ab, den Sie gerade erstellt haben, indem Sie den folgenden Codeausschnitt ausführen, um eine GetFlowAlias-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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

Führen Sie den folgenden Codeausschnitt aus, um einen Laufzeit-Client der Agenten für Amazon Bedrock zu erstellen und einen Flow aufzurufen. Die Anfrage füllt die Variablen im Prompt Ihres Flows aus und gibt die Antwort des Modells zurück, um eine InvokeFlow-Anfrage mit einem Runtime-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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'])

Die Antwort sollte eine Popmusik-Playlist mit drei Songs zurückgeben.

Löschen Sie mit den folgenden Aktionen den Alias, die Version und den Flow, die Sie erstellt haben:

1. Löschen Sie den Alias, indem Sie den folgenden Codeausschnitt ausführen, um eine DeleteFlowAlias-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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

2. Löschen Sie die Version, indem Sie den folgenden Codeausschnitt ausführen, um eine DeleteFlowVersion-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

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

3. Löschen Sie den Flow, indem Sie den folgenden Codeausschnitt ausführen, um eine DeleteFlow-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock zu stellen:

   client.delete_flow(flowIdentifier=flow_id)