Amazon Lex Tutorial: A Beginner’s Guide to AI Chatbots

Setting Up Amazon Lex

In this section, I show how to set up Amazon Lex. 

Note that the AWS user interface changes frequently. So, the layout and text of various sections and titles in the instructions and screenshots can change over time or from region to region. 

Step 1: Sign into the AWS console

I assume you already have an AWS account. If not, follow the instructions on the AWS Signup page and register a new account.

In this guide, we use the AWS console to set up and use Lex. Enter your AWS credentials to sign in to the AWS Lex console and land on the Lex home page.

Step 2: Create a new bot

• To create a new bot, visit the Amazon Lex console. 
• Select Get Started. 

The above leads to the Bots homepage (shown below). This page shows the list of Bots you have already created.

Amazon Lex Bots homepage.

• On this page, select Create Bot. 

This will lead to the configuration page for a new bot. It shows two methods of creating bots: Traditional and Generative AI.

Create a new bot.

We want to learn the process of setting up and configuring bots. So, choose the Traditional method and start with a blank bot. 

• Bot name: Give the bot a name and description. In this article, we create a simple bot named “CabBookBot” to book a cab. 
• IAM permissions: Choose the right role to manage authorization and authentication for the bot.
• If you have already created bots before, choose from the dropdown of existing roles.
• If this is your first bot, choose “Create a role with basic Amazon Lex permissions.” 
• COPPA: If this bot is designed to serve children and minors, specify that it is subject to the Children’s Online Privacy Protection Act (COPPA). We choose “No”. 
• Idle session timeout: Bots must remember the user’s previous messages to maintain “context” throughout the conversation. If a user has not responded in a while, we assume they no longer use the bot and reset the context for a new user. Leave this at the default value. 

You don’t need to update the optional advanced settings; just go to the next section. 

You must also set up the bot’s language(s) because Lex bots are based on natural language processing (NLP).

• In this example, we use the default English (US) language. 
• Keep the default settings and select Done. 

Then, you’ll be led to the Intents page, which we will configure in the next section. 

Having created a basic bot, I now explain how to configure it for our desired use case: booking a cab.

Step 3: Configure intents

As the name suggests, intents represent the user’s intention or the goal of the conversation. For example, the user might want to book a hotel or a flight. Each bot can serve multiple goals. 

Provided a few example texts (called sample utterances) for each intent, Lex uses NLP to recognize and match the user’s input to the right intent based on these utterances. For example, a taxi booking bot can have sample utterances such as “I want to book a cab,” “book me a cab from X to Y on this date,” etc. 

After selecting Done on the bot creation page in the previous step, you will be taken to the page where you can create a new intent called NewIntent. 

On the Intent page:

• Find the Conversation Flow at the top. This illustrates the flow and sample text messages for each conversation step. 
• Update the intent's name to something meaningful, such as “CabBookIntent”, and provide a relevant description.

Step 4: Add sample utterances

Lex needs a few sample utterances for each intent to recognize whether the user’s need matches the current intent. 

• On the Intent page, scroll down to the Sample utterances section. 
• Switch the editor window to Plain Text. 
• Add a few sample utterances, one on each line, for example:
• I want to book a taxi
• Book me a cab
• I need to make a taxi reservation

Sample utterances.

• Add an Initial response, such as, “Ok, I will help you book a cab,” to acknowledge the user’s request. 

Creating a Conversation Flow

Lex bots follow a predefined conversation structure. The conversation flow outlines and gives the specifications for the components of the conversation. In this section, I explain how to design the conversation to communicate with the user and get the information needed to fulfill their request.

Step 1: Add slots to capture user input

The bot needs to prompt the user for relevant information. Slots contain information that the bot needs to fulfill the user’s request. For example, the cab booking bot receives the starting and destination cities and the journey date as slot values. 

Add slots to intents.

For each slot, you need to specify these parameters:

