Run Amazon Bedrock Prompt flows code samples

Note

Amazon Bedrock Prompt flows is in preview and is subject to change.

The following code samples assume that you've fulfilled the following prerequisites:

Set up a role to have permissions to Amazon Bedrock actions. If you haven't, refer to Getting started with Amazon Bedrock.
Set up your credentials to use the AWS API. If you haven't, refer to Getting started with the AWS API.
Create a service role to carry out prompt flow-related actions on your behalf. If you haven't, refer to Create a service role for Amazon Bedrock Prompt flows in Amazon Bedrock.

To try out some code samples for Amazon Bedrock Prompt flows, select the tab corresponding to your method of choice and follow the steps:

Python

Create a prompt flow using a CreateFlow request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint with the following nodes:

An input node.
A prompt node with a prompt defined inline that creates a music playlist using two variables (genre and number).
An output node that returns the model completion.

Run the following code snippet to load the AWS SDK for Python (Boto3), create an Amazon Bedrock Agents client, and create a prompt flow with the nodes (replace the executionRoleArn field with the ARN of your the service role that you created for prompt flow):


# 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/MyPromptFlowsRole"

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

List the prompt flows in your account, including the one you just created, by running the following code snippet to make a ListFlows request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.list_flows()
```
Get information about the prompt flow that you just created by running the following code snippet to make a GetFlow request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.get_flow(flowIdentifier=flow_id)
```
Prepare your prompt flow so that the latest changes from the working draft are applied and so that it's ready to version. Run the following code snippet to make a PrepareFlow request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.prepare_flow(flowIdentifier=flow_id)
```
Version the working draft of your prompt flow to create a static snapshot of your prompt flow and then retrieve information about it with the following actions:
1. Create a version by running the following code snippet to make a CreateFlowVersion request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
response = client.create_flow_version(flowIdentifier=flow_id)
                                
flow_version = response.get("version")
```
2. List all versions of your prompt flow by running the following code snippet to make a ListFlowVersions request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.list_flow_versions(flowIdentifier=flow_id)
```
3. Get information about the version by running the following code snippet to make a GetFlowVersion request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
Create an alias to point to the version of your prompt flow that you created and then retrieve information about it with the following actions:
1. Create an alias and point it to the version you just created by running the following code snippet to make a CreateFlowAlias request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
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. List all aliases of your prompt flow by running the following code snippet to make a ListFlowAliass request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
3. Get information about the alias that you just created by running the following code snippet to make a GetFlowAlias request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```

Run the following code snippet to create an Amazon Bedrock Agents Runtime client and invoke a flow. The request fills in the variables in the prompt in your prompt flow and returns the response from the model to make a InvokeFlow request (see link for request and response formats and field details) with an Agents for Amazon Bedrock runtime endpoint:


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("Prompt flow invocation was successful! The output of the prompt flow is as follows:\n")
    print(result['flowOutputEvent']['content']['document'])

else:
    print("The prompt flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])

The response should return a playlist of pop music with three songs.

Delete the alias, version, and prompt flow that you created with the following actions:
1. Delete the alias by running the following code snippet to make a DeleteFlowAlias request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
2. Delete the version by running the following code snippet to make a DeleteFlowVersion request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
3. Delete the flow by running the following code snippet to make a DeleteFlow request (see link for request and response formats and field details) with an Agents for Amazon Bedrock build-time endpoint:
```
client.delete_flow(flowIdentifier=flow_id)
```

Warning Javascript is disabled or is unavailable in your browser.

To use the Amazon Web Services Documentation, Javascript must be enabled. Please refer to your browser's Help pages for instructions.

Document Conventions

Delete a prompt flow

Customize a model for your use case