Amazon Lex - Cognigy Documentation

Documentation Index

Fetch the complete documentation index at: /llms.txt

Use this file to discover all available pages before exploring further.

The Amazon Lex Endpoint enables you to connect your AI Agent with Amazon Lex.

Prerequisites

Generic Endpoint Settings

Learn about the generic Endpoint settings on the following pages:

Specific Endpoint Settings

Amazon Lex Settings

Parameter Description
Reparse Alexa Slots Allows Slots detected by Amazon Lex to be passed to Cognigy.AI and be processed by the Cognigy.AI NLU model. To make this parameter available, select Amazon Lex (Built-in) from the NLU Connector list in the Endpoint settings.

How to Set Up

Setup on the Cognigy.AI Side

Create an Amazon Lex Endpoint

  1. In the left-side menu of your Agent, click Deploy > Endpoints.
  2. On the Endpoints page, click + New Endpoint.
  3. In the New Endpoint section, do the following:
    1. Select the Lex Endpoint type.
    2. Specify a unique name.
    3. Select a relevant Flow from the list. Save changes.
    4. Go to the Configuration Information section and copy the Endpoint URL for later use in Amazon Lex.
    5. (Optional) In the Amazon Lex Settings section, activate the Reparse Alexa Slots option only if you want the Cognigy.AI NLU model to process Amazon Lex slots.

Setup on the Amazon Side

Select the use case:

Use Amazon Lex with Amazon NLU
Use your existing Amazon Lex bots along with their native NLU capabilities to process user input within Cognigy.AI.

  1. Open the Lambda console.
  2. Select Create function. Configure the following settings:
    • Function name – enter a name for the function.
    • Runtime – select Node.js 22.x.
  3. Select Create function. The console creates a Lambda function with a single source file named index.mjs. Edit this file in the built-in code editor. Copy the following code and paste it into your index.mjs file:
   const COGNIGY_ENDPOINT_HOSTNAME = "endpoint-trial.cognigy.ai";
   const COGNIGY_ENDPOINT_PATH = "/your-urltoken";
   
   // Change these attributes to the session attributes that contain your userId and sessionId
   const USERID_ATTRIBUTE = "CustomerNumber";
   const SESSIONID_ATTRIBUTE = "ContactId";
   
   // Pagination doesn't work at this API so we need to specify the maximum number of slots that are used for a single intent as page size
   const PAGESIZE = 20;
   
   const AWS = require("aws-sdk");
   const lexmodelsv2 = new AWS.LexModelsV2({
       apiVersion: "2020-08-07"
   });
   
   exports.handler = async (event, context, callback) => {
       const slotMap = await retrieveSlots(event);
       const postObject = {
           userId: event["sessionState"]["sessionAttributes"][USERID_ATTRIBUTE] || AWS.util.uuid.v4(),
           sessionId: event["sessionState"]["sessionAttributes"][SESSIONID_ATTRIBUTE] || AWS.util.uuid.v4(),
           text: event["transcriptions"][0]["transcription"],
           data: {
               request: event,
               slotMap
           },
       };
       const resultMap = await sendMessageToCognigy(postObject);
       const defaultSessionAtrributes = {
           action: "NONE",
           action_data: "",
       };
       if (resultMap["data"] && resultMap["data"]["connect_action"]) {
           defaultSessionAtrributes["action"] = resultMap["data"]["connect_action"];
       }
       if (resultMap["data"] && resultMap["data"]["connect_action_data"]) {
           defaultSessionAtrributes["action_data"] = JSON.stringify(resultMap["data"]["connect_action_data"]);
       }
       const response = {
           sessionState: {
               sessionAttributes: {
                   action: defaultSessionAtrributes.action,
                   action_data: JSON.stringify(defaultSessionAtrributes.action_data),
               },
               dialogAction: {
                   type: "Close",
                   fulfillmentState: "Fulfilled",
                   message: resultMap["text"],
               },
               intent: {
                   confirmationState: "Confirmed",
                   name: event["sessionState"]["intent"]["name"],
                   slots: {},
                   state: "Fulfilled",
               },
           },
           messages: [{
               contentType: "PlainText",
               content: resultMap["text"],
           }, ],
       };
       callback(null, response);
   };
   const https = require("https");
   async function sendMessageToCognigy(postObject) {
       return new Promise((resolve, reject) => {
           const postData = JSON.stringify(postObject);
           const options = {
               hostname: COGNIGY_ENDPOINT_HOSTNAME,
               path: COGNIGY_ENDPOINT_PATH,
               method: "POST",
               headers: {
                   "Content-Type": "application/json",
               },
           };
           const request = https.request(options, handleResponse);
           request.on("error", error => {
               reject(error);
           });
           request.write(postData);
           request.end();

function handleResponse(response) {
               let data = "";
               response.on("data", d => {
                   data += d.toString();
               });
               response.on("end", () => {
                   resolve(JSON.parse(data));
               });
           }
       });
   }
   async function retrieveSlots(event) {
       const params = {
           botId: event.bot.id,
           botVersion: event.bot.version,
           localeId: event.bot.localeId,
           filters: [{
               name: "IntentName",
               operator: "EQ",
               values: [event.sessionState.intent.name],
           }, ],
       };
       const intents = await lexmodelsv2.listIntents(params).promise();
       const slotParams = {
           botId: event.bot.id,
           botVersion: event.bot.version,
           localeId: event.bot.localeId,
           intentId: intents.intentSummaries[0].intentId,
           maxResults: PAGESIZE,
       };
       const slotList = await lexmodelsv2.listSlots(slotParams).promise();
       const slots = slotList.slotSummaries.reduce((obj, item) => Object.assign(obj, {
           [item.slotName]: item.slotTypeId
       }), {}, );
       return slots;
   }

In the script, replace the COGNIGY_ENDPOINT_HOSTNAME and COGNIGY_ENDPOINT_PATH variables with your Endpoint hostname and the URL token of your Endpoint. For example, if your Cognigy.AI trial Endpoint URL is https://endpoint-trial.cognigy.ai/175525264283054b52edb3b9ece270755e46e651ac00015fad9f1175bb47c110, specify the following values:

const COGNIGY_ENDPOINT_HOSTNAME = "endpoint-trial.cognigy.ai";
const COGNIGY_ENDPOINT_PATH = "/175525264283054b52edb3b9ece270755e46e651ac00015fad9f1175bb47c110";

In the Deploy section, select Deploy to update your function’s code. Then, to run your code, select Create test event in the Test events section.

Modify the service that was created for the Lambda function. Add the following permissions: lex:ListIntents and lex:ListSlots. Alternatively, you can also use a predefined role such as AmazonLexReadOnly. Save the Lambda function.

  1. Open the Amazon Lex console.
  2. Select Create bot. For the Creation method, select Start with an example. In the Example bots section, select OrderFlowers from the list.
  3. In the Bot configuration section, give the bot a name and an optional description. The name must be unique in your account.
  4. Open your first intent. Go to the Fulfillment section and enable Fulfillment Lambda code hook in the Advanced options.
  5. Click Update Options and Save intent. Open each intent in the current language, including the FallbackIntent, and repeat these steps. Build the language, then repeat these steps for additional languages if required.
  6. Go to Bot versions and create a new version. Then, go to Aliases and create a new alias and link it to the latest bot’s version. Reopen the alias and click the name of each language that is supported.
  7. Select the previously created Lambda function with its latest version and save changes.

More Information