• Slot name: The bot uses this name as a placeholder for the slot’s value. For example, you can configure the bot’s response as “You want to travel from {SourceCity}” and it automatically substitutes the value of the SourceCity slot entered by the user.
• Slot type: Like programming variables, Lex slots can be various types. Many prebuilt slot types exist, such as AMAZON.City, AMAZON.Date, etc. You can also add custom slot types (discussed later).
• Prompt: Provide a text template that the bot can use to ask (prompt) the user for the value of each slot.

• Select Add Slot, and add the following slots, marking them as required:

• Add a few additional utterances that directly capture the slot values. For example:
• Book a cab on {TravelDate} from {SourceCity} to {DestinationCity}
• Book a cab from {SourceCity} to {DestinationCity} for {TravelDate}

Custom slots

Inbuilt slot types are not always sufficient for all use cases. For example, a cab booking service might have a slot type for the kind of car (compact, hatchback, sedan, SUV, etc.) the user wants. 

To add a custom slot:

• Go to Slot types from the menu in the left column:
• CabBookBot > Bot versions > Draft version > All languages > English (US) > Slot types). 
• Add a name (such as CabType) and a description for the new slot type. 
• Choose one of two types of slot values: 
• Expand: You provide a few sample values for the slot, and Lex uses these as examples to learn new possible values. For example, given a list of surnames, Lex adapts the slot type to accept similar surnames you did not explicitly list. 
• Restrict: The slot only accepts values from the list that you provide. It will not learn new values. 

In this case, we have a few predetermined cab types. So, we restrict our slot values to these types.

• You can also provide alternative values for each value. For example, for the cab type, Limo is an acceptable value for Limousine. 

Custom slots.

• Select Save Slot type. The new slot type becomes available when adding a slot to the intent.

Step 2: Configure prompting and error handling

When the user provides an invalid response to a prompt asking for a slot value, Lex repeats the prompt. The session terminates when the user repeatedly fails to give a proper response (like a valid city name). 

Set up Lex to throw an error message (before terminating the session) if the user repeatedly fails to provide a valid slot value:

• Select an individual slot and select Advanced options for that slot. 
• Scroll down the advanced options window for the Slot capture: failure response section. 
• Provide an appropriate response for invalid input. For example, if the user repeatedly enters a city that’s not recognized, the bot can respond, “Sorry, we don't serve that city.”

Error handling and failure response.

All bots have a FallbackIntent, which is invoked when the user’s input doesn’t match the existing intents. Because this intent is invoked as the default, its utterances cannot be customized. 

• Specify a meaningful closing response with the FallbackIntent and end the conversation. 

Closing response. 

Step 3: Confirmation, fulfillment, and closing

Confirm the user’s intent after getting the appropriate values for the slots and before fulfilling the request. 

• Use the Confirmation section to provide a confirmation prompt. 
• Notice there’s a small toggle switch for the Confirmation dialog. Activate it. 

It is common to include the slot values in the confirmation prompt. For example: “Please confirm (yes or no) that you want to make a booking from {SourceCity} to {DestinationCity} on {TravelDate}”. 

• Provide a Decline response in case the user responds negatively to the confirmation prompt. For example, “Okay, we won’t do this booking”. 

Confirmation prompt.

The fulfillment response indicates to the user that the bot is starting to service their request (booking the cab). 

• In the Fulfillment section, provide another message after successfully fulfilling the request. For example, “Okay, we have made this booking.” 

The closing response is the final message sent to the user. For example, “Thank you for traveling with us. Have a safe trip!”. 

• Update the responses and select Save intent.

Fulfillment and closing responses. 

Testing Your Amazon Lex Bot

Now that we have created the bot and its conversation structure, we can test it! 

Step 1: Test in the Lex console

• Find the Build and Test buttons at the top of the Intents page. 
• Build the bot. You must rebuild the bot after every change. 
• Select Test to test the bot in the Lex console. 
• Enter relevant messages In the pop-up chat window and respond to the bot’s prompts. 

Testing the Amazon Lex bot.

