Introducing multi-turn dialog with an agent node for Amazon Bedrock Flows (preview)

Amazon Bedrock Flows gives an intuitive visible builder and a set of APIs to seamlessly hyperlink basis fashions (FMs), Amazon Bedrock options, and AWS providers to construct and automate user-defined generative AI workflows at scale. Amazon Bedrock Brokers gives a completely managed answer for creating, deploying, and scaling AI brokers on AWS. With Flows, you’ll be able to present explicitly said, user-defined resolution logic to execute workflows, and add Brokers as a node in a move to make use of FMs to dynamically interpret and execute duties primarily based on contextual reasoning for sure steps in your workflow.

At this time, we’re excited to announce multi-turn dialog with an agent node (preview), a strong new functionality in Flows. This new functionality enhances the agent node performance, enabling dynamic, back-and-forth conversations between customers and flows, just like a pure dialogue in a move execution.

With this new function, when an agent node requires clarification or further context from the person earlier than it could possibly proceed, it could possibly intelligently pause the move’s execution and request user-specific data. After the person sends the requested data, the move seamlessly resumes the execution with the enriched enter, sustaining the executionId of the dialog.

This creates a extra interactive and context-aware expertise, as a result of the node can adapt its habits primarily based on person responses. The next sequence diagram reveals the move steps.

Multi-turn conversations make it easy to builders to create agentic workflows that may adapt and cause dynamically. That is significantly worthwhile for advanced situations the place a single interplay won’t be ample to completely perceive and tackle the person’s wants.

On this put up, we talk about methods to create a multi-turn dialog and discover how this function can rework your AI purposes.

Answer overview

Think about ACME Corp, a number one fictional on-line journey company creating an AI-powered vacation journey planner utilizing Flows. They face a number of challenges of their implementation:

• Their planner can’t have interaction in dynamic conversations, requiring all journey particulars upfront as an alternative of asking follow-up questions
• They face challenges to orchestrate advanced, multi-step journey planning processes that require coordinating flights, lodging, actions, and transportation throughout a number of locations, typically resulting in inefficiencies and suboptimal buyer experiences
• Their software can’t dynamically adapt its suggestions when customers modify their preferences or introduce new constraints through the planning course of

Let’s discover how the brand new multi-turn dialog functionality in Flows addresses these challenges and allows ACME Corp to construct a extra clever, context-aware, and environment friendly vacation journey planner that really enhances the shopper’s journey planning expertise.

The move gives two distinct interplay paths. For normal journey inquiries, customers obtain immediate responses powered by an LLM. Nevertheless, when customers need to search or ebook flights and motels, they’re related to an agent who guides them via the method, gathering important data whereas sustaining the session till completion. The workflow is illustrated within the following diagram.

Conditions

For this instance, you want the next:

• An AWS account and a person with an AWS Identification and Entry Administration (IAM) function licensed to make use of Bedrock. For steering, confer with Getting began with Amazon Bedrock. Be certain that the function contains the permissions for utilizing Flows, as defined in Conditions for Amazon Bedrock Flows, and the permissions for utilizing Brokers, as defined in Conditions for creating Amazon Bedrock Brokers.
• Entry offered to the fashions you utilize for invocation and analysis. For steering, see Handle entry to Amazon Bedrock basis fashions.
• Create an Amazon Bedrock Agent to automate the duty for the journey company software by orchestrating interactions between the FM, APIs calls, and person conversations. Our journey agent gives 4 important reserving capabilities: looking obtainable flights, securing flight reservations, discovering appropriate lodge lodging, and finishing lodge bookings. For an instance of methods to create a journey agent, confer with Brokers for Amazon Bedrock now help reminiscence retention and code interpretation (preview). Be certain that the agent has person enter performance enabled. This setting permits the agent to assemble all required particulars via pure dialog, even when the preliminary request is incomplete.

Create a multi-turn dialog move

To create a multi-turn dialog move, full the next steps:

1. On the Bedrock console, select Flows beneath Builder instruments within the navigation pane.
2. Begin creating a brand new move referred to as ACME-Corp-trip-planner.

