Codebeispiele von Amazon Bedrock Flows ausführen

Bei den folgenden Codebeispielen wird davon ausgegangen, dass Sie die folgenden Voraussetzungen erfüllt haben:

Eine Rolle einrichten, um Berechtigungen für Amazon-Bedrock-Aktionen zu erhalten. Falls noch nicht geschehen, finden Sie weitere Informationen unter Erste Schritte mit Amazon Bedrock.
Ihre Anmeldeinformationen für die Verwendung der AWS-API einrichten. Falls noch nicht geschehen, finden Sie weitere Informationen unter Erste Schritte mit der API.
Eine Servicerolle erstellen, um Flow-bezogene Aktionen in Ihrem Namen ausführen zu lassen. Falls noch nicht geschehen, finden Sie weitere Informationen unter Erstellen einer Servicerolle für Amazon Bedrock Flows in Amazon Bedrock.

Um einen Flow zu erstellen, senden Sie eine CreateFlow-Anfrage mit einem Build-Time-Endpunkt von Agenten für Amazon Bedrock. Beispielcode finden Sie unter Codebeispiele von Amazon Bedrock Flows ausführen

Die folgenden Felder sind erforderlich:

Feld	Grundlegende Beschreibung
Name	Ein Name für den Flow.
executionRoleArn	Der ARN der Servicerolle mit Berechtigungen zum Erstellen und Verwalten von Flows.

Die folgenden Felder sind optional:

Feld	Anwendungsfall
definition	Enthält die `nodes` und `connections`, aus denen der Flow besteht.
description	Dient zur Beschreibung des Flows.
tags	Hiermit ordnen Sie dem Flow Tags zu. Weitere Informationen finden Sie unter Markieren von Amazon-Bedrock-Ressourcen.
customerEncryptionKeyArn	Dient zur Verschlüsselung der Ressource mit einem KMS-Schlüssel. Weitere Informationen finden Sie unter Verschlüsselung von Flow-Ressourcen von Amazon Bedrock.
clientToken	Zur Sicherstellung, dass die API-Anfrage nur einmal abgeschlossen wird. Weitere Informationen finden Sie unter Sicherstellen von Idempotenz.

Das Feld definition ist zwar optional, aber es ist erforderlich, damit der Flow funktioniert. Sie können sich dafür entscheiden, zuerst einen Flow ohne die Definition zu erstellen und den Flow später zu aktualisieren.

Für jeden Knoten in Ihrer nodes-Liste geben Sie den Knotentyp im Feld type an und legen seine entsprechende Konfiguration im Feld config fest. Einzelheiten zur API-Struktur verschiedener Knotentypen finden Sie unter Knotentypen für Ihren Flow.

Um einige Codebeispiele für Amazon Bedrock Flows auszuprobieren, wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und folgen Sie dann den nachstehenden Schritten:

Python

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

Ein Eingabeknoten.
Ein Prompt-Knoten mit definiertem Inline-Prompt, der eine Musik-Playlist mit zwei Variablen (genre und number) erstellt.
Ein Ausgabeknoten, der die Fertigstellung des Modells zurückgibt.

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)
```

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Konversation mit einem Flow

Einen Flow löschen