Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Konversation mit einem Amazon-Bedrock-Flow

Multi-Turn-Konversation in Amazon Bedrock Flows ermöglicht dynamische Konversationen zwischen Benutzern und Flows, ähnlich einem natürlichen Dialog. Wenn ein Agenten-Knoten Erläuterungen oder zusätzlichen Kontext benötigt, kann er die Ausführung des Flows intelligent unterbrechen und den Benutzer zur Eingabe bestimmter Informationen auffordern. Dies sorgt für ein interaktiveres und kontextsensitiveres Erlebnis, da der Knoten sein Verhalten an die Benutzerantworten anpassen kann. Wenn beispielsweise eine ursprüngliche Benutzerabfrage mehrdeutig oder unvollständig ist, kann der Knoten nachfragen, um die erforderlichen Details zu erhalten. Sobald der Benutzer die angeforderten Informationen eingegeben hat, setzt der Flow die Ausführung mit der angereicherten Eingabe nahtlos fort, sodass genauere und relevantere Ergebnisse gewährleistet sind. Diese Funktion ist besonders nützlich für komplexe Szenarien, in denen eine einzige Interaktion möglicherweise nicht ausreicht, um die Anforderungen des Benutzers vollständig zu verstehen und zu erfüllen.

So verarbeiten Sie eine Multi-Turn-Konversation in einem Flow

Um eine Multi-Turn-Konversation in einem Flow zu verwenden, benötigen Sie einen Agenten-Knoten, der mit einem Amazon-Bedrock-Agenten verbunden ist. Wenn Sie den Flow ausführen, findet eine Multi-Turn-Konversation statt, wenn der Agent weitere Informationen vom Benutzer benötigt, bevor er fortfahren kann. In diesem Abschnitt wird ein Flow beschrieben, der einen Agenten mit den folgenden Anweisungen verwendet:

You are a playlist creator for a radio station. 
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.

Weitere Informationen zum Erstellen eines Agenten finden Sie unter Automatisieren von Aufgaben in einer Anwendung mithilfe von KI-Agenten.

Schritt 1: Starten des Flows

Sie starten einen Flow, indem Sie die Operation InvokeFlow aufrufen. Sie fügen den ursprünglichen Inhalt hinzu, den Sie an den Flow senden möchten. Im folgenden Beispiel enthält das Feld document die Anforderung Create a playlist zum Erstellen einer Playlist. Jede Konversation besitzt eine eindeutige Kennung (Ausführungs-ID), die die Konversation innerhalb des Flows identifiziert. Um die Ausführungs-ID zu erhalten, senden Sie das Feld executionID bei Ihrem ersten Aufruf nicht an InvokeFlow. Die Antwort von InvokeFlow enthält die Ausführungs-ID. Verwenden Sie in Ihrem Code die Kennung, um mehrere Konversationen nachzuverfolgen und eine Konversation in weiteren Aufrufen der Operation InvokeFlow zu identifizieren.

Nachstehend finden Sie ein JSON-Beispiel für die Anforderung InvokeFlow.

{
  "flowIdentifier": "XXXXXXXXXX",
  "flowAliasIdentifier": "YYYYYYYYYY",
  "inputs": [
    {
      "content": {
        "document": "Create a playlist."
      },
      "nodeName": "FlowInputNode",
      "nodeOutputName": "document"
    }
  ]
}

Schritt 2: Abrufen von Agenten-Anfragen

Wenn der Agenten-Knoten im Flow entscheidet, dass er weitere Informationen vom Benutzer benötigt, enthält der Antwortstream (responseStream) von InvokeFlow ein FlowMultiTurnInputRequestEvent-Ereignisobjekt. Das Ereignis enthält die angeforderten Informationen im Feld content (FlowMultiTurnInputContent). Im folgenden Beispiel bezieht sich die Anforderung im Feld document auf Informationen über die Anzahl der Songs, das Musikgenre und das Thema für die Playlist. In Ihrem Code müssen Sie diese Informationen dann vom Benutzer abrufen.