For detailed directions on making a Movement, see Amazon Bedrock Flows is now usually obtainable with enhanced security and traceability.

Bedrock offers completely different node sorts to construct your immediate move.

3. Select the immediate node to judge the enter intention. It can classify the intentions as categoryLetter=A if the person desires to look or ebook a lodge or flight and categoryLetter=B if the person is asking for vacation spot data. Should you’re utilizing Amazon Bedrock Immediate Administration, you’ll be able to choose the immediate from there.

For this node, we use the next message within the immediate configuration:

You're a question classifier. Analyze the {{enter}} and reply with a single letter:

A: Journey planning/reserving queries for lodge and flights Instance: "Discover flights to London"
B: Vacation spot data queries Instance: "What is the climate in Paris?"

Return solely 'A' or 'B' primarily based on the first intent.

For our instance, we selected Amazon’s Nova Lite mannequin and set the temperature inference parameter to 0.1 to attenuate hallucinations and improve output reliability. You possibly can choose different obtainable Amazon Bedrock fashions.

4. Create the Situation node with the next data and join with the Question Classifier node. For this node, the situation worth is:

   Identify: Reserving
   Situation: categoryLetter=="A"

   

5. Create a second immediate node for the LLM information invocation. The enter of the node is the output of the Situation node output “If all situations are false.” To finish this move department, add a Movement output node and join the immediate node output to it.

   You're AcmeGuide, an enthusiastic and educated journey information. 
   Your activity is to supply correct and complete details about journey locations to customers. 
   When answering a person's question, cowl the next key points:
   
   - Climate and greatest instances to go to
   - Well-known native figures and celebrities
   - Main sights and landmarks
   - Native tradition and delicacies
   - Important journey suggestions
   
   Reply the person's query {{question}}. 
   
   Current the data in a transparent and fascinating method. 
   If you're not sure about particular particulars, acknowledge this and supply probably the most dependable data obtainable. 
   Keep away from any hallucinations or fabricated content material. 
   Present your response instantly after these directions, with none preamble or further textual content.

For our instance, we selected Amazon’s Nova Lite mannequin and set the temperature inference parameter to 0.1 to attenuate hallucinations and improve output reliability.

6. Lastly, create the agent node and configure it to make use of the agent that was created beforehand. The enter of the node is the output of the Situation node output “Situations Reserving.” To finish this move department, add a Movement output node and join the agent node output to it.
   
7. Select Save to save lots of your move.

Take a look at the move

You’re now able to check the move via the Amazon Bedrock console or API. First, we ask for details about Paris. Within the response, you’ll be able to evaluation the move traces, which offer detailed visibility into the execution course of. These traces aid you monitor and debug response instances for every step, monitor the processing of buyer inputs, confirm if guardrails are correctly utilized, and establish any bottlenecks within the system. Movement traces provide a complete overview of your entire response technology course of, permitting for extra environment friendly troubleshooting and efficiency optimization.,

Subsequent, we proceed our dialog and request to ebook a journey to Paris. As you’ll be able to see, now with the multi-turn help in Flows, our agent node is ready to ask follow-up questions to assemble all data and make the reserving.

We proceed speaking to our agent, offering all required data, and eventually, the agent makes the reserving for us. Within the traces, you’ll be able to examine the ExecutionId that maintains the session for the multi-turn requests.

After the affirmation, the agent has efficiently accomplished the person request.

Use Amazon Bedrock Flows APIs

You too can work together with flows programmatically utilizing the InvokeFlow API, as proven within the following code. In the course of the preliminary invocation, the system mechanically generates a novel executionId, which maintains the session for 1 hour. This executionId is important for subsequent InvokeFlow API calls, as a result of it offers the agent with contextual data vital for sustaining dialog historical past and finishing actions.

{
  "flowIdentifier": " MQM2RM1ORA",
  "flowAliasIdentifier": "T00ZXPGI35",
  "inputs": [
    {
      "content": {
        "document": "Book a flight to paris"
      },
      "nodeName": "FlowInputNode",
      "nodeOutputName": "document"
    }
  ]
}

