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 **Note** La conversation à plusieurs tours Amazon Bedrock Flows est en version préliminaire pour Amazon Bedrock et susceptible d’être modifiée. La conversation à plusieurs tours Amazon Bedrock Flows permet back-and-forth des conversations dynamiques entre les utilisateurs et les flux, comme dans le cas d'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. **Topics** + [Traitement d’une conversation à plusieurs tours dans un flux](#flows-multi-turn-invocation-how) + [Création et exécution d’un exemple de flux](#flows-multi-turn-invocation-example-flow) ## 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](flows-nodes.md#flows-nodes-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](agents.md). ### Étape 1 : démarrage du flux Vous démarrez un flux en appelant l'[InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)opération. 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. ![\[Étapes d’un flux pour une conversation à plusieurs tours.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png) ## 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. **Pour créer le flux** 1. Créez un agent dans la console Amazon Bedrock en suivant les instructions sous [Création et configuration manuelles de l’agent](agents-create.md). + Pour l’étape *2.d*, saisissez **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 l’étape *2.e*, choisissez **Activé** dans **Entrée utilisateur**. Ainsi, l’agent peut demander des informations supplémentaires, si nécessaire. 1. Créez le flux en suivant les instructions sous [Création et conception d’un flux dans Amazon Bedrock](flows-create.md). Assurez-vous que le flux possède un nœud d’entrée, un nœud d’agent et un nœud de sortie. 1. Liez le nœud d’agent à l’agent que vous avez créé à l’étape 1. Le flux devrait ressembler à l’image suivante : ![\[Conversation à plusieurs tours de flux\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-multi-turn.png) 1. Exécutez le flux dans la console Amazon Bedrock. Pour les tests, vous pouvez suivre les étapes effectuées par le flux. Pour de plus amples informations, veuillez consulter [Test d’un flux dans Amazon Bedrock](flows-test.md). L’exemple de code Python suivant montre comment utiliser le flux. Pour exécuter le code, spécifiez les éléments suivants : + `region_name`— La AWS région dans laquelle vous exécutez le flux. + `FLOW_ID` : identifiant du flux. + `FLOW_ALIAS_ID` : identifiant de l’alias du flux. Pour plus d'informations sur l'obtention du IDs, voir[Affichage d’informations sur les flux dans Amazon Bedrock](flows-view.md). 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, telles que les demandes d'appel de AWS Lambda fonctions. Pour de plus amples informations, veuillez consulter [Fonctionnement des agents Amazon Bedrock](agents-how.md). 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 de plus amples informations, veuillez consulter [Suivi de chaque étape de votre flux en consultant sa trace dans Amazon BedrockSuivi de chaque étape de votre flux en consultant sa trace](flows-trace.md). ``` """ 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)}) ```