Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Conversation avec un flux Amazon Bedrock

La conversation à plusieurs tours Amazon Bedrock Flows permet des conversations dynamiques entre les utilisateurs et les flux, semblables à un dialogue naturel. Lorsqu’un nœud d’agent a besoin de précisions ou de contexte supplémentaire, il peut suspendre intelligemment l’exécution du flux et demander des informations spécifiques à l’utilisateur. Cela crée une expérience plus interactive et plus contextuelle, car le nœud peut adapter son comportement en fonction des réponses utilisateur. Par exemple, si la requête utilisateur initiale est ambiguë ou incomplète, le nœud peut poser des questions complémentaires pour recueillir les informations nécessaires. Une fois que l’utilisateur a fourni les informations demandées, le flux reprend facilement son exécution avec l’entrée enrichie, garantissant ainsi des résultats plus précis et plus pertinents. Cette fonctionnalité est particulièrement utile pour les scénarios complexes dans lesquels une seule interaction peut ne pas être suffisante pour bien comprendre les besoins de l’utilisateur et y répondre pleinement.

Traitement d’une conversation à plusieurs tours dans un flux

Pour utiliser une conversation à plusieurs tours dans un flux, vous avez besoin d’un nœud d’agent connecté à un agent Amazon Bedrock. Lorsque vous exécutez le flux, une conversation à plusieurs tours a lieu lorsque l’agent a besoin d’informations supplémentaires de la part de l’utilisateur avant de pouvoir continuer. Cette section décrit un flux qui utilise un agent avec les instructions suivantes :

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.

Pour plus d’informations sur la création d’un agent, consultez Automatisation des tâches de votre application à l’aide d’agents d’IA.

Étape 1 : démarrage du flux

Vous démarrez un flux en appelant l’opération InvokeFlow. Vous incluez le contenu initial que vous souhaitez envoyer au flux. Dans l’exemple suivant, le champ document contient une demande de création d’une liste de lecture. Chaque conversation possède un identifiant unique (identifiant d’exécution) qui l’identifie au sein du flux. Pour obtenir l’identifiant d’exécution, vous n’envoyez pas le champ executionID lors de votre premier appel à l’opération InvokeFlow. La réponse de l’opération InvokeFlow inclut l’identifiant d’exécution. Dans votre code, suivez plusieurs conversations et identifiez une conversation lors d’appels ultérieurs à l’opération InvokeFlow à l’aide de l’identifiant.

Voici un exemple de code JSON pour une demande envoyée à l’opération InvokeFlow :

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

Étape 2 : récupération des demandes d’agent

Si le nœud d’agent du flux décide qu’il a besoin d’informations supplémentaires de la part de l’utilisateur, le flux de réponse (responseStream) de l’opération InvokeFlow inclut un objet d’événement FlowMultiTurnInputRequestEvent. L’événement comporte les informations demandées dans le champ content (FlowMultiTurnInputContent). Dans l’exemple suivant, la demande dans le champ document concerne des informations sur le nombre de chansons, le genre musical et le thème de la liste de lecture. Dans votre code, vous devez ensuite obtenir ces informations auprès de l’utilisateur.

Voici un exemple d’objet JSON FlowMultiTurnInputRequestEvent :

{
    "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."
    }
}

Comme le flux ne peut pas continuer tant que d’autres entrées ne sont pas reçues, il émet également un événement FlowCompletionEvent. Un flux émet toujours l’événement FlowMultiTurnInputRequestEvent avant l’événement FlowCompletionEvent. Si la valeur du paramètre completionReason de l’événement FlowCompletionEvent est INPUT_REQUIRED, le flux a besoin d’informations supplémentaires avant de pouvoir continuer.

Voici un exemple d’objet JSON FlowCompletionEvent :

{
    "completionReason": "INPUT_REQUIRED"
}

Étape 3 : envoi de la réponse utilisateur au flux

Renvoyez la réponse utilisateur au flux en appelant à nouveau l’opération InvokeFlow. Veillez à inclure l’executionId pour la conversation.

Voici un exemple de code JSON pour la demande envoyée à l’opération InvokeFlow : Le champ document contient la réponse de l’utilisateur.

{
  "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"
    }
  ]
}

Si le flux a besoin d’informations supplémentaires, il crée d’autres événements FlowMultiTurnInputRequestEvent.

Étape 4 : achèvement du flux

Lorsqu’aucune information supplémentaire n’est nécessaire, le flux émet un événement FlowOutputEvent qui contient la réponse finale.

Voici un exemple d’objet JSON FlowOutputEvent :

{
    "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!"
     }
}

Le flux émet également un événement FlowCompletionEvent. La valeur du paramètre completionReason est SUCCESS.

Voici un exemple d’objet JSON FlowCompletionEvent :

{
    "completionReason": "SUCCESS"
}

Le diagramme de séquence suivant montre les étapes d’un flux à plusieurs tours.

Création et exécution d’un exemple de flux

Dans cet exemple, vous allez créer un flux qui crée des listes de lecture pour une station de radio à l’aide d’un agent. L’agent pose des questions de clarification pour déterminer le nombre de chansons, le genre musical et le thème de la liste de lecture.

L’exemple de code Python suivant montre comment utiliser le flux.

Pour exécuter le code, spécifiez les éléments suivants :

Pour en savoir plus sur l’obtention d’identifiants, consultez Affichage d’informations sur les flux dans Amazon Bedrock. Le code invite à envoyer une demande initiale au flux et demande des entrées supplémentaires selon les besoins du flux. Le code ne gère pas les autres demandes de l’agent, comme les demandes d’appel de fonctions AWS Lambda. Pour plus d’informations, consultez Fonctionnement des agents Amazon Bedrock. Pendant l’exécution, le code génère des objets FlowTraceEvent vous permettant de suivre le chemin entre l’entrée et la réponse renvoyée par le flux. Pour plus d’informations, consultez Suivi de chaque étape de votre flux en consultant sa trace dans 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)})