If the agent node within the move decides that it wants extra data from the person, the response stream (responseStream) from InvokeFlow features a FlowMultiTurnInputRequestEvent occasion object. The occasion has the requested data within the content material(FlowMultiTurnInputContent) discipline.

The next is an instance FlowMultiTurnInputRequestEvent JSON object:

{
  "nodeName": "Trip_planner",
  "nodeType": "AgentNode",
  "content material": {
      "doc": "Definitely! I would be comfortable that can assist you ebook a flight to Paris. 
To get began, I would like some extra data:
1. What's your departure airport (please present the IATA airport code if attainable)?
2. What date would you wish to journey (in YYYYMMDD format)?
3. Do you've got a most well-liked time for the flight (in HHMM format)?
As soon as I've these particulars, I can seek for obtainable flights for you."
  }
}

As a result of the move can’t proceed till extra enter is acquired, the move additionally emits a FlowCompletionEvent occasion. A move at all times emits the FlowMultiTurnInputRequestEvent earlier than the FlowCompletionEvent. If the worth of completionReason within the FlowCompletionEvent occasion is INPUT_REQUIRED, the move wants extra data earlier than it could possibly proceed.

The next is an instance FlowCompletionEvent JSON object:

{
  "completionReason": "INPUT_REQUIRED"
}

Ship the person response again to the move by calling the InvokeFlow API once more. Make sure you embody the executionId for the dialog.

The next is an instance JSON request for the InvokeFlow API, which offers further data required by an agent node:

{
  "flowIdentifier": "MQM2RM1ORA",
  "flowAliasIdentifier": "T00ZXPGI35",
  "executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
  "inputs": [
    {
      "content": {
        "document": "Madrid on Valentine's day 2025"
      },
      "nodeName": "Trip_planner",
      "nodeInputName": "agentInputText"
    }
  ]
}

This backwards and forwards continues till no extra data is required and the agent has all that’s required to finish the person’s request. When no extra data is required, the move emits a FlowOutputEvent occasion, which accommodates the ultimate response.

The next is an instance FlowOutputEvent JSON object:

{
  "nodeName": "FlowOutputNode",
  "content material": {
      "doc": "Nice information! I've efficiently booked your flight to Paris. Listed here are the small print:

- Date: February 14, 2025 (Valentine's Day)
- Departure: Madrid (MAD) at 20:43 (8:43 PM)
- Arrival: Paris (CDG)

Your flight is confirmed."
  }
}

The move additionally emits a FlowCompletionEvent occasion. The worth of completionReason is SUCCESS.

The next is an instance FlowCompletionEvent JSON object:

{
  "completionReason": "SUCCESS"
}

To get began with multi-turn invocation, use the next instance code. It handles subsequent interactions utilizing the identical executionId and maintains context all through the dialog. You could specify your move’s ID in FLOW_ID and its alias ID in FLOW_ALIAS_ID (confer with View details about flows in Amazon Bedrock for directions on acquiring these IDs).

The system will immediate for added enter as wanted, utilizing the executionId to keep up context throughout a number of interactions, offering a coherent and steady dialog move whereas executing the requested actions.

"""
Runs an Amazon Bedrock move and handles multi-turn interactions
"""
import boto3
import logging

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

def invoke_flow(consumer, flow_id, flow_alias_id, input_data, execution_id=None):
    """
    Invoke an Amazon Bedrock move and deal with the response stream.

    Args:
        consumer: Boto3 consumer for Bedrock
        flow_id: The ID of the move to invoke
        flow_alias_id: The alias ID of the move
        input_data: Enter information for the move
        execution_id: Execution ID for persevering with a move. Defaults to None for first run.

    Returns:
        Dict containing flow_complete standing, input_required data, and execution_id
    """
    request_params = {
        "flowIdentifier": flow_id,
        "flowAliasIdentifier": flow_alias_id,
        "inputs": [input_data]
    }
    
    if execution_id:
        request_params["executionId"] = execution_id

    response = consumer.invoke_flow(**request_params)
    execution_id = response.get('executionId', execution_id)
    
    input_required = None
    flow_status = ""

    for occasion in response['responseStream']:
        if 'flowCompletionEvent' in occasion:
            flow_status = occasion['flowCompletionEvent']['completionReason']
        elif 'flowMultiTurnInputRequestEvent' in occasion:
            input_required = occasion
        elif 'flowOutputEvent' in occasion:
            print(occasion['flowOutputEvent']['content']['document'])
        elif 'flowTraceEvent' in occasion:
            print("Movement hint:", occasion['flowTraceEvent'])

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

def create_input_data(textual content, node_name="FlowInputNode", is_initial_input=True):
    """
    Create formatted enter information dictionary.
    
    Args:
        textual content: The enter textual content
        node_name: Identify of the node (defaults to "FlowInputNode")
        is_initial_input: Boolean indicating if that is the primary enter (defaults to True)
    
    Returns:
        Dict containing the formatted enter information
    """
    input_data = {
        "content material": {"doc": textual content},
        "nodeName": node_name
    }

    if is_initial_input:
        input_data["nodeOutputName"] = "doc"
    else:
        input_data["nodeInputName"] = "agentInputText"

    return input_data

def predominant():
    FLOW_ID = "MQM2RM1ORA"
    FLOW_ALIAS_ID = "T00ZXPGI35"
    
    session = boto3.Session(
        region_name="us-east-1"
    )
    bedrock_agent_client = session.consumer(
        'bedrock-multi-turn', 
    )

    execution_id = None

    attempt:
        # Preliminary enter
        user_input = enter("Enter enter: ")
        input_data = create_input_data(user_input, is_initial_input=True)

        whereas True:
            consequence = invoke_flow(
                bedrock_agent_client, 
                FLOW_ID, 
                FLOW_ALIAS_ID, 
                input_data, 
                execution_id
            )
        
            if consequence['flow_status'] == "SUCCESS":
                break
            
            if consequence['flow_status'] == "INPUT_REQUIRED":
                more_input = consequence['input_required']
                immediate = f"{more_input['flowMultiTurnInputRequestEvent']['content']['document']}: "
                user_input = enter(immediate)
                # Subsequent inputs
                input_data = create_input_data(
                    user_input,
                    more_input['flowMultiTurnInputRequestEvent']['nodeName'],
                    is_initial_input=False
                )
            
            execution_id = consequence['execution_id']

    besides Exception as e:
        logger.error(f"Error occurred: {str(e)}", exc_info=True)

if __name__ == "__main__":
    predominant()

Clear up

To wash up your assets, delete the move, agent, AWS Lambda capabilities created for the agent, and information base.

Conclusion

The introduction of multi-turn dialog functionality in Flows marks a big development in constructing refined conversational AI purposes. On this put up, we demonstrated how this function allows builders to create dynamic, context-aware workflows that may deal with advanced interactions whereas sustaining dialog historical past and state. The mix of the Flows visible builder interface and APIs with highly effective agent capabilities makes it easy to develop and deploy clever purposes that may have interaction in pure, multi-step conversations.

With this new functionality, companies can construct extra intuitive and responsive AI options that higher serve their prospects’ wants. Whether or not you’re creating a journey reserving system, customer support or different conversational software, multi-turn dialog with Flows offers the instruments wanted to create refined AI workflows with minimal complexity.

We encourage you to discover these capabilities on the Bedrock console and begin constructing your individual multi-turn conversational purposes at present. For extra data and detailed documentation, go to the Amazon Bedrock Consumer Information. We look ahead to seeing the revolutionary options you’ll create with these highly effective new options.

In regards to the Authors

Christian Kamwangala is an AI/ML and Generative AI Specialist Options Architect at AWS, primarily based in Paris, France. He helps enterprise prospects architect and implement cutting-edge AI options utilizing the great suite of AWS instruments, with a deal with production-ready programs that observe business greatest practices. In his spare time, Christian enjoys exploring nature and spending time with household and associates.

Irene Arroyo Delgado is an AI/ML and GenAI Specialist Options Architect at AWS. She focuses on bringing out the potential of generative AI for every use case and productionizing ML workloads to realize prospects’ desired enterprise outcomes by automating end-to-end ML lifecycles. In her free time, Irene enjoys touring and mountaineering.