Nachfolgend finden Sie ein Beispiel für ein FlowMultiTurnInputRequestEvent-JSON-Objekt.

{
    "nodeName": "AgentsNode_1",
    "nodeType": "AgentNode",
    "content": {
        "document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
        1. How many songs would you like in the playlist?
        2. What genre of music do you prefer? 
        3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
    }
}

Da der Flow erst fortgesetzt werden kann, wenn weitere Eingaben empfangen wurden, gibt der Flow auch ein FlowCompletionEvent-Ereignis aus. Ein Flow gibt immer das FlowMultiTurnInputRequestEvent vor dem FlowCompletionEvent aus. Wenn der Wert von completionReason im FlowCompletionEvent-Ereignis INPUT_REQUIRED ist, benötigt der Flow weitere Informationen, bevor er fortgesetzt werden kann.

Nachfolgend finden Sie ein Beispiel für ein FlowCompletionEvent-JSON-Objekt.

{
    "completionReason": "INPUT_REQUIRED"
}

Schritt 3: Senden der Benutzerantwort an den Flow

Senden Sie die Benutzerantwort zurück an den Flow, indem Sie die Operation InvokeFlow erneut aufrufen. Es ist wichtig, dass Sie die executionId für die Konversation angeben.

Im Folgenden sehen Sie ein JSON-Beispiel für die Anforderung InvokeFlow. Das Feld document enthält die Antwort vom Benutzer.

{
  "flowIdentifier": "AUS7BMHXBE",
  "flowAliasIdentifier": "4KUDB8VBEF",
  "executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
  "inputs": [
    {
      "content": {
        "document": "1. 5 songs 2. Welsh rock music 3. Castles"
      },
      "nodeName": "AgentsNode_1",
      "nodeInputName": "agentInputText"
    }
  ]
}

Wenn der Flow noch mehr Informationen benötigt, erzeugt er weitere FlowMultiTurnInputRequestEvent-Ereignisse.

Schritt 4: Beenden des Flows

Wenn keine weiteren Informationen benötigt werden, gibt der Flow ein FlowOutputEvent-Ereignis aus, das die endgültige Antwort enthält.

Nachfolgend finden Sie ein Beispiel für ein FlowOutputEvent-JSON-Objekt.

{
    "nodeName": "FlowOutputNode",
    "content": {
        "document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles. 
        Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems 
        Description: A 5-song Welsh rock playlist featuring songs about castles 
        Songs: 
        1. Castell y Bere - Super Furry Animals 
        2. The Castle - Manic Street Preachers 
        3. Caerdydd (Cardiff Castle) - Stereophonics 
        4. Castell Coch - Catatonia 
        5. Chepstow Castle - Feeder 
        This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles. 
        Enjoy your castle-themed Welsh rock music experience!"
     }
}

Der Flow gibt auch ein FlowCompletionEvent-Ereignis aus. Der Wert von completionReason ist SUCCESS.

Nachfolgend finden Sie ein Beispiel für ein FlowCompletionEvent-JSON-Objekt.

{
    "completionReason": "SUCCESS"
}

Das folgende Ablaufdiagramm zeigt die Schritte in einem Multi-Turn-Flow.

Erstellen und Ausführen eines Beispiel-Flows

In diesem Beispiel erstellen Sie einen Flow, der mithilfe eines Agenten Playlisten für einen Radiosender erstellt. Der Agent stellt klärende Fragen, um die Anzahl der Songs, das Musikgenre und das Thema für die Playlist zu ermitteln.

Das folgende Python-Codebeispiel zeigt, wie der Flow verwendet wird.

Um den Code auszuführen, geben Sie Folgendes an:

Weitere Information zum Abrufen der IDs finden Sie unter Anzeigen von Informationen zu Flows in Amazon Bedrock. Der Code fordert zum Senden einer ersten Anforderung an den Flow auf und fordert je nach Bedarf weitere Eingaben an. Der Code verwaltet keine anderen Anforderungen des Agenten, z. B. Anforderungen zum Aufrufen von AWS Lambda-Funktionen. Weitere Informationen finden Sie unter Funktionsweise von Agenten für Amazon Bedrock. Während der Ausführung generiert der Code FlowTraceEvent-Objekte, mit denen Sie den Pfad von der Eingabe bis zur Antwort, die der Flow zurückgibt, verfolgen können. Weitere Informationen finden Sie unter Verfolgen jedes Schritts im Flow durch Anzeigen der zugehörigen Nachverfolgung in Amazon Bedrock.

"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.

"""
import logging
import boto3
import botocore



import botocore.exceptions

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
    """
    Invoke an Amazon Bedrock flow and handle the response stream.

    Args:
        client: Boto3 client for Amazon Bedrock agent runtime
        flow_id: The ID of the flow to invoke
        flow_alias_id: The alias ID of the flow
        input_data: Input data for the flow
        execution_id: Execution ID for continuing a flow. Use the value None on first run.

    Returns:
        Dict containing flow_complete status, input_required info, and execution_id
    """

    response = None
    request_params = None

    if execution_id is None:
        # Don't pass execution ID for first run.
        request_params = {
            "flowIdentifier": flow_id,
            "flowAliasIdentifier": flow_alias_id,
            "inputs": [input_data],
            "enableTrace": True
        }
    else:
        request_params = {
            "flowIdentifier": flow_id,
            "flowAliasIdentifier": flow_alias_id,
            "executionId": execution_id,
            "inputs": [input_data],
            "enableTrace": True
        }

    response = client.invoke_flow(**request_params)
    if "executionId" not in request_params:
        execution_id = response['executionId']

    input_required = None
    flow_status = ""

    # Process the streaming response
    for event in response['responseStream']:
        # Check if flow is complete.
        if 'flowCompletionEvent' in event:
            flow_status = event['flowCompletionEvent']['completionReason']

        # Check if more input us needed from user.
        elif 'flowMultiTurnInputRequestEvent' in event:
            input_required = event

        # Print the model output.
        elif 'flowOutputEvent' in event:
            print(event['flowOutputEvent']['content']['document'])

        elif 'flowTraceEvent' in event:
            logger.info("Flow trace:  %s", event['flowTraceEvent'])

    return {
        "flow_status": flow_status,
        "input_required": input_required,
        "execution_id": execution_id
    }


if __name__ == "__main__":

    session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
    bedrock_agent_client = session.client('bedrock-agent-runtime')
    
    # Replace these with your actual flow ID and alias ID
    FLOW_ID = 'YOUR_FLOW_ID'
    FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'


    flow_execution_id = None
    finished = False

    # Get the intial prompt from the user.
    user_input = input("Enter input: ")

    flow_input_data = {
        "content": {
            "document": user_input
        },
        "nodeName": "FlowInputNode",
        "nodeOutputName": "document"
    }

    logger.info("Starting flow %s", FLOW_ID)

    try:
        while not finished:
            # Invoke the flow until successfully finished.

            result = invoke_flow(
                bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID, flow_input_data, flow_execution_id)
            status = result['flow_status']
            flow_execution_id = result['execution_id']
            more_input = result['input_required']
            if status == "INPUT_REQUIRED":
                # The flow needs more information from the user.
                logger.info("The flow %s requires more input", FLOW_ID)
                user_input = input(
                    more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
                flow_input_data = {
                    "content": {
                        "document": user_input
                    },
                    "nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
                    "nodeInputName": "agentInputText"

                }
            elif status == "SUCCESS":
                # The flow completed successfully.
                finished = True
                logger.info("The flow %s successfully completed.", FLOW_ID)

    except botocore.exceptions.ClientError as e:
        print(f"Client error: {str(e)}")
        logger.error("Client error: %s", {str(e)})

    except Exception as e:
        print(f"An error occurred: {str(e)}")
        logger.error("An error occurred: %s", {str(e)})
        logger.error("Error type: %s", {type(e)})