Common configuration errors

Some of the sections, like Confirmation, Fulfillment, and Closing response, are, in principle, optional. To enable a section, enable the toggle switch. 

In some cases, enabling a section or response automatically enables a Lambda function for that section. If a specific section has the Lambda function toggle set to “on” but there is no associated Lambda function, you’ll get an error like the one below:

Cannot call FulfillmentCodeHook for Intent CabBookIntent. BotAlias/LocaleId TestBotAlias/en_US doesn't have an associated Lambda Function.

The above error comes from the Fulfillment section. To resolve it, go to advanced settings in the relevant section and uncheck the option to use a Lambda function. 

Another similar error occurs when the flow is misconfigured. For example, consider this error message at the build stage:

'ElicitSlot' next step at 'InitialResponse:CodeHook:Success' in intent 'CabBookIntent' contains invalid slotToElicit setting. slotToElicit must be a required Slot within the intent. Change the slot name in slotToElicit and try your request again.

To resolve this error, go in the Advanced options for the Initial response. Notice that the Dialog Code hook toggle is active. However, at this stage, we have not yet enabled Lamba functions nor configured them to initialize the conversation. Deactivate the code hook and update the bot; it should build normally. 

Advanced options for initial response.

Step 2: Test with voice (Optional)

Lex bots work by default with both text and voice. 

• Press the microphone icon in the chat window to communicate using voice.
• The placeholder text in the input field changes to “Listening…”. 
• Speak your intent, for example, “I want to book a taxi.” 
• Press the check mark at the right of the text input field. 
• Lex will briefly transcribe the voice input and respond with audio. 

Amazon Polly converts text to natural speech. It is used in speech-based applications, like newsreaders, games, bots, etc., to generate human-like speech from text. Since 2021, Amazon Lex has supported Amazon Polly Neural Text-to-Speech (NTTS). Thus, the Lex bot can directly generate natural-sounding voice responses. 

To configure the bot’s voice:

• On the bot’s homepage, select View languages. 
• Choose the appropriate language. 
• You can also select the relevant language under the All languages option in the left menu.
• In the Language details section, select Edit. 
• This takes you to the Language page.
• Under the Voice section, you can listen to various voice samples and select the preferred text-to-speech voice. 

Defining a Fulfillment with AWS Lambda

In practice, a bot needs to communicate with other backend services. For example, a cab booking bot needs to send the trip information to an API endpoint and receive a successful response. Lambda functions help do this. 

AWS Lambda functions are a way to write server-side logic and execute it without having to explicitly rent a VPS or compute instances. 

To start with Lambda functions:

• Go to the AWS Lambda homepage.
• Select Create function. 
• For this example, choose the option to create a function from scratch. 
• Choose Python 3.x (3.13 at the time of writing) as the language and x86_64 as the processor to run the function. 
• If this is your first Lambda function, create a new role. You can also use one of the existing roles if you know that it has the right permissions. 
• Select Create function. 
• Enter the code of the function on the Code tab on the webpage of the specific Lambda function. 

Below, we show a short Lambda function that sends a success message in the Fulfillment section: 

import json
import urllib.request

def lambda_handler(event, context):
    slots = event['sessionState']['intent']['slots']
    intent = event['sessionState']['intent']['name']

    if event['invocationSource'] == 'FulfillmentCodeHook':
        message = "Lambda has placed your reservation"
        response = {
            "sessionState": {
                "dialogAction": {
                    "type": "Close"
                },
                "intent": {
                    'name':intent,
                    'slots': slots,
                    'state':'Fulfilled'
                    }
            },
            "messages": [
                {
                    "contentType": "PlainText",
                    "content": message
                }
            ]
        }
        return response

Configure the Bot to call this Lambda function:

• Go to the bot's home page. In the left menu, select the Aliases option (Deployment > Aliases). 
• By default, it should already have an alias with the name TestBotAlias. 
• Select the alias.
• On the alias page, under languages, find the bot's language. This example is in English(US).
• Select the language. 
• On the language page, find the Lambda function section. 
• Under source, select the name of your Lambda function. 
• The default choice for the version is $LATEST. Leave it unchanged. 
• Save the changes.

