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

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

Immediately, we’re excited to announce multi-turn dialog with an agent node (preview), a robust 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 extra context from the person earlier than it may well proceed, it may well 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 based mostly on person responses. The next sequence diagram reveals the move steps.

Multi-turn conversations make it simple to builders to create agentic workflows that may adapt and cause dynamically. That is significantly precious for advanced situations the place a single interplay may not be adequate to completely perceive and handle the person’s wants.

On this publish, we talk about tips on how to create a multi-turn dialog and discover how this function can rework your AI purposes.

Answer overview

Take into account 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 a substitute 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 utility can’t dynamically adapt its suggestions when customers modify their preferences or introduce new constraints throughout the planning course of

Let’s discover how the brand new multi-turn dialog functionality in Flows addresses these challenges and permits 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 affords two distinct interplay paths. For common journey inquiries, customers obtain instantaneous responses powered by an LLM. Nonetheless, when customers need to search or ebook flights and lodges, they’re related to an agent who guides them by the method, accumulating important data whereas sustaining the session till completion. The workflow is illustrated within the following diagram.

Stipulations

For this instance, you want the next:

• An AWS account and a person with an AWS Identification and Entry Administration (IAM) position licensed to make use of Bedrock. For steering, discuss with Getting began with Amazon Bedrock. Ensure the position consists of the permissions for utilizing Flows, as defined in Stipulations for Amazon Bedrock Flows, and the permissions for utilizing Brokers, as defined in Stipulations for creating Amazon Bedrock Brokers.
• Entry supplied to the fashions you employ 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 utility by orchestrating interactions between the FM, APIs calls, and person conversations. Our journey agent affords 4 important reserving capabilities: looking obtainable flights, securing flight reservations, discovering appropriate resort lodging, and finishing resort bookings. For an instance of tips on how to create a journey agent, discuss with Brokers for Amazon Bedrock now assist reminiscence retention and code interpretation (preview). Ensure the agent has person enter performance enabled. This setting permits the agent to collect all required particulars by 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 known as ACME-Corp-trip-planner.

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

Bedrock supplies completely different node varieties to construct your immediate move.

3. Select the immediate node to guage the enter intention. It is going to classify the intentions as categoryLetter=A if the person needs to look or ebook a resort or flight and categoryLetter=B if the person is asking for vacation spot data. Should you’re utilizing Amazon Bedrock Immediate Administration, you may 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 resort and flights Instance: "Discover flights to London"
B: Vacation spot data queries Instance: "What is the climate in Paris?"

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

For our instance, we selected Amazon’s Nova Lite mannequin and set the temperature inference parameter to 0.1 to reduce hallucinations and improve output reliability. You’ll be able to 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:

   Title: 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 Stream output node and join the immediate node output to it.

   You might be AcmeGuide, an enthusiastic and educated journey information. 
   Your job is to supply correct and complete details about journey locations to customers. 
   When answering a person's question, cowl the next key facets:
   
   - Climate and finest occasions to go to
   - Well-known native figures and celebrities
   - Main sights and landmarks
   - Native tradition and delicacies
   - Important journey ideas
   
   Reply the person's query {{question}}. 
   
   Current the data in a transparent and fascinating method. 
   In case you are uncertain 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 extra textual content.

For our instance, we selected Amazon’s Nova Lite mannequin and set the temperature inference parameter to 0.1 to reduce 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 Stream 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 by the Amazon Bedrock console or API. First, we ask for details about Paris. Within the response, you may assessment the move traces, which give detailed visibility into the execution course of. These traces provide help to monitor and debug response occasions for every step, observe the processing of buyer inputs, confirm if guardrails are correctly utilized, and determine any bottlenecks within the system. Stream traces provide a complete overview of the complete response era 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 may see, now with the multi-turn assist in Flows, our agent node is ready to ask follow-up questions to collect all data and make the reserving.

We proceed speaking to our agent, offering all required data, and at last, the agent makes the reserving for us. Within the traces, you may test 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

It’s also possible to work together with flows programmatically utilizing the InvokeFlow API, as proven within the following code. Through the preliminary invocation, the system mechanically generates a novel executionId, which maintains the session for 1 hour. This executionId is crucial for subsequent InvokeFlow API calls, as a result of it supplies the agent with contextual data crucial 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) subject.

The next is an instance FlowMultiTurnInputRequestEvent JSON object:

{
  "nodeName": "Trip_planner",
  "nodeType": "AgentNode",
  "content material": {
      "doc": "Actually! I might be blissful 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 doable)?
2. What date would you prefer to journey (in YYYYMMDD format)?
3. Do you may have 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 obtained, the move additionally emits a FlowCompletionEvent occasion. A move all the time 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 may well 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. Remember to embody the executionId for the dialog.

The next is an instance JSON request for the InvokeFlow API, which supplies extra 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 forwards and backwards 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 main points:

- 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. It’s essential specify your move’s ID in FLOW_ID and its alias ID in FLOW_ALIAS_ID (discuss 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 take care of 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(degree=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 knowledge 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("Stream 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 knowledge dictionary.
    
    Args:
        textual content: The enter textual content
        node_name: Title 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 knowledge
    """
    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 important():
    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

    strive:
        # 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__":
    important()

Clear up

To scrub up your sources, delete the move, agent, AWS Lambda capabilities created for the agent, and data base.

Conclusion

The introduction of multi-turn dialog functionality in Flows marks a major development in constructing refined conversational AI purposes. On this publish, we demonstrated how this function permits builders to create dynamic, context-aware workflows that may deal with advanced interactions whereas sustaining dialog historical past and state. The mixture of the Flows visible builder interface and APIs with highly effective agent capabilities makes it simple 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 clients’ wants. Whether or not you’re creating a journey reserving system, customer support or different conversational utility, multi-turn dialog with Flows supplies 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 as we speak. For extra data and detailed documentation, go to the Amazon Bedrock Person Information. We look ahead to seeing the modern options you’ll create with these highly effective new options.

Concerning the Authors

Christian Kamwangala is an AI/ML and Generative AI Specialist Options Architect at AWS, based mostly in Paris, France. He helps enterprise clients architect and implement cutting-edge AI options utilizing the great suite of AWS instruments, with a give attention to production-ready techniques that observe business finest practices. In his spare time, Christian enjoys exploring nature and spending time with household and mates.

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 attain clients’ desired enterprise outcomes by automating end-to-end ML lifecycles. In her free time, Irene enjoys touring and mountain climbing.