In this example, we want to use the Lambda function at the fulfillment stage:

• On the Intent page, go to Advanced options under the Fulfillment section. 
• Under the section Fulfillment Lambda code hook, mark the checkbox with the label Use a Lambda function for fulfillment. 
• Save the changes (select Update options) to the Fulfillment options. 
• Save the Intent. 
• Go to the Intent page of the bot, build it, and test it. 

Now, the response comes from the Lambda function:

Testing the Lambda function integrated with the Lex bot.

Deploying Your Amazon Lex Bot

After creating and testing the Lex bot, we are ready to deploy it. Deployment is a complex topic whose specifics depend on the individual use case. In this section, I provide an overview of various common deployment methods. 

Step 1: Deploying on a web or mobile application

Lex can be integrated into web apps and mobile apps using the API, the SDK, or prebuilt libraries:

• CloudFormation: AWS CloudFormation is an Infrastructure as code solution. It allows using YAML files to bundle, provision, deploy, and manage various AWS resources as a complete product. CloudFormation has templates to integrate various AWS products like S3 buckets, Lambda functions, Lex bots, and more. Use the Lex YAML template file to configure the Lex bot as part of a CloudFormation project. 
• Website integration: AWS has made available a set of Javascript loader files and the AWS SDK to load a bot into a website. These include the prebuilt Lex UI files and a loader library to load the Lex bot. The bot can be integrated into a website as a standalone webpage or an iframe. 
• Mobile native apps: AWS Amplify includes the tools to integrate with various mobile and web frontends, such as ReactJS / React Native, NextJS, Angular, Android, iOS, and more. The Amplify documentation explains how to configure a Lex bot to work with these SDKs.
• Lex API: To have complete control over the interactions and interface, you can use the Lex API. Using the API, you can pass the user’s and the bot’s messages (to each other) while retaining control of the user experience via your app. Lex offers two APIs:
• The Runtime API is used for user interaction, as explained above. 
• The Build API is used to build and configure the Lex bot programmatically instead of using the GUI. 

The steps below give an outline of how to deploy the chatbot as a webpage:

• Use the Lex Web UI Loader library. This library creates an object ChatBotUiLoader, which includes FullPageLoader() and IframeLoader constructors. These constructors’ load() function loads the bot in the page or iFrame, respectively.
• For loading the bot on the webpage, specify the chatbot configuration:
• The Cognito pool ID. Note that you need an AWS Cognito identity pool to connect to the bot. You can create an identity pool from the AWS Cognito console. You must link the Cognito identity pool to the Lex bot. 
• The name and details of the Lex bot. 
• Load the bot using the .load() function. 

The snippet below shows the outline of a JavaScript function that deploys a Lex bot on a webpage: 

 <!-- LexWebUi loader -->
  <script src="./lex-web-ui-loader.js"></script>
  <script>
    // instantiate the loader
    var lexWebUiLoader = new ChatBotUiLoader.FullPageLoader();

    var chatbotUiconfig = {
     cognito: {
       poolId: 
     },
     lex: {
        initialText: 'How can I help you?',
        botName: 'CabBookBot'
      },
      ui: {
        toolbarTitle: 'Cab Booking Lex Bot',
        toolbarLogo: ''
      },
    };

    lexWebUiLoader.load(chatbotUiConfig)
      .then(function () {
        console.log('chatbot UI loaded');
      })
      .catch(function (error) {
        console.error('chatbot UI failed to load', error);
      });
   </script>

Step 2: Integrating with messaging platforms 

You can integrate the Lex bot with third-party messaging services like Facebook Messenger, Slack, and Twilio SMS. 

In this section, we discuss how to integrate Lex with Facebook Messenger. Before starting, you need: 

• A Facebook developer account
• A business page on Facebook. Note that the Facebook app needs permission to use the Messaging API with Lex. Only apps reviewed and approved by Facebook as verified business apps are granted these permissions. 

Below, I outline the steps to integrate the Lex bot with Facebook Messenger so that users who message your Facebook page can receive responses from the bot. 

• Create a new Business app if you don’t already have one. 
• Under the app use cases, choose Other. 
• Select Business as the app type. 
• You can add various Facebook products to each app, like Messenger, Instagram, etc. Add Messenger to the app and choose Set up. 
• In the Messenger API Setup section:
• Connect your Facebook business page to this app. 
• Generate a new token (with the Generate button) for this app. Copy this token in a text editor. 
• Notice the message, “To send and receive messages, request pages_messaging permission.” Select Request Permission to request the required permissions. 
• If your app has not yet been reviewed and approved by Facebook, submit it for review. 
• From App Settings in the left menu options, choose Basic.
• Select Show under App Secret and copy the secret code in a text file. 

Now go to the Lex console and choose the bot you want to integrate with Messenger. 

• In the left menu tree, find Channel integrations under Deployment. 
• Select Add Channel under Create Channel:

• Choose Facebook under Platform.
• Choose KMS Key under Identity policies. 
• Under Integration configuration:
• Give the integration a name
• Choose an alias (of the Lex bot) that you want to integrate with Messenger
• Choose the language. 
• Under Additional configuration:
• Under Alias, enter a string to identify the app calling Lex. You will need this string later. 
• Under Page access token, enter the access token you copied in Facebook. 
• Under App secret key, enter the secret key you copied in Facebook.
• Use the Add button to create the new channel. 
• Return to the Channel Integrations page and select the channel you created. 
• Copy the URL under Endpoint in the Callback URL section. 

Go back to the Facebook developer console and open the app you created earlier. 

• From the left menu, under Messenger, choose Messenger API Settings. 
• Under Callback URL, enter the callback URL you copied in the Lex console. 
• Under Verify token, enter the alias string you entered in the Lex console. 
• Verify and save the changes.
• Under Webhooks, choose Add subscriptions. Select messages in the pop-up window, followed by Save. 

You can now message the Facebook page with the Lex bot’s sample utterances and get relevant responses. 

Step 3: Connecting Lex with AWS Lambda for enhanced interactivity

We wrote a simple Lambda function for the fulfillment section in the previous section. It only returned a text message: “Lambda has placed your reservation.” In practice, we would send the success message after fulfilling the request. 

For example, the Lambda function sends a request with the user’s reservation details to the backend API, which does the booking and then replies to the user based on the API’s response.

Here’s how you would do the above:

• The JSON object slots in the Lambda function contains the slot values. Study its structure using a code beautifier to extract the appropriate values. 
• The code snippet below shows how to get the slot value for SourceCity and pass this value to a backend API that handles the reservations. Add this code inside the lambda_handler() function:

slots = event['sessionState']['intent']['slots']
print("slots - ", slots)
source_city = slots['SourceCity']['value']['interpretedValue']
print("source city - ", source_city)

I now show how to make API requests from the Lambda function. For this example, we use the dummy API endpoint at ASDFast. This service allows you to send HTTP(S) requests to an API endpoint and receive a realistic response. 

• With the code below, we send a GET request to this endpoint. We then customize the message the bot sends to the user depending on the response status code of the GET request:

       res = urllib.request.urlopen(urllib.request.Request(
           url='http://asdfast.beobit.net/api/',
           headers={'Accept': 'application/json'},
           method='GET'),
           timeout=5)

       message_success = "Lambda has placed your reservation"
       message_failure = "Lambda could not place your reservation. Please retry."
       message = message_success if res.status == 200 else message_failure

The complete Lambda function is shown below:

import json
import urllib.request

def lambda_handler(event, context):
    print("event - ", event)
    slots = event['sessionState']['intent']['slots']
    intent = event['sessionState']['intent']['name']

    print("slots - ", slots)
    source_city = slots['SourceCity']['value']['interpretedValue']
    print("source city - ", source_city)
    print("intent - ", intent)
    
    if event['invocationSource'] == 'FulfillmentCodeHook':
        print("FulfillmentCodeHook")    
        res = urllib.request.urlopen(urllib.request.Request(
            url='http://asdfast.beobit.net/api/',
            headers={'Accept': 'application/json'},
            method='GET'),
            timeout=5)
        
        message_success = "Lambda has placed your reservation"
        message_failure = "Lambda could not place your reservation. Please retry."
        message = message_success if res.status == 200 else message_failure
        #message = "Lambda has placed your reservation"

        response = {
            "sessionState": {
                "dialogAction": {
                    "type": "Close"
                },
                "intent": {
                    'name':intent,
                    'slots': slots,
                    'state':'Fulfilled'
                    }
            },
            "messages": [
                {
                    "contentType": "PlainText",
                    "content": message
                }
            ]
        }
        return response

Best Practices for Building Amazon Lex Bots

After discussing the basic principles of Lex bots and their practical uses, I present some best practices for designing bots in this section. 

Design clear and concise conversations

Make sure that your conversational paths and slots are precise:

• Each intent must focus on a single task, and each slot must capture the value corresponding to a single variable. 
• Don’t make the prompt texts too wordy or verbose. Keep the dialogs brief and get quickly to the desired outcome.

This approach avoids confusing the user and potential misunderstandings by Lex. 

Utilize slot types and validation

The bot and its associated backend services need accurate user requirements information. Using the right slot types ensures this. 

• In general, I advise using the built-in slots for common data types, such as AMAZON.Date for dates, AMAZON.City for cities, and so on. These slot types have been extensively tested and are known to be compatible with various applications.
• You can design custom slot types in exceptional cases. Take care that they are correctly configured and tested. 
• In addition to using the right slot types, validate that the user has given the information corresponding to all the mandatory slots. This allows the backend API to fulfill the user’s request and ensures a smooth user experience. 

Enable multi-turn conversations

Users can find it overwhelming to enter all the necessary information in a single message, such as “Book a trip for N people on Z date/time from X to Y in cab type T.” 

• Use multi-turn conversations to ensure a better user experience. Like many modern language-model-based tools, Lex can maintain context through a multi-turn conversation. This enables it to relate previous prompts and responses to recent interactions. 
• Breaking down a complex prompt into a series of short questions improves the conversational flow.

Monitor and optimize performance

For a bot in production, it is crucial to monitor its performance across various metrics such as: 

• Total number of conversations.
• Average conversation duration.
• Average turns per conversation.
• Number (and ratio) of detected and missed utterances.
• Lambda errors, and more.

Use these metrics to gauge user interactions and the bot’s performance: 

• On the left menu on the Bot page, select the Analytics option. 
• Access the Conversation dashboard, the Performance dashboard, and CloudWatch metrics to study the bot's performance. 

AWS CloudWatch is a monitoring tool for AWS services. It consolidates various performance metrics in real time on a single page. Use these metrics to improve and fine-tune the bot’s performance.

Conclusion

In this article, we explored Amazon Lex V2, AWS’s context-aware chatbot service. We walked through the process of building a basic bot, configuring it to interact with users, and integrating it with a backend API using AWS Lambda. Additionally, we discussed best practices and deployment options, including embedding the bot on a website or a Facebook page.

As you continue learning about AWS services, consider expanding your knowledge with these courses:

• Get a solid foundation in AWS cloud services with the AWS Cloud Technology and Services course.
• Learn how to manage AWS security and costs effectively in the AWS Security and Cost Management course.
• Explore programmatic AWS interactions with Boto3, the AWS SDK for Python, in the Introduction to AWS Boto in Python course.

By leveraging these resources, you’ll be well-equipped to build, secure, and optimize AWS-based applications, including chatbots powered by Amazon Lex!