DEV Community: Dasha

Call center automation: how I created a conversational AI app version of my own Apple customer support call in just 2 hours.

Dasha — Wed, 27 Oct 2021 15:25:28 +0000

This post is a bit different from what I’ve created before. This time, I’ve recreated an Apple Support operator-to-customer phone call in a form of an automated conversational AI app.

Let me give you the reason why I’ve decided to create this Apple customer support conversational AI app. My conversational with the human operator took about 7 minutes in total. That’s 7 minutes of someone’s time to answer 2 questions and 7 minutes of my time to ask them. I believe that artificial intelligence can be used to automate this type of customer support conversation, therefore saving operators time to focus on the most complex issues that require human creativity.

Take a look at the demo call to have a quick look at how the app works:

https://youtu.be/5S9OMcbSSuo

This app can serve you as a base to create your own customer support conversational AI apps and use it for call center automation.

Here are the steps we will take to create this app:

Getting started with Dasha conversational AI

If you have never used Dasha before, you need to activate your API key. The API key lets you load your conversational application to the Dasha Cloud Platform, where it is executed. If you have your Dasha API key, ignore this part.

Download the latest versions of Microsoft VSCode, Node.js and NPM installed. Dasha Studio is implemented as an extension to VSCode for your convenience. Open Visual Studio Code and install the Dasha Studio extension and Dasha Command Line Interface.

code --install-extension dasha-ai.dashastudio && 
npm i -g "@dasha.ai/cli@latest"

Now, run a command to register your Dasha API key. A browser window will pop up and you will need to sign up for an account.

dasha account login

Afterwards, run to check your API key.

dasha account info

Now let’s get to know the files you’ll be using to create your conversational AI app. We recommend downloading Dasha Blank Slate app source code and use it as a base to write your code.

For that, you’ll have to open main.dsl and data.json files and delete everything you see there. This way, you’ll be able to start writing your code from scratch while having all the other essential files (for instance, the commonReactions library that has pre-programmed replies so you don’t have to worry about coding those).

You can also download the source code of this conversational AI app here.

You’ll mainly be using 2 files to create your conversational AI app:

main.dsl -- this is where you’ll write your DashaScript Language code to create the workflow of your conversational AI app. With Dasha Studio extension on and with the directions in this post, it’ll be an easy job for you. You can read more about it in our documentation.
data.json -- is the data set you provide to train the Dasha Cloud neural networks to recognize user intents and identify named entities.

Additionally, you will want to use the index.js file to write out external functions. External functions are needed to process data with the SDK. For example, you may need to process data, get access to databases or APIs or use it for any other purposes.

index.js -- is the server-side JavaScript file to which the Dasha SDK is imported and which launches the contents of the /app folder to the Dasha Cloud to be executed. Here you’ll be adding any external functions you deem necessary once adapting the code to your company’s needs.

Familiarizing yourself with the files is important, but now let’s get to the fun part - programming the recreated Apple customer support conversational AI app!

Purpose of the conversation

The conversation I had with the call center representative was quite short, though informative. My purpose was to ask 2 main questions:

What can I do to get my mom’s iPhone broken screen fixed.
How can I trade in my own phone and get a discount for a newer model.

Throughout the code you’ll see what kind of questions I asked and the way they were answered.

Start with the basics

First of all, download the source code of this conversational AI app to be a form of a guide to you.

Now, the basics here are 2 things:

importing common library

import "commonReactions/all.dsl";```



* writing our the context for the app



```dsl
context 
{
    // declare input variables phone and name  - these variables are passed at the outset of the conversation. In this case, the phone number and customer’s name 
    input phone: string;

    // declare storage variables 
    output first_name: string = "";
    output last_name: string = "";
    output phone_model: string = "";
    output owner_phone_model: string = "";

}

The next step is writing your first node called root. Take a look at how it’s written out:

start node root 
{
    do 
    {
        #connectSafe($phone);
        #waitForSpeech(1000);
        #sayText("Hi, thanks for calling Apple Support. My name is Dasha. Can I get your name, please?");
        wait *;
    }   
    transitions 
    {

    }
}

We’re achieving multiple things here. In the do section we establish a connection to the user’s phone, wait for 1 second to speak (or give the user 1 second to say something), and then say our welcome message.

Since we need to know the user’s name, we should write where the conversation should go after we get that information in the transitions section. We make a transition to the node that follows once a particular intent gets triggered (#messageHasData("first_name");).

Let’s take a dive into the data.json file and take a look at how entities work there:

  "entities": {
    "first_name": 
    {
      "open_set": true,
      "values": 
      [
        {
          "value": "John"
        },
        {
          "value": "Bridgette"
        },
        {
          "value": "James"
        },
        {
          "value": "Sarah"
        },
        {
          "value": "Jermaine"
        },
        {
          "value": "Roseanne"
        },
        {
          "value": "Ahmed"
        },
        {
          "value": "Tony"
        },
        {
          "value": "Jon"
        }
      ],
      "includes": 
      [
        "(Oscar)[first_name]",
        "(Danielle)[first_name]",
        "My name is (Sophie)[first_name]",
        "My name is (Sarah)[first_name]",
        "My name is (Cameron)[first_name]",
        "My name is (Steven)[first_name]",
        "My name is (Jessica)[first_name]",
        "My name is (Jon)[first_name]",
        "My name is (Ahmed)[first_name]",
        "My first name is (Lisa)[first_name]"
      ]
    },

The includes section is very helpful. It provides you with an opportunity to have your model trained better as you feed it more examples.

Onexitsection lets the conversational AI app store, remember, and later use the variables we feed it. In this case, we assume the user might say their last name, first name, or both. And we got to store that information for later use. Note that this information will be used in the node you specify right after onexit.

Moving on to the next nodes.

In the following digression, our purpose is to program the conversational AI app to ask the user about their concern or problem and then transition to the corresponding nodes (or digressions).

digression how_may_i_help
{
    conditions {on #messageHasData("first_name");} 
    do 
    {
        set $first_name =  #messageGetData("first_name")[0]?.value??"";
        set $last_name =  #messageGetData("last_name")[0]?.value??"";
        #sayText("Hi," + $first_name + " how may I help you out today?");
        wait *;
    }
}

Note that in the onexit section, what comes after set goes to our context up above.

On the phone call, I mentioned my problem: a broken phone screen. But I haven’t mentioned the model of my iPhone. Naturally, the operator asked me that question and our app shall do the same:

node what_phone_model
{
    do
    {
        #sayText("Could you tell me the model of the phone, please?");
        wait *;
    }   
    transitions
    {

        broken_phone_screen: goto broken_phone_screen on #messageHasData("phone_model");
    }
    onexit
    {
        broken_phone_screen : do {
        set $phone_model =  #messageGetData("phone_model")[0]?.value??"";}
    }
}

Next, we need to ask qualifying questions to make the final answer to the first question as accurate as possible.

node broken_phone_screen
{
    do 
    {     
        #sayText("Gotcha, we're more than happy to help you with getting the phone screen fixed. I'm gonna need one moment."); 
        // a pause in between sentenses for more human-like interaction
        #waitForSpeech(1000);
        #sayText("Okay," + $phone_model + " , let me see. Alright. Do you know if you've got Apple Care coverage on you?");
        wait*;
    }
    transitions
    {
        no_apple_care_explain: goto no_apple_care_explain on #messageHasIntent("no") or #messageHasIntent("no_apple_care") or #messageHasIntent("how_much_for_repair_with_no_apple_care");
    }
}

Here (in the transitions section and following nodes) I didn’t program the app to have an answer to a “yes, I do have Apple Care coverage” as I wanted to stick to the original conversation as closely as possible for it to be more realistic.

We got information that the user has no Care coverage. I’m glad I wasn’t asked to buy Apple Care on the spot.

Pro note: upselling is nice, but always remember that the rule of the thumb and the main purpose of a conversational AI app is to solve the user’s problem as fast and as efficiently as possible.

node no_apple_care_explain
{
    do 
    {
        #sayText("Alright. So, when it comes to getting Apple Care, it can actually only be purchased within 60 days of originally purchasing the device... Other than that once there's actual damage to the phone, you're actually not allowed to purchase Apple care.");
        wait *;
    }   
    transitions 
    {
        confirm_phone_model: goto confirm_phone_model on #messageHasIntent("broken_phone_screen_replace_cost") or #messageHasIntent("how_much_for_repair_with_no_apple_care");
    }
}

In the do section we don’t pose any questions. This means the conversation doesn’t have to necessarily go the direction we program it to go in the transitions section. It can go to one of the digressions instead, depending on what the user is thinking.

In my case, I asked the call center operator how much I’d have to pay to repair the phone screen without having Apple Care on me. And that’s what I wrote in the intents section in the data.json file for that:

{
  "version": "v2",
  "intents": 
  {
    "how_much_for_repair_with_no_apple_care": {
      "includes": [
        "how much does it cost to repair without apple care",
        "how much will it cost to repair without apple care",
        "how much would it cost to repair without apple care",
        "Without apple care how much does it cost ",
        "what's the price to repair the phone with no apple care",
        "what's the price for reparing phone without apple care",
        "cost without apple care",
        "if I don't have apple care, how much would it cost me to repare",
        "without having apple care how much the repair",
        "no apple care, how much would it cost to repair the screen",
        "reparing the screen without apple care"
      ]
    },
    "broken_phone_screen_repair_cost": {
      "includes": [
        "how much does it cost to repair a broken screen",
        "how much does it cost to repair a cracked screen",
        "how much would it cost to repair a cracked phone screen?",
        "what's the price to repair a cracked screen",
        "what's the price to repair the broken screen",
        "how much does it cost to fix a broken phone screen",
        "cost of broken phone screen",
        "price to fix a cracked screen on the phone"
      ]
    },

Under includes you write words or phrases that you know your user would say in a particular instant. There can be as many variations as you like.

Next node is all about confirming the phone model the user has already mentioned before. It’s only natural for a human to ask such a confirmation question and by the same token makes the conversational AI sound more natural. And that’s besides providing feedback to the user that we got all the information right.

node confirm_phone_model
{
    do 
    {     
        #sayText("Yes, I'm pulling that up now..."); 
        #waitForSpeech(1000);
        #sayText(" " + $phone_model + " Is it Pro or Pro Max, you said?");
        wait*;
    }
    transitions
    {
        screen_repair_price: goto screen_repair_price on #messageHasIntent("no") or #messageHasData("phone_model") or #messageHasIntent("not_pro_pro_max") or #messageHasIntent("phone_just_as_i_said");
    }
}

Next up I have 2 identical phrases mapped in 2 different ways: digression and node.

Nodes are stable. They let the conversation move from one point to another in a linear way. Digressions, on the other hand, are like conversational zigzags, the conversation could jump from one digression to another and then back (if needed).

In this particular case, I wrote both because I used the following node in my previous node’s transitions section.

node screen_repair_price
{
    do 
    {     
        #sayText("Okay gotcha, so that pricing is showing one ninety-nine and that of course plus tax most likely."); 
        wait*;
    }
    transitions
    {

    }
}

digression screen_repair_price
{
    conditions {on #messageHasIntent("pnot_pro_pro_max") or #messageHasIntent("phone_just_as_i_said") and #messageHasData("phone_model");} 
    do 
    {     
        #sayText("Okay gotcha, so that pricing is showing one ninety-nine and that of course plus tax most likely."); 
        wait*;
    }
}

The transitions here are empty. That means the conversation can go to one of the digressions based on the intents triggered.

Here’s a very simple digression that a customer support representative provides the user with the information on the timing of the repair.

digression time_no_parts_available
{
    conditions {on #messageHasIntent("time_no_parts_available");} 
    do 
    {     
        #sayText("It depends, but the average time is about three to five business days. And that's for mailing in the phone instead of going to the store. That being said, I've never heard of the screen repair taking longer than this time frame."); 
        wait*;
    }
}

And yet another simple digression that will get triggered shall a user ask what the mailing/shipping options are.

digression mailing_option_pricing
{
    conditions {on #messageHasIntent("mailing_option") or #messageHasIntent("mailing_option_pricing");} 
    do 
    {     
        #sayText("Alright, so with shipping, we only ship with UPS or FedEx. That typically costs about 5 to 6 dollars. Could be a bit more expensive, though."); 
        wait*;
    }
}

In my real-life conversation with the Apple support representative, I got all the information I required. So it was time for me to move on to my next question about trading in my phone to get a newer version.

Note that it’s a digression since the question I asked popped out of the blue.

This digression structure follows the same logic as the digressions above, so should be easy breezy for you.

digression trade_in_update
{
    conditions {on #messageHasIntent("upgrade_phone") or #messageHasIntent("trade_in_phone");} 
    do
    {
        #sayText("Could you tell me the model of the phone, please?");
        wait *;
    }   
    transitions
    {
        trade_in_cost: goto trade_in_cost on #messageHasData("phone_model");
    }
    onexit
    {
        trade_in_cost : do {
        set $owner_phone_model =  #messageGetData("phone_model")[0]?.value??"";}
    }
}

Next up is a very simple node that we program to let the user know how much money that would have as a trade-in credit for the purchase of the new iPhone:

node trade_in_cost
{
    do 
    {   
        #sayText("So with the " + $owner_phone_model + " in prestine condition you can get up to 500 dollars in trade-in credit. That's for the next generation phone."); 
        wait*;
    }
    transitions
    {

    }
}

Similarly, here we let the user know how much the final cost of the phone be after the credits are applied:

digression new_phone_price_after_discound
{
    conditions {on #messageHasIntent("new_phone_price_after_discount");} 
    do 
    {     
        #sayText("The best thing to do is to go to apple dot com because there are different variations to the phone. But the bottom level model with no Apple Care is showing to be 599 dollars after trade it for 128 gigabyte phone. This is a subtotal without tax."); 
        wait*;
    }
}

At this point I got both of my questions answered and my conversation with the Apple Support operator ended.

digression thats_it_bye
{
    conditions {on #messageHasIntent("thank_you") or #messageHasIntent("that_would_be_it");} 
    do 
    {     
        #sayText("No problem, happy to help. I hope you have a great rest of your day. Bye!"); 
        #disconnect();
        exit;
    }
}

And that’s it. End of the conversation with all issues tackled the easiest way possible.

Despite this being my whole conversation, I’ve written out more digressions that solve some of the most common user’s problems:

Frozen screen
Phone doesn’t get charged
Accidental purchase on Apple Store, iTunes, etc
User forgot their iPhone password
iPhone got water damage

On the Apple website, all the abovementioned solutions don’t provide an immediate answer. Instead, the users are prompted to contact chat- or voice-based support. These use cases and so many more can be automated by creating one simple conversational AI app that will tackle all the FAQs in the operator’s stead, saving the company money and time of the operators.

Final note

Naturally, this is just a demo and is a mirror-like reflection of my own conversation with the Apple Support operator. However, the good news is that this could serve as a solid base for your own customer support conversational AI apps. Or for automating your call center, for example.

The best thing to do now (and a great opportunity to learn by practicing) is opening the source code and adjusting it to make it fit your criteria.

And the number one best thing to do is to join Dasha Developer Community where you’ll meet welcoming like-minded developers who share ideas, questions, and get all the help they need (for free, of course).

I’m looking forward to seeing your success story in Dasha Developer Community! :) See you there soon!

What is Dasha AI?

Dasha — Wed, 13 Oct 2021 19:31:10 +0000

You’ve probably heard the terms “conversational AI” and “chatbot” being thrown around. Nowadays, it seems like everyone is getting into the chatbot game, but what is Dasha AI? What does it mean to be a conversational-AI-as-a-service?

In this article, I’ll explain all of this and more. I’ll also describe the Dasha AI Platform, how it operates, and give you a few examples of what you can do with Dasha.

What is Dasha AI?

Dasha is a conversational-AI-as-a-service platform that lets you embed realistic voice and text conversational capabilities into your apps or products. By creating a simple conversational AI app, you can create a conversational experience that is natural, intuitive, and engaging. Just like a human, Dasha can hold a conversation with you, ask questions, and help you and/or your company complete tasks that can be and should be automated.
To sound indistinguishable from a human, Dasha uses a set of machine learning (ML), natural language processing (NLP), text-to-speech (TTS), speech-to-text (STT).

What can you build with Dasha?

You could start off by building a simple insurance customer service app:

Embedded content: https://www.youtube.com/watch?v=46nyWBTSHgs

Or an automated receptionist for a hotel front desk:

Embedded content: https://www.youtube.com/watch?v=2Glp_HC-VHc&t=29s

OR you can integrate Dasha with an incident management platform to be able to resolve incidents on the go:

Embedded content: https://www.youtube.com/watch?v=TeJAFI993_0

Or build an app to qualify inbound leads and integrate it with Hubspot:

Embedded content: https://youtu.be/MjKQ2Zibqgk

How Dasha works

Architecture overview

Dasha platform consists of 3 main parts:

Dasha Cloud
Dasha SDK
Dasha Studio

Dasha SDK

The Dasha SDK (software development kit) is an abstraction layer that lets you connect your locally stored conversational application to the Dasha AI as a service cloud platform where it is executed. It hides (abstracts) communication channels from you and, like other libraries, gives you a programmable Node.js interface that you can use every day.
We regularly update Dasha SDK so that the users have the best experience possible.

Dasha Cloud

Dasha Cloud provides conversational AI as a service. This means that you don’t need to be a data scientist to use machine learning when building Dasha conversational apps. For example with Dasha Cloud, your app uses an NLU based on neural networks that are trained with the data you provide, Speech To Text, Voice Activity Detectors, and many other things.
Here is a detailed overview of these cloud AI services.
We use GRPC for communication between SDK and the Dasha Cloud. Here are its advantages:

You can connect to Dasha from anywhere, from your PC, from a test environment, from another cloud.
You do not need to have the public IP address, DNS name, TLS Certificate, because the connection is initiated from your side. Dasha has DNS names, TLS Certificates.
It's easier to implement A/B testing and scaling of your application.
It's secure. You do not need to expose any HTTPS endpoints to the world.

Dasha Studio

Dasha Studio is a Visual Studio Code extension. It lets you build, train manage and deploy Dasha applications. Dasha apps are human-like voice interfaces for CX, support, sales,notifications, smart IVRs or voice interfaces for web and mobile applications and games.You can also add conversational capabilities to websites, games, mobile apps, voice assistants, smart devices, and more with only a few lines of code, from Visual Studio Code.
Since Dasha is an open technology you can write Dasha apps without using Dasha Studio but you will lose out on the syntax highlighting, visual graph editor and debugging tools. All code you write resides on your machine and is your intellectual property.
The language you'll be using to write your conversational AI apps is DashaScript which is the native language of the Dasha Cloud Platform.

DashaScript

DashaScript is an event-driven declarative programming language used to design complex real-world conversations that pass a limited Turing test. Automate call center conversations, recreate the Google Duplex demo in under 400 lines of code or create a no-code GUI for your users that translates into DashaScript code.
DashaScript program consists of nodes representing AI actions and transitions between nodes representing conversation events. The program written in DashaScript is called a script. The script is an integral part of your dashaapp that determines its behavior at runtime.

Files that comprise your Dasha conversational AI app

Take any Dasha app. You will see the /app folder - this is where your Dasha application resides.
In building Dasha apps in VSCode, you will mainly work with three files:

main.dsl is the Dasha Scripting Language file. DSL is a domain-specific language, derived from TypeScript and used for the exclusive purpose of describing a conversation. You can read more about it in our documentation.
data.json is the data set you provide to train the Dasha Cloud neural networks to recognize user intents and identify named entities. I'll discuss them in detail right below.
index.js is the server-side JavaScript file to which the Dasha SDK is imported and which launches the contents of the /app folder to the Dasha Cloud to be executed.

Join Dasha Developer Community and check Dasha out for yourself

Join us in the Dasha developer community for guidance on your exciting journey of conversational AI app creation. We share thoughts, ideas, problems, and solutions here. See what you can create!

Godspeed! :)

How to integrate Hubspot with Dasha AI using Zapier to automatically qualify leads over the phone

Dasha — Mon, 11 Oct 2021 13:37:21 +0000

Every two minutes that an inbound lead waits to receive a call from your SDR lowers the likelihood of a closed deal by 5%. Instead of waiting for an SDR to call the lead or sending an automated email like everyone else, have a conversational AI app automatically call to the user as soon as they submit the form on your website.

I previously wrote a tutorial on how such an app can be built using Dasha. Today we will integrate this app into a workflow, in less than an hour. We will use the recently deployed official Dasha Zapier integration to do this. For this tutorial we will use the following tools:

Here is the process at a glance:

We create a stand-alone form on Hubspot with the fields "First Name", "Email" and "Phone".
We point to this form submission as the action that initiates the Zap in Zapier.
We launch a call with the Dasha Zapier integration and pass Name and Phone as input variables.
Once the call is complete, we write all the collected information to specially created fields in the Hubspot lead card using another Zapier step.

Now, let's get started.

Setting up your Dasha app

For this tutorial we will reuse code that I wrote previously. It is a conversational AI app that qualifies inbound leads for a company (ACME Software) that sells a software for invoicing automation. At its core, the app checks if now is a good time to talk, asks a few questions and asks when a good time for the user to take a call from an account executive is. Let's get this application opened in your development environment.

Make sure you have the latest Microsoft Visual Studio Code, Node.js and NPM installed. Dasha Studio is implemented as an extension to VSCode for your convenience. Open Visual Studio Code and install the Dasha Studio extension and Dasha Command Line Interface .

code --install-extension dasha-ai.dashastudio && 
npm i -g "@dasha.ai/cli@latest"

Now, run a command to register your Dasha API key. A browser window will pop up and you will need to sign up for an account.

dasha account login

Afterwards, run to check your API key.

dasha account info

Now, you need to clone the inbound leads Dasha app and open the folder in which it is located. We will be cloning this app.

git clone https://github.com/dasha-samples/inbound-lead-qualification
cd blank-slate-app

In building Dasha apps in VSCode, you will mainly work with three files:

main.dsl is the Dasha Scripting Language file. DSL is a domain specific language, derived from TypeScript and used for the exclusive purpose of describing a conversation. You can read more about it in our documentation.
data.json is the data set you provide to train the Dasha Cloud neural networks to recognize user intents and identify named entities.
index.js is the server-side JavaScript file to which the Dasha SDK is imported and which launches the contents of the /app folder to the Dasha Cloud to be executed.

Note that last bit. "launches the contents of the /app folder to the Dasha Cloud to be executed". This means that when your Dasha application is launched from Zapier, it only functions as the contents of the /app folder.

Take a look at the main.dsl file, namely the context variables, beginning at line 7.

context 
{
    input phone: string;
    input name: string = "";

    output software: string = "";
    output invoices: string = "";
    output lead_source: string = "";
    output calltimeday: string ="";

    calltime: string = "";
    callday: string = "";
    callback: string = "";
    visitedNodeTime: boolean = false;
    visitedNodeQuestion1: boolean = false;
}

Note that you are taking Input variables name and phone and outputting variables software, invoices, lead_source and calltimeday. This is a key ingredient to the Zapier integration. We will input the name and phone from the collected form data and output all of our output variables to be saved to the lead card in Hubspot.

Now, you need to run a sample. It will serve two purposes. You will test the app and secondly, you will register the app in the Dasha Cloud to your account, so that you can refer to it from Zapier in building your integration.

npm i 
npm start 12223334455

Where 12223334455 is your phone number in the international format.

Setting up Hubspot

Log into your Hubspot account. Everything we will do here today can be done with the free Hubspot package. We will do two things:

Create a stand-alone form
Add a few custom Contact properties

Creating a form

On the top menu, hit Marketing > Lead capture > Forms.

Now, click Create Form in the upper right corner, select Standalone Page from the Form menu and click Next. Pick Blank Template and click Next again. Name your form (I named mine "Zapier test form") and add the following fields: First Name, Last Name, email, Phone number.

Click Update > Publish. You will get a pop up with the link to access the form. Copy this link and set it aside, we will need it to test the integration.

Create custom fields (properties) in Hubspot

Refer back to the output variables in main.dsl. We need to map fields in Hubspot to four output variables. Here is how I named mine in Hubspot:

calltimeday > call_time_day_test
invoices > invoices_test
lead_source > lead_source_test
software > software_test

Click on Settings, then Properties and finally Create Property.

Select
Object Type > Contact
Group: Contact information
Label: your name for the property

Hit Next, and select field type: single line text.

Do the same for the other 3 properties.

Now, let's make these properties clearly visible on the lead card, so that you can easily look at the results of the test. Open any contact by going to Contacts > Contacts and clicking on any one of them. Now, scroll a bit down and click "View all properties".

Now, search for each of your newly added properties by their name and click "Add to your view"

Great, our Hubspot is ready to go. Before moving to the next step, use that link to the form that you copied earlier to open up the form in a browser window, fill it out and submit. Use your real phone number in the international format (12223334455). This will give us some data for Zapier to use in the next step.

Create a custom Zapier Zap integration

Log into your `Zapier account. The Zap we are building is a complex multi step integration. Zapier free users only get to build two step integrations, so you will need to get the 7 day free trial of premium Zapier personal account to build this integration.

Once sorted, click "Create Zap" in the upper left corner. Name the Zap and search for Hubspot as the first kick off event.

Choose "new form submission" for the trigger event and hit "Continue". In the next step you will need to add a hubspot account. If you've never used one, click "+ Connect a new account". Once connected, click "Continue". Now you will be asked to set up the Trigger. Choose your Hubspot form name from the drop-down, click refresh fields and click "Continue". If you have previously filled out the Hubspot form, you should see something like this:

Click "Continue" and search for "Dasha" for Step 2. We will now connect Zapier to Dasha Conversational AI API.

In the Action Event Drop-down, select "Make a Call" and "Continue". In the next "Choose account" drop-down, select your account and click "continue".

On the next screen, choose "Provided by Dasha" for the dropdown "SIP Trunk to use", choose "inbound-leads" for the "Application to use" dropdown and select the upper-most value for "Application to use" dropdown. Once you select the application, two new fields should appear: "Phone" and "Name". These are the input variables required by the Dasha app. Select from the drop down appropriate fields, as collected by the Hubspot form. (Note if the fields "Name" and "Phone" do not appear, hit the "refresh fields" button).

Click "Test & Continue". You should get a call from your Dasha app. You will likely not see proper data appear in Zapier, do not fret, this seems to be the way it works. Once your Zap is complete, it will work as you want it to.

Click the little plus sign below to go to the next step.

In order to write data to Hubspot, we need to have the Contact ID number. Since we do not have it, we have to first make a request to Hubspot API to find the contact's ID using the contact's email (which we do have). Choose Hubspot under "action". For dropdown "Action event" look for "Find Contact". Next, select your Hubspot account. In the Set Up Action menu, select "Contact Information: Email" under "FIrst search property name" and for "First search property value" choose the email field from the first action (Hubspot form submission).

Click "Continue" and then "Test & Continue." Now, click the + sign to create a new action. This final action will let us write the data collected by Dasha to the contact card in Hubspot.

Select Hubspot and "Action event": Update contact. Hit "Continue". Choose your Hubspot account and hit "Continue" again. Under Object ID select the ID value we hav received in the previous step.

Now, scroll down to find all the property field names we have previously added to Hubspot:
call_time_day_test
invoices_test
lead_source_test
software_test

For each, select the appropriate output data type from "Step 2 - Make a Call with Dasha", as such:

Hit "Continue" when you are done and "Turn on Zap".

Testing the Hubspot-Dasha-Hubspot Zapier integration

Now to the fun part. Fill out your form again. Within 30 seconds you should get a call from Dasha. Give it all the information it asks for. Now, go to your lead card in Hubspot, you should see something like this:

In conclusion - you should make changes to the Dasha app, adapt it to the realities of your use case and tell us how it went in the Dasha community.

AI devops squad to the rescue: How to use voice AI to make your site reliability engineering more efficient

Dasha — Wed, 06 Oct 2021 18:44:36 +0000

Originally published on https://dasha.ai/en-us/blog/voice-AI-site-reliability-engineering by Arthur Grishkevich

Voice AI and site reliability engineering? What a ridiculous match up. The two live in completely different worlds. The former in the world of pesky call centers, the latter in the world of ponytailed sys admins.

I could end my post here if not for one thing. I signed up to give a lecture on using voice AI for site reliability engineering at conf42. Why would I do a stupid thing like that? Because I had a vision of how the two can work together.

Intro and definitions

In this tutorial we will use the following technologies and tools:

Webhooks
HTTPS requests
Site reliability monitoring (we will use Better Uptime)
Conversational voice AI (we will use Dasha)

First, let's do definitions:

Site reliability engineering - principles of software engineering applied to infrastucture and operations problems.
Incident - something bad that happens to your site. In other words, your site was up, an incident happens, now it's down. Incidents are reported by site reliability monitors.
Incident acknowledgement - once an incident is reported, it has to be confirmed by a responsible individual (you).
Incident resolution - after incident is acknowledged, it has to be resolved (that is, if you want your website to be up and running again).
Conversational AI app - an automated conversation built for a specific need, integrated with tools you already use, powered by AI.

What's wrong with the current incident reporting workflow?

Nothing really wrong with it but it can be made more efficient.

As an example, let's look at Better Uptime, since this is what we will be integrating with. You add a domain for Better Uptime to monitor. Every 30 seconds it sends an HTTP and ping request to the website. If the website is down, an incident is created. At this point, you are notified either via email, SMS, phone call or by sending out a webhook wherever you specify.

Once the incident is created, it needs to go through two more lifecycle stages. Stage one is - acknowledgement, the responsible user need to acknowledge the incident happened. The next stage is resolution - the same user or a different user with access to this monitor needs to set the incident as resolved. After its resolution, Better Uptime checks again to see if the website is indeed up.

How do I think this can be made more efficient? By adding a devops conversational AI app that will call the user when an incident happens, provide updates to the user from additional services (Kubernetes cluster, TLS certificates, etc.), be able to notify co-workers and finally, set the acknowledge and resolve statuses in Better Uptime. There are two main use cases/benefits I see here:

The responsible user may be away from their machine, as the incident happens. They can check some of the systems from their phone and maybe even resolve the issue but why force them to waste time logging into Better Uptime if they can just put the phone on speaker and resolve everything with the AI app?
The user might indeed be at their computer but to resolve the incident would have to log onto a half dozen websites and click tons of things. With the AI app they will be able to get all info/data they need through a simple voice question, as well as set appropriate incident statuses in Better Uptime.
And I'm sure you will find a dozen more ways in which this tech would be useful in your devops workflow.

"But Arthur," I hear you shout "you said that Better Uptime can notify the responsible user through a phonecall when the incident happens. All on its own!"

I certainly did say that. But it is not a conversational phone call. It's a very simple "Hi there, you had an incident. Bye." call. Which is still great. But can be made much better.

Here is what I built:

Embedded content: https://www.youtube.com/watch?v=TeJAFI993_0

And here is how you can build it in ten easy steps to build our SRE conversational AI for devops:

Create a Better Uptime account.
Activate Dasha API key.
Create a server for Better Uptime to monitor.
Create a server to listen to webhooks from Better Uptime and launch the Dasha app.
Build a Dasha conversational app that will call to you when an incident is created; set up external functions and HTTPS requests to Better Uptime.
Set up nodemailer to email yourself a transcript of the conversation.
Set up .env.
Set up a tunnelling service to your localhosts.
Set up the monitors and webhooks on Better Uptime.
Test.

I urge you to follow the tutorial and build this thing on your own. Yet if you want it, here is the source code.

1. Create a Better Uptime Account

First off, you'll need a Better Uptime account. Unfortunately, to send webhooks out you will need a paid account. And we will need to send webhooks. There are at least a dozen Better Uptime alternatives that I was able to find, some of which might offer free webhooks. I'm using Better Uptime because we already use it for our SRE workflows at Dasha.

So, step 1, go to Better Uptime and register an account.

2. Activate Dasha API key

Now, you need to activate your Dasha API key. If you have your Dasha API key, ignore this part. Open Visual Studio Code and install the Dasha Studio extension and Dasha Command Line Interface .

code --install-extension dasha-ai.dashastudio && 
npm i -g "@dasha.ai/cli@latest"

Now, run a command to register your Dasha API key. A browser window will pop up and you will need to sign up for an account.

dasha account login

Afterwards, run to check your API key.

dasha account info

Now, you need to clone a blank Dasha app and open the folder in which it is located. We will be cloning this app.

git clone https://github.com/dasha-samples/blank-slate-app
cd blank-slate-app
npm i

3. Create a server for Better Uptime to monitor

In the root of the folder you've got open in VSCode, create a new Node.js file. You can name it anything, I named it helloworld.js.

Use this code for the super simple server:

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World. Server is up.');
});

server.listen(port, hostname, () => {
  console.log("Server running at http://${hostname}:${port}/");
});

Now, launch it.

node helloworld.js

4. Create a server to listen to webhooks from Better Uptime and launch the Dasha app

Open index.js and delete all code. We will start from scratch here. We will do much more than just create the webhook listener server. We will build a Node.js application that will launch your Dasha AI conversational app, collect data from the app, send HTTPS requests to Better Uptime when your Dasha app requires it and email a formatted transcript of the conversation to your specified email address.

We will use Express.js to run the server. We will also use fs, Dasha SDK, body-parser, json2html, axios and dotenv. Let's start off with the declarations and go ahead and create the server. :

const dasha = require("@dasha.ai/sdk");
const fs = require("fs");
const express = require( "express" );
const bodyParser = require("body-parser");
const hook = express();
const PORT = 1919;
const json2html = require("node-json2html");
const axios = require("axios").default;

require("dotenv").config();

hook.get('/', (req, res) => {
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello World. Server running on port " + PORT + ". Listening for incidents on http://1543a913a2c7.ngrok.io As soon as incident is identified, I will initiate a call from Dasha AI to ackgnowledge or address the incident. ");
})

hook.use(bodyParser.json());
hook.listen(PORT, () => console.log("🚀 Server running on port ${PORT}"));

Now, let's create the webhook listener. Note that Better Uptime sends a webhook out whever an incident is created, acknowledged or resolved. We only need to launch the AI call when the incident is created. I got the JSON structure above from the Better uptime Incidents API documentation. Please refer to the comments:

hook.post("/hook", async(req, res) => 
{
  console.log(req.body); // Call your action on the request here
  res.status(200).end(); // Responding is important
  // save incidentID from JSON as const incidentId 
  // we will need it to send acknowledged and resolved requests to Better Uptime 
  incidentId = req.body.data.id; 
  // we also save acknowledged and resolved statuses.
  // we will need these to keep Dasha from calling you when your incident is acknowledged or resolved
  acknowledged = req.body.data.attributes.acknowledged_at;
  resolved = req.body.data.attributes.resolved_at;
  // log the statuses 
  console.log("incidentID: " + incidentId);
  console.log("acknowledged: " + acknowledged);
  console.log("resolved: " + resolved);

  // Better Uptime sends out webhooks on created, acknowledged, resolved statuses for each incident 
  // we only need to run the Dasha app when the incident is created, thus we do the following: 
  if (acknowledged != null && resolved == null) 
  {
    console.log("Incident " + incidentId + " acknowledged.");
  }
  else if (acknowledged != null && resolved != null)
  {
    console.log("Incident " + incidentId + " resolved.");
  }
  else 
  { 
    console.log("Incident " + incidentId + " created. Expect a call from Dasha.");
    // Launch the function running the Dasha app  
    await calldasha(incidentId);
  }
});

Now, let's define the Dasha App function. Note the // external functions begin and // external functions end. We will add code for external functions here as we get to this point in creating our Dasha conversation.

Please refer to the comments:

async function calldasha(incidentId) 
{
  const app = await dasha.deploy("./app");

  // external functions begin 

  // external functions are called from your Dasha conversation in the body of main.dsl file 
  // external functions can be used for calculations, data storage, in this case, to 
  // call external services with HTTPS requests. You can call an external function from DSL
  // in your node.js file and have it do literally anything you can do with Node.js.

  // external functions end

  await app.start();

  const conv = app.createConversation({ 
    phone: process.env.phone, 
    name: process.env.name 
  });

  conv.audio.tts = "dasha";

  if (conv.input.phone === "chat") {
    await dasha.chat.createConsoleChat(conv);
  } else {
    conv.on("transcription", console.log);
  }

  if (conv.input.phone !== "chat") conv.on("transcription", console.log);

  const result = await conv.execute();

  console.log(result.output);

  //create directory to save transcriptions
  fs.mkdirSync("transcriptions", { recursive: true } );  
  var transcription = JSON.stringify(result.transcription);

  //save the transcript of the conversation in a file  
  // or you can upload incident transcriptions to your incident management system here
  fs.writeFileSync("transcriptions/" + (incidentId??"test") + ".log", transcription ); 

  // and  email it to yourself
  var transcript = json2html.render(transcription, {"<>": "li", "html":[
    {"<>": "span", "text": "${speaker} at ${startTime}: ${text} "}
    ]});
  sendemail(transcript);

  await app.stop();
  app.dispose();
}

node index.js

To test. Your server should run. When you set the webhook address up on Better Uptime and have this server running, a Dasha conversation will be initiated every time a new incident is created. Let's build the Dasha app.

5. Build a Dasha conversational app that will call to you when an incident is created

Open main.dsl. This is a Dasha Scripting Language file. DSL is a domain specific language, derived from TypeScript and used for the exclusive purpose of describing a conversation. You can read more about it in our documentation.

As always, we start off with declarations. Let's declare input variables and external functions.

context 
{
    input phone: string;
    input name: string;
}

// declare external functions here 
external function acknowledge(): string;
external function resolve(): string;
external function getstatusof( what:string? ): string;

Next, we have the AI app wait for speech (the user should say "hello" or something of the sort), then greet the user, inform of the incident and wait for instructions.

start node root {
    do {
        #connectSafe($phone);
        wait *;
    }
    transitions {
        hello: goto hello on true;        
    }
}

node hello {
    do { 
        #sayText("Hello " + $name + "! This is Dasha calling you regarding your website. There has been an incident. "); 
        #sayText("You can acknowledge or resolve the incident right on the call with me. "); 
        #sayText(" Please note, I will listen and take notes until you mention that you are ready to resolve or acknowledge. ", interruptible:true);
        wait *;
    }
    transitions {
    }
}

Note that I said "wait for instructions." In this case, the instructions will come in the form of a digression. A digression is a node in Dasha Scripting Language which does not necessarily flow from a previous node but can be called up at absolutely any point in the conversation. The digression becomes active when a specific intent is identified in the user's reply. Intents are defined as a data set in data.json used to train the Dasha Cloud neural network. Digressions are also useful in giving your app a human-like feel. You can read more about digressions in this post.

In this application we will have three key digressions for three key actions that the user can perform.

Acknowledge the incident.
Resolve the incident.
Ignore the incident.

We will also add four additional digressions to make the conversation more efficient:

Ask Dasha to wait while the user thinks something over or looks something up.
Ask Dasha to repeat what she last said.
Easter egg digression "oops".
Journal node - lets Dasha know to not react unless an intent is identified. This lets us passively record any notes that the user makes to self, as he is resolving the incident.
Get status of vital services. *

There are two steps to implementing digressions - define intents (create data set) in data.json and write out the code for the digressions in main.dsl. We will also need to write external functions in our index.js.

Creating the data set to train the Dasha neural network

Since digressions are activated by intents, we need to define our intents training data set in data.json. Once you run your conversational AI app, your data.json file is loaded in the Dasha Cloud, where it is used to train the neural network. The "includes" section for each intent is where you provide a set of phrases on which the neural net is trained to then recognize the user intent. You can (and should) read up on intents in the blog post by Ilya Ovchinnikov, the ML team lead who built out this engine for Dasha. Open up the file and delete everyting in it. Paste the code below in.

{
  "version": "v2",
  "intents": 
  {
    "yes": {
      "includes": [
        "yes", "sure", "yep", "I confirm", "confirmed", "I do", "yeah", "that's right"
      ],
      "excludes": []
    },
    "no": {
      "includes": [
      ]
    },
    "repeat": {
      "includes": [
      ]
    },
    "acknowledge": {
      "includes": [
        "I acknowledge the incident", "I can acknowledge the incident", "I do acknowledge the incident",
        "acknowledge", "acknowledge please", "incident acknowledged"
      ]
    },
    "resolve": {
      "includes": [
      ]
    },
    "ignore": {
      "includes": [
      ]
    },
    "oops": {
      "includes": [
      ]
    },
    "wait": {
      "includes": [
      ]
    },

    "status": {
      "includes": [
        "What is the status of (kubernetes)[statusentity]",
        "Dasha, what's the status of (kubernetes)[statusentity] and (TLS)[statusentity]",
        "What's the status of (kubernetes)[statusentity]",
        "Tell me about the status (healthcheck)[statusentity]",
        "Give me an update on the status of (healthcheck)[statusentity]",
        "Status (healthcheck)[statusentity] and (TLS)[statusentity]",
        "Dasha, let's look at the status of (TLS)[statusentity]"
      ]
    }

  },

  "entities": {
    "statusentity": {
      "open_set": false,
      "values": [
        {
          "value": "kubernetes",
          "synonyms": [
            "Kubernetes cluster", "cooper netease", "kubernetes", "Kubernetes instances", "for burnett", "Kubernetes deploy"
          ]
        },
        {
          "value": "TLS",
          "synonyms": [ "SSL", "TLS/SSL", "TLS certificate", "certificate", "SSL certificate"
          ]
        },
        {
          "value": "healthcheck",
          "synonyms": [ "site healthchecks", "health check ", "site health checks", "health checks"
          ]
        }
      ],
      "includes": []
    }
  }
}

You will see here a few complete intents ("acknowledge", "yes") that you will need to activate your digressions. The format is simple to follow - intent name is followed by a list of phrases ("includes") the user might use to signify their intent. You can follow this same format to specify phrases to define intents for the other digressions listed above.

Note the "status" digression. It is a compound intent and relies on named entities to function.

In this case, we are looking to identify two things within the user's phrase. One is the intent to "check the status of something" and the other is what the "something" is. The "something" is defined by named entities. Using named entity recognition, the neural network powering your app in the Dasha Cloud extracts important data from the user's speech.

You can always refer to the app source code to get a copy of my data.json file.

Writing the digressions in main.dsl

// acknowledge flow begins 
digression acknowledge {
    conditions { on #messageHasIntent("acknowledge"); }
    do {
        #sayText("Can you please confirm that you want me to acknowledge the incident?");
        wait *;
    } 
    transitions {
        acknowledge: goto acknowledge_2 on #messageHasIntent("yes");
        donotacknowledge: goto waiting on #messageHasIntent("no");
    }
}

node acknowledge_2 {
    do {
        external acknowledge();
        #sayText("Got it. I have set the status in Better Uptime as acknowledged. The next step is to resolve the incident.");
        wait *;
    } 
    transitions
    {
    }
}

node waiting {
    do{
        #sayText("Okay. I will wait for your instructions then. ");
        wait *;
    } 
}

The code above is for __digression acknowledge__ use it as an example to write code for the digressions resolve and ignore. Note that you do not need to recreated the node waiting - you only need to define it once and can call this node from other nodes or digressions, as needed.

Getting your node.js external functions to call external APIs

Note the external acknowledge();. Here we are calling out to the external function acknowledge which we have defined in the beginning of main.dsl.

As you recall, external functions call out to a specific function in index.js. We even left some space in our index.js file specifically for our external functions.

You can go ahead and paste the following code into your index.js between // external functions begin and external functions end:

  // external functions are called from your Dasha conversation in the body of main.dsl file 
  // external functions can be used for calculations, data storage, in this case, to 
  // call external services with HTTPS requests. You can call an external function from DSL
  // in your node.js file and have it do literally anything you can do with Node.js.

  // External function. Acknowledge an incident in Betteruptime through posting HTTPS  
  app.setExternal("acknowledge", (args, conv) => 
  {
    // this keeps the code from throwing an error if we are testing with blank data
    if (incidentId === null)
    return;

    const config = {
      // remember to set your betteruptimetoken in .env
      headers: { Authorization: "Bearer " + process.env.betteruptimetoken }
    };

    const bodyParameters = { key: "value" };

    axios.post( "https://betteruptime.com/api/v2/incidents/" + incidentId + "/acknowledge", bodyParameters, config)
    .then(console.log)
    .catch(console.log);

  });

  // External function. Resolve an incident in Betteruptime through posting HTTPS  
  app.setExternal("resolve", (args, conv) => 
  {  
    if (incidentId === null)
    return;

    const config = {
      headers: { Authorization: "Bearer "+ process.env.betteruptimetoken }
    };

    const bodyParameters = { key: "value" };

    axios.post( "https://betteruptime.com/api/v2/incidents/" + incidentId + "/resolve", bodyParameters, config)
    .then(console.log)
    .catch(console.log);
  });

  // external function getting status of additional services 
  app.setExternal("getstatusof", (args, conv) => 
  {
    switch (args.what)
    {
      case "kubernetes":
        return "Kubernetes is up and running";
      case "healthcheck":
        return "Site health checks are not responding";
      case "TLS":
        return "TLS Certificate is active";
    }
  });

Take a look at app.setExternal("acknowledge"). As you can see we are making an HTTPS post request to the Better Uptime API and are using the incidentId variable we collected when we first got the inbound webhook notifying us of incident creation. I referred to the Better Uptime API documentation for this.

Additional digressions in your Dasha app

Go back to your main.dsl. We need to add a few more digressions to make our app complete. Append these to your main.dsl file

// get status of vital services 
digression status  {
    conditions { on #messageHasIntent("status") && #messageHasData( "statusentity" ); }
    do {
        for (var e in #messageGetData("statusentity") ){ 
            var result = external getstatusof(e.value );
            #sayText( result );
        }
        return;
    }
}

Digression status becomes activated on that complex intent/named entity hybrid we built. If Intent "status" is identified AND the message carries data "statusentity", we collect the data (note: #messageGetData collects data as an array) and send each data point to external function getstatusof which, in turn, returns a string which Dasha pronounces out to the user. Please look at the app.setExternal("getstatusof") in the JavaScript code above. This function returns dummy data for the demo. Obviously in production, you would want to call out to specific end points to get realistic data here.

Now, add this code:

// additional digressions 
digression @wait {
    conditions { on #messageHasAnyIntent(digression.@wait.triggers)  priority 900; }
    var triggers = ["wait", "wait_for_another_person"];
    var responses: Phrases[] = ["i_will_wait"];
    do {
        for (var item in digression.@wait.responses) {
            #say(item, repeatMode: "ignore");
        }
        #waitingMode(duration: 70000);
        return;
    }
    transitions {
    }
}

// this digression tells Dasha to only respond to user replies that trigger an intent
// this is a very helpful little piece of code for our particular use case because 
// the user might talk to themselves as they are resolving the incident
// everyting the user says to themselves is logged (thus: journal) in the transcript 
// which can then be appended to the incident report 
digression journal {
    conditions { on true priority -1; }
    do {
        return;
    }
}

digression repeat {
    conditions { on #messageHasIntent("repeat"); }
    do {
        #repeat();
        return;
    }
} 

digression oops {
    conditions { on #messageHasIntent("oops"); }
    do {
        #sayText("What happened " + $name + "? Did you ue the wrong terminal again?");
        return;
    }
}

Digressions wait and repeat help progress the conversation along. The user can ask Dasha to wait a minute, or to repeat her last phrase. The digression oops is an easter egg, activated with the intent words "oops", "crap", or your favorite exclamation. The digression journal tells the Dasha app to stay quiet until it hears the user say one of the specificly defined intents. Everything that the user says before the intent is loggled into the transcript. This digression lets the user dictate notes to Dasha which are then collated into the transcript. The transcript can be attached to your incident management system. In this case, we will email the transcript to a specified address.

6. Set up nodemailer to email yourself a transcript of the conversation

Look at the last 11 lines of code in the function used for launching your Dasha app that you added to your index.js earlier. Dasha conversation transcripts are JSON. In this code, we are formatting the JSON as HTML and emailing it. To email the code, we call the sednemail(transcript) function.

Let's now add this function to our index.js application.

function sendemail(transcript)
{
  const nodemailer = require('nodemailer');
    require('dotenv').config();

  var transporter = nodemailer.createTransport(
  {
      service: 'gmail',
      auth: {
              // be sure to specify the credentials in your .env file
        user: process.env.gmailuser,
        pass: process.env.gmailpw
      }
  });

  var mailOptions = 
  {
    from: process.env.gmailuser,
    to: process.env.sendto,
    subject: 'Incident conversation transcript',
    html: '<h2>Conversation transcript:</h2><p>' + transcript + '</p>'
  };

  transporter.sendMail(mailOptions, function(error, info)
  {
      if (error) {
          console.log(error);
      } else {
          console.log('Email sent: ' + info.response);
      }
  });
}

This code will send an email from your Gmail account to the specified address.

7. Set up .env

You will need to create .env file named ".env" (make sure you have dotenv installed).

In this file you will need to define the following tokens and/or credentials:

betteruptimetoken = 
name = 
phone =
sendto = 
gmailuser = 
gmailpw =

betteruptimetoken is, expectedly, your Better Uptime API token. If you are using a different service, rename the enviornment variable accordingly. If you are using Better Uptime, you can find the token by going to team members > configure team and scroll halfway down.

name is quite literally the name which Dasha will use to refer to you.

phone is the phone number Dasha will call you on. As with name, you are welcome to push this data to Dasha externally.

sendto is the email address to which you want to send your transcript.

gmailuser is your Gmail email address.

gmailpw is your Gmail password.

There is a bit of nuance about those last two. You will need to have additional security disabled on your Gmail account to use simple auth like this. Your other option is writing our OAuth2 authentification as per this StackOverflow thread.

At the end of this step, you should have all needed environment variables defined in your .env file.

8. Set up a tunnelling service to your localhosts.

Open split terminals in your VSCode. In one, run:

node helloworld.js

In the other, run:

node index.js

Congrats, you should have two servers running. helloworld.js on port 3000 and index.js on port 1919. They are running as localhosts which will not do because we need them to interact with the web. To solve this you can use a local tunnel. I used Ngrok but you can use any other one.

To use Ngrok, you will need to sign up and follow these instructions. Once you have got Ngrok installed and authorized, open two terminal windows (I did outside of VSCode) and run this command in one:

./ngrok http 3000

and this command in the other terminal:

./ngrok http 1919

This will create two internet domain names which will tunnel to your locally hosted servers. Note: you may have to purchase the paid Ngrok subscription for two tunnels.

9. Set up the monitors and webhooks on Better Uptime

Let's assume that Ngrok gave you two domain names:

12345.ngrok.io - localhost: 3000 (helloworld.js) (the server we are monitoring)
67890.ngrok.io - localhost: 1919 (index.js) (the server which catches webhooks)

Go to Better Uptime > Monitors > Create Monitor

Enter "12345.ngrok.io" into the field "URL to monitor". Now, uncheck all boxes under On-call escalation (Call, send sms, send e-mail, push notification). Finally, hit Create monitor.

Go back to the monitors page and you should see your monitor turn green.

Now, go to Integrations > Exporting Data > Configure Webhooks > Add

Give your webhook a name and list this Webhook URL: http://67890.ngrok.io/hook

You can hit send test webhook and watch the Terminal in your Dasha app. It should show something like this:

10. Test the entire app

Now, to launch a full on call, the only thing you need to do is kill your helloworld server. Ctrl+с in the VSCode terminal running the helloworld.js app and you will get an inbound webhook. Watch the terminal for index.js and you will see a Dasha call initiated. The call will arrive on your phone ASAP, so make sure it is not in do not disturb mode.

Congratulations! You have just built a conversational AI app for site reliability engineering automation.

If you need it, here is the link to the source code again.

Let us know in the Dasha community how you did with this app.

How to connect jambonz with Dasha AI

Dasha — Tue, 05 Oct 2021 16:22:27 +0000

Originally posted on https://dasha.ai/en-us/blog/how-connect-jambonz-dasha-AI

Note from the editor: this is a repost of David Horton's article. jambonz is an open source CPaaS for communications service providers.

Dasha is a conversational-AI-as-a-service platform that lets you embed realistic voice and text conversational capabilities into your apps or products. Dasha is a relatively new entry in the conversational AI space, albeit one with that is getting some nice press and brings some interesting capabilities, including such things as handling conversational digressions more easily and a nice VSCode plugin for creating applications using their declarative language.

When building contact center solutions using jambonz, integrating with Dasha is a breeze!

Dasha side

Make sure you have node.js version 13+ and npm installed. You will also want the latest version of Visual Studio Code running to edit and test the Dasha app.

Join Dasha Community - you will get your API key here automatically
Open VSCode and install the Dasha Studio Extension from the extension store. You’ll get all the DSL syntax highlighting and a GUI interface for debugging your conversation flow.
Run npm i -g "@dasha.ai/cli@latest" to install the latest Dasha CLI.

Run a dasha app

You’ll want to load up a Dasha conversational AI app. For the purposes of this tutorial, we will load up the simple inbound tester app that they provide.

$ git clone https://github.com/dasha-samples/dasha-sip-test \
&& cd dasha-sip-test \
&& npm install

Cloning into 'dasha-sip-test'...
remote: Enumerating objects: 66, done.
remote: Counting objects: 100% (66/66), done.
remote: Compressing objects: 100% (51/51), done.
remote: Total 66 (delta 27), reused 41 (delta 14), pack-reused 0
Unpacking objects: 100% (66/66), done.

added 204 packages, and audited 205 packages in 2s

Dasha integrates with voice systems over SIP. That makes it super simple to integrate with jambonz.

So the next thing we shall do is create a SIP endpoint on the hosted Dasha platform that we can send our calls to. We will create a unique SIP URL that routes to their platform and which on the Dasha side is linked to our application.

$ dasha sip create-inbound --application-name sip-test-app sip-test-app
{
  "applicationName": "sip-test-app",
  "priority": 0,
  "groupName": "Default",
  "uri": "sip:5de44e6b-c0df-4532-b952-e4e4c5a5a9ec@sip.us.dasha.ai"
}

Whoa, slow down! What just happened there?

We used the dasha cli to create a SIP URI on the Dasha platform that we can send to. We specified an application name and a config name -- in this case, using sip-test-app for both.

We can also use the dasha cli to list the sip-inbound endpoint we have created:

$ dasha sip list-inbound
{
  "sip-test-app": {
    "applicationName": "sip-test-app",
    "priority": 0,
    "groupName": "Default",
    "uri": "sip:5de44e6b-c0df-4532-b952-e4e4c5a5a9ec@sip.us.dasha.ai"
  }
}

We can see the data returned is an object keyed by the config name where the values are objects containing information about an individual SIP URI.

Note that in order for everything to link up properly on the Dasha side, the application-name you use in the dasha sip create-inbound command must match the value in the name field of your dashaappfile (which is found in app/app.dashaapp). If you want to change the name of the application, change it in the dashaappfile and create a new sip inbound URI using that same name, then restart your app.

Now all we need to do is start our Dasha app:

$ npm start in

..skipping startup log messages here..

Waiting for calls via SIP
sip:5de44e6b-c0df-4532-b952-e4e4c5a5a9ec@sip.us.dasha.ai

Note that it again tells us the SIP URI Dasha has exposed for our application.

jambonz side

On the jambonz side, all we need to do is to dial an outbound call leg to that SIP URI provided. Let's whip up a jambonz app to do just that:

$ npx create-jambonz-app --scenario dial dasha-connect

Creating a new jambonz app in /Users/dhorton/dasha/dasha-connect

Installing packages...

Note: you can see the finished app here on github.

This gives us a basic demo jambonz application that by default dials a talking time clock. Let's change it to dial the Dasha SIP URI instead.

First, let's rename the webhook file:

$ cd dasha-connect
$ mv lib/routes/endpoints/dial-time.js lib/routes/endpoints/dial-dasha.js

Next, replace the contents of lib/routes/endpoints/dial-dasha.js with this:

const router = require('express').Router();
const WebhookResponse = require('@jambonz/node-client').WebhookResponse;

router.post('/', (req, res) => {
  const {logger} = req.app.locals;
  logger.debug({payload: req.body}, 'POST /dial-dasha');
  try {
    const app = new WebhookResponse();
    app.dial({
      answerOnBridge: true,
      target: [
        {
          type: 'sip',
          sipUri: 'sip:5de44e6b-c0df-4532-b952-e4e4c5a5a9ec@sip.us.dasha.ai'
        }
      ]
    });
    res.status(200).json(app);
  } catch (err) {
    logger.error({err}, 'Error');
    res.sendStatus(503);
  }
});

module.exports = router;

Note: replace the sipUri above with your own SIP URI that you generated in the previous step.

You can see that all we are doing is using the jambonz dial target type to dial out to a SIP URI.

Finally, edit the lib/routes/endpoints/index.js to reference dial-dasha instead of dial-time

const router = require('express').Router();

router.use('/call-status', require('./call-status'));
router.use('/dial-dasha', require('./dial-dasha'));

module.exports = router;

As with any jambonz Node.js app, we need to provide environment variables to reference our account sid and other details, so edit the ecosystem.config.js file accordingly, then start it

$ pm2 start ecosystem.config.js

Now that it's running, all we need to do is create an application in our jambonz portal for this webhook:

and then point a phone number to it:

That's it! Time to test by calling the number we assigned. This dasha sample app is quite simple so you will simply hear a woman's voice saying hello and then waiting for your response after which she will close out the conversation.

Of course, this simple Dasha app is only meant to provide an easy way to verify SIP connectivity, and you can now proceed to build out more sophisticated conversational AI apps using Dasha and connect them to your jambonz voice applications.

Conversational AI can handle order confirmation for you… and more.

Dasha — Thu, 09 Sep 2021 15:21:45 +0000

Originally posted on dasha.ai/en-us/blog/order-confirmation-ai

A new wave of conversational AI helps automate order confirmation — and potentially save your company money and time. All while skyrocketing your customer experience.

The conversational AI market is booming. If you’ve been following developments, you’ll know that it goes by a lot of different names — chatbots, voicebots, personal assistants, etc. But at the end of the day, everyone agrees to use conversational AI as a cheaper and more accessible way to interact with users. One of the ways companies use conversational AI is to automate their order confirmation process.

Grubhub, for instance, gets over 620,000 orders per day, and that’s just one food ordering app. UPS delivered 21.1 million packages on average in 2020. With such huge numbers of deliveries per day, it's essential for companies to make sure they can accurately and efficiently confirm the order and the delivery details.

Why traditional order confirmation ways aren't efficient
While some companies have implemented traditional order confirmation via text message or email, there are many drawbacks. The ability to confirm the order in real-time changes the entire customer experience. It saves time and money for the customer and improves their experience with the company. An order confirmation text is not the best method for companies that deliver perishable goods like flowers or food.

What if the flowers arrive but the customer didn’t get the text? What if the food delivery was made to the wrong address? What if the right information wasn't provided correctly? Conversational AI tackles these issues by allowing you to easily and efficiently confirm orders in real-time. This article will explain how conversational AI can be used for order confirmation, and how you can automate it for your company.

The order confirmation option is available in most apps right now. The customer and the delivery company both get a notification, and both parties can see the confirmation. However, some apps give the delivery company access to the order details, and not the customer. This can be problematic for the customer. The customer might not even realize their order was placed, and it would be very difficult to cancel and get a refund. Besides, it's not uncommon for the customer to have ordered something they didn't mean to order, be it an extra pizza, or jeans in the wrong size. The best way to avoid such errors is by calling the person who placed an order right after it has been placed. And you can do just that with an automated conversational AI order confirmation app.

Why conversational AI is the best way to confirm orders
In the U.S, online spending amounted to around $900 billion in 2020. With such a huge amount of spending, companies have to keep their order confirmation process as efficient as possible, and that’s what conversational AI does. If a company chooses to automate its order confirmation process, it doesn’t mean that it has to spend lots of time creating a conversational AI app. In fact, it only takes a couple of hours to write an order confirmation app with Dasha AI. Once done, your company will no longer need to bother with hiring personnel to handle order confirmation calls, conversational AI will do it in their stead.

Besides, one of the greatest benefits of conversational AI apps is that you can not only automate the order confirmation process. The app can help you create the best customer experience by not only automatically confirming orders, but also ask customer experience and/or NPS survey questions such as,

“Are you satisfied with your order?",
"How would you rate the delivery process?",
"Did the size of the [item ordered] fit you?",
"Would you recommend [brand name] to your friends?."
The applications of conversational AI apps are virtually limitless. Why waste time and money on a team of customer service people when you can "hire" a conversational AI app to do the work for you?

With the right app, you can automate the process of connecting with customers and building an immediate rapport, since the person will hear a human voice on the other side of the phone. The best part is that, with conversational AI, you don’t need to create a separate app for every category of products. Whether it’s customer service, delivery confirmation, or product search or recommendation, the app can be created once and then used across different use cases.

Benefits of automating processes with conversational AI
There are several benefits to conversational AI automation:

Increase customer satisfaction.
Most companies see conversational AI as an opportunity for you to connect with your customers in a human-like, most natural manner. In turn, they get happier and more engaged. Moreover, you can nudge your customers to respond to questions and/or requests as they come in.

Increase customer retention and loyalty.
Newer, smarter customers have become harder to retain. If you want to win back these customers, you have to offer a better experience. You can use Dasha AI to make calls that are more personal and specific to the customer. For example, you can ask if they would be happy with a discount, or you can send a generous promo code in case they weren't fully satisfied with the previous order.

Gaining new customers with conversational AI.
Baymard Institute states that nearly 70% of carts get abandoned. Whole 7 out of 10 potential customers leave the purchasing process mid-way. Yet conversational AI could be a game-changer. With Dasha, you could create a conversational AI app that would call those potential customers. Dasha will remind them about the unfinished order, thus reducing the abandoned cart rate and increasing the conversion rate.

Also, your company can analyze customer behavior and know that they’d be most likely to purchase a product if they have already got similar ones. Then, you can mark these new customers as potential prospects, create a compelling personalized offer.

Get honest feedback.
The best way to learn if your company is doing well is by asking your customers about their experience. Use a conversational AI app to ask questions about their opinion on their order, or even ask feed company and how you could improve the experience. Take a look at how NPS surveys are automated with a conversational AI app in this post.

Reduce cancellations.
When your customer places an order and gets a confirmation from the merchant, they feel reassured and are more likely to complete the transaction. However, many times, the customer realizes that they made a mistake during the ordering process. It could be because the company changed prices, or a different product was ordered. But as a result of having paid for it, the customer would want to get a refund. With conversational AI, the customer would not only be able to revise their food delivery, clothes, or tech device order, but cancel it right after the purchase was complete, shall they have a change of heart.

How the conversational AI order confirmation process works
With Dasha, the interactions with customers aren't troublesome to automate. Companies can focus more on other things while conversational AI does most of the work dealing with customers.

Before I get into describing the process, I encourage you to take a look at this how-to post on how I created an order delivery conversational AI app in just a couple of hours.

Without further ado, with Dasha, the order confirmation process is done as follows:

Once your company gets an order request, they will be given a call from Dasha and the person on the other line will sound like a human. At this point Dasha will already have all the necessary information needed such as ordered items, customer's name, and delivery address, to proceed with the order confirmation.

Next, Dasha will proceed conversing with the customer regarding their order and say things like: "Hi Jessica, this is Dasha from [company name] calling to confirm your order. I see you've ordered [item 1] and [item 2] to be delivered to [customer's address]. Would you like to change anything about your order?" and go from there.

Dasha conversational AI can also ask the customer about their preferred paying method and shall it be a card, process the payment right there and then.

Once Dasha has confirmed the order, the order can then be passed on to the fulfillment team to prepare the order.

The order is then delivered (or shipped) to your customer's address. Once the shipping/delivery process is initiated, Dasha can call back the customer to confirm that the package or the delivery is on its way.

This, in essence, is how conversational AI saves your company time and money, by taking care of the customer service aspect of the order, thus allowing companies to spend more time improving their other services.

Develop an AI ordering system yourself (it's easy!)
Take a look at how the conversation would go once you create the order confirmation app:

https://youtu.be/J4JuK6ds8PE

Since creating an order confirmation conversational AI app takes only a couple of hours, I encourage you to try developing an app yourself! You don't need a team of developers to write it, using Dasha is intuitive and doesn't require any programming knowledge, so come as you are! In case you run into any difficulties, we're always here to help you in Dasha Developer Community, so join us! :)

Take order confirmation to a new level with conversational AI

Dasha — Tue, 31 Aug 2021 19:22:03 +0000

Today we’ll be taking a look at how to create a conversational AI app that automates order confirmation. While this app will be targeted towards confirming a food delivery order, yet the logic of this app can apply to create virtually any order confirmation app. Let’s get started!

Prep steps to create conversational AI apps with Dasha

In order to get access to the community of like-minded developers, have all your questions answered, and get help with app development the moment you need it, join Dasha Developer Community.

Once done, you’ll need to download the latest versions of:

NodeJS
VSCode
NPM

Open VSCode, go to extensions and download the Dasha Studio extension. You use the studio to create your conversational script, it gives you syntax analysis and highlights the code. There's also a visual graph editor and it has a GUI tool for debugging.

All done with the downloads!

Now you can go ahead and download Dasha Blank Slate app source code and use it as a base to write your code. You can also refer to the source code of this order confirmation conversational AI app* that you can download here.

You would want to install the latest version of Dasha CLI. Do that by opening the Terminal in VSCode and running this command:

npm i -g "@dasha.ai/cli"
npm i

You could also run a live chat at any moment of time with the following command:

npm start chat (text chat)
npm start your_phone_number (voice chat. Instead of “your_phone_number” type the number of your phone)

With these commands, you’ll be able to converse with the AI in text form. This will not only help you test the conversational flow but also gauge whether there are any errors in the code.

Get to know the files you’ll use to create human-like conversational AI apps

There are 3 main files you need to know about and use:

main.dsl -- here you’ll write DashaScript Language code to create the workflow of your conversational AI app.
data.json -- you will set the intents and entities (/NER/Named Entity Recognition) in this file. The neural network will use intents and entities you’ll create to learn.
index.js -- a NodeJS file that launches the Dasha SDK. You’ll be adding any external functions you deem necessary once adapting the code to your company’s needs. External functions are needed to process data in JavaScript or to get or push data from external APIs. For example, you may need to process data, get access to databases or APIs or use it for any other purposes.

Create your order confirmation conversational AI app!

Off to creating your 2-in-1 ai food delivery and order confirmation app!

Start with importing the common library. It provides all the pre-programmed replies to common digressions such as “wait”, “are you a robot?”, etc.

// Import the commonReactions library so that you don't have to worry about coding the pre-programmed replies
import "commonReactions/all.dsl";

Now you want to establish the context. Here you’ll write the variables, both input (the ones available at the start of the conversation) and output (the variables AI will receive, store and use throughout the conversation).

context
{
// Declare the input variable - phone. It's your hotel room phone number and it will be used at the start of the conversation.  
    input phone: string;
// Storage variables. You'll be referring to them across the code. 
    appetizers: string="";
    drinks: string="";
    new_burger: string="";
    street: string="";
    house_num: string="";
}

Once you’ve set the variables, write out the start node named root. In it, under the do command, you’ll let the AI know that it needs to connect to the user’s phone, wait for 1 second, and then say some kind of a welcome message and wait for the reply (wait *;).

Once the user says something, the AI will go to the next node. Under transitions you can either write directions to the specified nodes, or leave it blank in case you want the transitions to be not to any of the nodes, but to one of the digressions. In this case, we have next: goto order_confirmation_start on true; -- this means that the transition will happen despite what the user says.

// A start node that always has to be written out. Here we declare actions to be performed in the node. 
start node root
{
    do
    {
        #connectSafe($phone); // Establishing a safe connection to the user's phone.
        #waitForSpeech(1000); // Waiting for 1 second to say the welcome message or to let the user say something
        #sayText("Hi, this is Dasha, I'm calling to verify some informaton regarding your order with ABC Burgers."); // Welcome message
        wait *; // Wating for the user to reply
    }
    transitions // Here you give directions to which nodes the conversation will go
    {
        next: goto order_confirmation_start on true;
    }
}

As we programmed the AI to go to node order_confirmation_start, let’s write it out:

node order_confirmation_start
{
    do 
    {   
        #sayText("Yeah, hi, so I see that you've ordered a cheeseburger to be delivered to 78 Washington Road. Do you want to change anything about your order?"); 
        wait*;
    }
    transitions
    {
        payment_method: goto payment_method on #messageHasIntent("no");
        edit_new_order: goto edit_new_order on #messageHasIntent("yes");
    }
}

Note that after #sayText we wrote a random order to a random address. However, you should create an external function (you’ll be doing that in index.js file as we’ve discussed above) and connect it to your internal ordering system, that will pull the information on the order and the delivery address of the user.

Considering that the user knows the menu and wants to change the burger they are ordering, let’s write out the corresponding node and digression. The reason we should write out both is that we’ll be referring to this node in another node’s transition, and the digression will be there to get triggered at any point of the conversation should there be a need for it.

digression change_order_burger
{
    conditions {on #messageHasData("burger_kind");}
    do 
    {   
        set $new_burger = #messageGetData("burger_kind")[0]?.value??"";
        #sayText("Perfect. I've added " + $new_burger + " to your order. Would you like anything else?"); 
        wait *;
    }
    transitions
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("order_sth_else");
    }
}

node change_order_burger
{
    do 
    {   
        set $new_burger = #messageGetData("burger_kind")[0]?.value??"";
        #sayText("Perfect. I've added " + $new_burger + " to your order. Would you like anything else?"); 
        wait *;
    }
    transitions
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("order_sth_else");
    }
}

At this point, let’s write the node we mention in the transition (+ a corresponding digression):

digression edit_new_order
{
    conditions {on #messageHasIntent("order_sth_else");}
    do
    {
        #sayText("What can I get for you?"); 
        wait *; 
    }
}

node edit_new_order
{
    do
    {
        #sayText("What can I get for you?"); 
        wait *; 
    }
    transitions
    {

    }
}

This is a simple, yet multifunctional node in a way since we’ll be transferring to it in multiple nodes.

Another similar digression and node are the following:

node nvm
{
        do
    {
        #sayText("Is there anything else I can help you with?"); 
        wait *;
    }
    transitions
    {
        payment_method: goto payment_method on #messageHasIntent("no");
        edit_new_order: goto edit_new_order on #messageHasIntent("yes");
    }
}

digression nvm
{
    conditions {on #messageHasIntent("nvm");}
    do
    {
        #sayText("Okay! How may I help you?"); 
        wait *; 
    }
}

We’ll also have a chance to refer to them in other nodes.

Let’s write a digression for a case when a person asks about the burger menu after deciding to change the order:

digression burgers_available
{
    conditions {on #messageHasIntent("burgers_available");}
    do 
    {
        #sayText("We've got cheeseburger, hawaiian burger, buffalo chicken burger, creamy mushroom burger, beef burger and barbeque burger. Which one would you like?"); 
        wait*;
    }
    transitions
    {
        change_order_burger: goto change_order_burger on #messageHasData("burger_kind");
    }
}

Pretty simple!

Now, what if the user wants to change the delivery address? Let’s program the conversational AI app to be able to deal with this case scenario.

There could be 4 different paths here. Either the user states they want to change the address without specifying it, or they name the new street, or the new building number, or the full address. We should write down a digression for each of these scenarios as they can pop up at any moment during the conversation:

digression different_address
{
    conditions {on #messageHasIntent("different_address");}
    do
    {
        #sayText("Sounds good, could you tell me the building number and the street name, please?"); 
        wait *; 
    }
}

digression change_street
{
    conditions {on #messageHasIntent("change_street");}
    do 
    {
        set $street = #messageGetData("street")[0]?.value??"";
        #sayText("Okay, I changed the street to " + $street + " . Is there anything else you'd like to change?"); 
        wait *;
    }
    transitions
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("order_sth_else");
        review_full_order: goto review_full_order on #messageHasIntent("no");
    }
}

digression change_house_num
{
    conditions {on #messageHasIntent("change_house_num");}
    do 
    {
        set $house_num = #messageGetData("house_num")[0]?.value??"";
        #sayText("Gotcha, I changed the building number to " + $house_num + " . Is there anything else you'd like to change?"); 
        wait *;
    }
    transitions
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("order_sth_else");
        review_full_order: goto review_full_order on #messageHasIntent("no");
    }
}

digression change_address
{
    conditions {on #messageHasData("house_num") and #messageHasData("street");}
    do 
    {
        set $street = #messageGetData("street")[0]?.value??"";
        set $house_num = #messageGetData("house_num")[0]?.value??"";
        #sayText("Okay, changed the delivery address to " + $house_num + " " + $street + ". Is there anything else you'd like to change?"); 
        wait *;
    }
    transitions
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("order_sth_else");
        review_full_order: goto review_full_order on #messageHasIntent("no");
    }
}

Take a look at the digression change_street the line under the do command: set $street = #messageGetData("street")[0]?.value??"";. You might recognize $street from the content that we’ve established right off the bat. This line lets the AI store the variable $street and use it throughout the chat.

Note that we can store multiple variables under the do section as seen under change_address.

We’ll use the stored variables right in the digressions to provide feedback to the user, letting them know we’ve understood them correctly and make some changes if we didn’t.

Now, let’s consider the case when the user decides to edit their order by ordering something extra that’s on our menu. Appetizers, for instance. Remember that the user might know the menu and say exactly what they want to order, or they might ask what you have on the menu appetizers-wise:

digression appetizers
{
    conditions {on #messageHasIntent("appetizers");}
    do 
    {
        #sayText("We've got fried calamari, french fries, spring salad, and a soup of the day. What of these would you like to order?");
        wait *;
    }
    transitions 
    {
       confirm_appetizers: goto confirm_appetizers on #messageHasData("appetizers");
    }
     onexit
    {
        confirm_appetizers: do {
        set $appetizers =  #messageGetData("appetizers", { value: true });
       }
    }
}
node confirm_appetizers
{
    do
    {
        var sentence = "Perfect. I've added ";
        set $appetizers = #messageGetData("appetizers");
        for (var item in $appetizers) {
            set sentence = sentence + (item.value ?? " and ");
        }
        set sentence = sentence + " to your order. Is there anything else you'd like?";
        #sayText(sentence); 
        wait *;
    }
     transitions 
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("drinks");
        confirm_drinks: goto confirm_drinks on #messageHasData("drinks");
        review_full_order: goto review_full_order on #messageHasIntent("no");
    }
}

The same thing goes for the drinks menu:

digression drinks
{   
    conditions {on #messageHasIntent("drinks");}
    do 
    {
        #sayText("We have orange juice, Sprite, and vanilla milkshakes. What would you like to get?");
        wait *;
    }
    transitions 
    {
       confirm_drinks: goto confirm_drinks on #messageHasData("drinks");
    }
    onexit
    {
        confirm_drinks: do {
        set $drinks = #messageGetData("drinks", { value: true });
       }
    }
}

node confirm_drinks
{
    do
    {
        var sentence = "Noted, I added ";
        set $drinks = #messageGetData("drinks");
        for (var item in $drinks) {
            set sentence = sentence + (item.value ?? " and "); // In case the guest desides to order multiple items of food
        }
        set sentence = sentence + " to your order. Anything else you'd like to order?";
        #sayText(sentence); 
        wait *;
    }
     transitions 
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes") or #messageHasIntent("appetizers");
        confirm_appetizers: goto confirm_appetizers on #messageHasData("appetizers");
        review_full_order: goto review_full_order on #messageHasIntent("no");
    }
}

Now that we’re done changing the order, we should provide the user with the final confirmation:

node review_full_order
{
    do
    {
        var sentence = "To review your order, you want to get ";
        for (var item in $new_burger) {
            set sentence = sentence + (item.value ?? "") + (", ");
        }
        for (var item in $appetizers) {
            set sentence = sentence + (item.value ?? "") + (", and ");
        }
        for (var item in $drinks) {
            set sentence = sentence + (item.value ?? "");
        }
        set sentence = sentence + ". Would you like anything else?"; 
        #sayText(sentence); 
        wait *;
    }
     transitions 
    {
        payment_method: goto payment_method on #messageHasIntent("no");
        edit_new_order: goto edit_new_order on #messageHasIntent("yes");
    }
}

Here we write out the for statements to account for multiple food/drink items (for example, if the user says they want both calamari and fries). The + (", "); and + (", and "); so that the multiple variables are separated when the text is spoken (fries, Hawaiian burger, and Sprite vs friedHawaiian burgerSprite).

Now, a couple of simple nodes will let the AI know it needs to ask about the payment method:

node payment_method
{
    do
    {
        #sayText("Gotcha. Now, would you be paying with cash or by card?");
        wait *;
    }
     transitions 
    {
        with_cash: goto with_cash on #messageHasIntent("cash");
        by_card: goto by_card on #messageHasIntent("card");
    }
}

node with_cash
{
    do
    {
        #sayText("Sounds good, with cash it is. Your order will be ready in 15 minutes. Thank you for your order! Bye bye!");
        exit;
    }
}

node by_card
{
    do
    {
        #sayText("Sounds good, by card it is. Your order will be ready in 15 minutes. Thank you for your order! Bye bye!");
        exit;
    }
}

It goes without saying that we need to account for the case scenario when the user wants to cancel the order altogether:

digression cancel_order
{   
    conditions {on #messageHasIntent("cancel_order");}
    do 
    {
        #sayText("Okay, just cancelled your order. Is there anything else I can help you with?");
        wait *;
    }
    transitions 
    {
        edit_new_order: goto edit_new_order on #messageHasIntent("yes");
        bye: goto bye on #messageHasIntent("no");
    }
}

And the final touch is our bye node and digression. We don’t ever want the user to not have an option to end the conversation:

digression bye 
{
    conditions { on #messageHasIntent("bye"); }
    do 
    {
        #sayText("Thanks for your time. Have a great day. Bye!");
        #disconnect();
        exit;
    }
}

node bye 
{
    do 
    {
        #sayText("Thanks for your time. Have a great day. Bye!");
        #disconnect();
        exit;
    }
}

Create your own conversational AI app! It’s easy :)

Try creating an order confirmation app that fits your business’ needs. Think of the questions your users could ask, plot them and write out corresponding nodes and digressions. Or improve the app and share the results in Dasha Developer Community :)

How to get started with customer service automation at your bank. A quick start guide for a simple money transfer AI app.

Dasha — Fri, 27 Aug 2021 18:20:58 +0000

So you’re considering using customer support automation at your bank but are unsure where to begin. The good news is you’re at the right place.

In this guide we’ll talk about why it is a smart decision to use artificial intelligence in banking, how to use customer service and support automation, and will provide you with a step-by-step guide on creating your own automated money transfer app.

What exactly are the benefits of automation for banking industry?

Automation is a catalyst for growth for companies. It’s tough to imagine a company that’s not deploying at least some sort of automated procedures. Without automation you are bound to have persistent human errors, overheads and reduced operational efficiency.

According to a Pega robotic automation case study, automating customer experience reduced error rates down to 2% (from an approximate of 30% rate), reduced processing time
by a whole 78% and accounts processed number increased twofold.

Customer service and support automation helps:

avoid repetitive tasks,
employees to focus on focal projects and task,
reduce operational costs,
scale the business,
reduce AHT,
be available to customers on a 24/7 basis, etc.

Why you should use customer support automation in banking

Let’s start with something that affected nearly all consumer banking customers.

During 2020, the number of times when the customers were put on hold for hours while trying to reach their bank are immense. Some of the clients had to spend three, five, and some even ten hours on hold, which greatly diminished their satisfaction with the banking experience. By letting artificial intelligence take care of incoming calls, banks that employed such tech managed not only to increase CX and to improve customer loyalty and satisfaction, but also avoided unnecessary work, which would’ve been their CS team spending time resolving complaints. This is just one example of how invaluable customer support automation is for the banking industry.

There is no question whether utilizing artificial intelligence in banking is a must in 2021. According to EY press release, 68% of financial institutions executives are planning to “use AI for new revenue generation, process automation, risk management, customer service and client acquisitions within two years”. And there’s no wonder why: “AI can potentially unlock $1 trillion of incremental value for banks, annually”, as per McKinsey.

The banking industry can rest assured that using automation will get their customers’ requests answered promptly and accurately. While AI can handle most customer questions, some require complex problem solving, human interaction and creativity, in which case calls get transferred securely to a human operator.

One of the most compelling reasons for utilizing artificial intelligence in banking is self-explanatory: cost saving. According to Business Insider, front- and middle-office AI uses provide banks with a cost saving opportunity of $416 billion. Think about that.

Now, let’s consider some AI implementation use cases for banks. You will see that AI in banking customer service is indispensable.

Conversational AI is a hype nowadays and it’s justified. There are myriad ways artificial intelligence can be used in banking. Banks use it to automate the way customer can:

submit a loan application,
report a stolen or lost card,
check balance of their accounts,
schedule an appointment with a bank representative,
transfer money, etc.

All of these use cases can be easily and seamlessly be solved with Dasha Studio. Without further ado, let’s take a look at how anyone with little to no coding skills can create the last point mentioned in the list, money transfer.

How to automatically conduct a money transfer with a simple conversational AI app

Let’s take a look at a Dasha conversational AI demo for the money transfer use case.

First things first, you’ll need to install Visual Studio, Node.js, join Dasha’s developer community (that’d allow you to get any help you need), and finally download a money transfer code demo. If that sounds confusing to you, don’t fret. We have a step-by-step guide that will allow you to do everything in a matter of minutes (you can go straight to the “Installing Dasha Studio and loading a pre-built AI virtual receptionist app” part).

Now to the fun part! Let’s take a look at the code.

In order to see the full picture of what’s happening in the code without actually distracting yourself with the code lines themselves, check out the Graph Editor. It will show you the pathways conversation might take place. The Graph Editor essentially shows you all the high-level nodes. (P.S. a node describes the system's actions in the current state and the conditions for transitioning to other nodes. For more information on DashaScript language structure (dsl), check out the Documentation link).

Note: if you can’t see the pathways, just zoom out. It should look like this:

At this point, zoom in a bit. What you are seeing are digressions. Nodes that have no other nodes leading into them. A user can call a digression up at any point in the conversation. This functionality emulates the way in which humans communicate with each other. For more info on digressions, take a look at this post.

Now, let’s get to the most important part - the code. Open file main.dsl

With line 1 we import common libraries. In line 7 we declare alias for a type and in lines 12-22 we declare variables for context. The variables will be used later to store data received from the user in the course of the conversation.

The lines 34-43 describe what happens at the start of the chat between AI and the customer.

start node root
{
    do
    {
        #connectSafe($phone);

tells us that Dasha safely connected to a customer’s phone. moving on to the

#waitForSpeech(1000);

means that Dasha will wait for 1000ms (1 second) and move on to

#say("greeting");

which means Dasha will greet the customer and after that it’ll wait for them to respond:

wait *;
    }

The lines 43-47 describe the transition the app makes once an event is triggered. In this case we see #messageHasIntent("transfer_money");, which refers to the intent transfer_money, which is when the customer specifies their intention to transfer money from one account to another.

It’s now the best time to take a look at the intents themselves. But what are intents? Intents are reusable within the application. It means that you can use it in different steps of the conversational script. You don't need to define individual ones for different transitions, except for those cases when it's necessary for your script. Intent classification is aimed to categorize phrases by their meanings (intention). (Note: for more information on intents you can check out this blog post which focuses on them).

Go to data.json to view all the specified intents As you can see, there are 2 main parts to each intent: includes and excludes. Includes part shows all the specified phrases a customer can say to trigger transition. In this case, a customer talks about their intention to have their money transfered. The excludes part describes the phrases that need to be prevented from being included in the intent so that the app doesn’t trigger the unexpected response.

Moving on to lines 48-64. The onexit node section is defined right after transitions section and allows to specify actions to perform before exiting the node. The app goes on to perform the lines 66-115, starting with the preprocessor digression transfer_data.

preprocessor digression transfer_data
{
    conditions
    {
        on true;
    }

    var amount: string = "";
    var source_account: string="";
    var target_account: string="";
    var account: string ="";

Here all the entities that the customer could have mentioned in the phrase are mentioned. If they said “$50”, the app remembers it in the amount (var amount: string = "";), if the person said something about their account (savings or deposit) or the bank they want to transfer the money to (Wells Fargo, Bank of America, etc - which are already on file in users_db.json), the app remembers that information, as the lines below show:

var source_account: string="";
    var target_account: string="";

Same logic applies to var account: string ="";.

Tags source and target are an extra marker of entities, which help differentiate entities’ meaning. Source refers to which account the money will be transferred from and target refers to where the money will be transferred to.

Lines 105-108 refer to the instance when the bank or account was identified without any tag assigned. For example, if a customer says “transfer $50, savings account”, we don’t yet know whether we should take $50 from the savings account or transfer that amount to the savings account.

One more important thing to note is that you shouldn’t worry about the customer asking tangential phrases such as “are you a robot?”, “call me back later”, or “wait a moment”:

As you can see, common reactions not only have the “wait” part, but iAmRobot, for instance, which describes the situation when a customer can digress to asking whether the person on the other side of the phone is a robot. You don’t need to worry about digressions such as a customer asking to repeat a question or a statement AI says, as it’s already accounted for.

Note that the app follows a slot filling system. From lines 186-192 you see that AI will try to get all the information necessary (what bank to transfer money to, from what account to take the funds from, and what amount to transfer) from the customer. It will go in a loop __ loop: goto transfer_money;__ until it has all the information.

  transitions
    {
        provide_data: goto transfer_money on #messageHasIntent("transfer_money") or #messageHasData("bank") or #messageHasData("account") or #messageHasData("numberword");
        loop: goto transfer_money;
        confirm: goto transfer_confirmation;
    }
}

Also note that in this particular demo case the app accounts for 2 different users, yet it can account for all the customers that exist in your bank’s database. We can see that from the screenshot below. For this app, we set those two users to have different banks to transfer money to, set one to have both savings and deposit accounts, and the other to have only a deposit account. Additionally, the app accounts for the customer's balance in order to cancel the transaction in case the customer doesn’t have sufficient funds.

At this point we got all the information we need from a customer, which are the account they want to transfer money from, the bank account they want to transfer money to, and the amount. The lines 224-258 describe the steps to make AI ask for confirmation. It will repeat all the information received from the customer and if it’s correct (positive: goto process_transfer on #messageHasIntent("agreement", "positive");
__), the app proceeds to transfer the money. If it got something wrong (negative: goto transfer_money on #messageHasIntent("agreement", "negative");
__), it will ask again for the needed information.

node transfer_confirmation
{
    do
    {

        #say("ask_transfer_confirmation",
        {
            amount: $amount,
            source_name: $source_account?.name,
            source_num: $source_account?.num,
            target_name: $target_account?.name,
            target_num: $target_account?.num
        }
        );
        wait *;
    }
    transitions
    {
        positive: goto process_transfer on #messageHasIntent("agreement", "positive");
        negative: goto transfer_money on #messageHasIntent("agreement", "negative");
    }
    onexit 
    {
        negative: do {
            set $amount = "";
            set $source_account = null;
            set $target_account = null;
            set digression.transfer_data.amount = "";
            set digression.transfer_data.source_account = "";
            set digression.transfer_data.target_account = "";
            set digression.transfer_data.account = "";
        }
    }
}

Let’s go back to lines 194-222 for a moment.

This part describes a situation where a customer decides to change the amount they want to be transferred. The block is a graph analog of subroutines that provides a mechanism for code reuse.

The if part describes a situation where a customer says they want to change the transfer amount and say the exact amount they want to change it to. In which case we notify that the amount has been changed and say the new amount.

if(#messageHasData("numberword", { value: true })){
           var amount = #messageGetData("numberword", { value: true })[0]?.value??"";
           #sayText("Awesome, I've just changed the transfer amount to " + amount, repeatMode: "ignore");
           return amount;

The else part describes a situation where a customer only says they want to change the transfer amount. Here we ask the customer to tell us the amount they want to change to.

  else {
            #sayText("What's the amount you want to be transfered?", repeatMode: "ignore");
            wait *;

Note that digression can happen at any moment of the conversation. For example, a customer could decide to change the amount to be transferred after choosing where to transfer the money to. You can see which phrases will trigger “differentamt” intent in the data.json tab on the left.

The final step, as mentioned above, is the app concluding the transaction and sending the funds to where the customer specified, lines 247-267 depict that.

node process_transfer
{
    do
    {
        #say("wait_for_processing");
        set $result = external transfer_money($amount, $source_account, $target_account);
        if($result)
        {
            #say("transfer_success");
        }
        else
        {
            #say("transfer_failed");
        }
        #disconnect();
        exit;
    }
    transitions
    {
    }
}

And done! Great job, you now have your own automated money transfer conversational AI app!

Conclusion

Whether your main goal is to reduce errors of your call center team, scale your business or become more effective in daily operations, automating with Dasha conversational AI is the right next step for your bank.

Now that you know how to build a money transfer app, you can go on to building more elaborate apps that target your main goals. And don’t worry if you encounter complications or have questions - Dasha AI developer team is always ready to help you out.

Take your candidate screening to the next level with this conversational AI app

Dasha — Tue, 17 Aug 2021 15:52:21 +0000

Originally published on https://dasha.ai/en-us/blog/ai-candidate-screening-app

This post will focus on creating a conversational AI app that automates HR candidate screening. Automating candidate screening allows companies to hire better candidates, reduce the backlog of interviewees, save time and money.

Getting started with Dasha conversational AI

As the first step, join Dasha Developer Community. It will give you access to all the help you may need be it answering your questions or supporting you with conversational AI app creation.

This is also where you’ll get your API key to use Dasha.

Now, you need to download the latest versions of VSCode and Node.js. Once done, launch VSCode and download the Dasha Studio extension, it enables syntax highlight for DSL and has GUI tool for debugging.

At this point, open the Terminal in VSCode and type the following commands:

npm i -g "@dasha.ai/cli" - this will install Dasha CLI (command line interface)
npm i

I recorded a demo that showcases how the conversation goes once you launch the conversational AI app. You can take a look at it below or test it yourself by typing npm start 1987654321 (your phone number with the country code) into the Terminal.

Note that you can always test your conversational AI app by typing npm start chat and converse with the AI in a text form. This will not only help you test the conversational flow but also gauge whether there are any errors in the code.

https://youtu.be/2Glp_HC-VHc

Now that you’ve checked out the conversation, it’s time to get to know the files you’ll be using to create your candidate screening conversational AI app.
We recommend downloading Dasha Blank Slate app source code and use it as a base to write your code. For that, you’ll have to open main.dsl and data.json files and delete everything you see there. This way you’ll be able to start writing your code from scratch while having all the other essential files (for instance, the commonReactions library that has pre-programmed replies so you don’t have to worry about coding those).

You can also download the source code of this particular candidate screening app here.

As mentioned above, you’ll be primarily using 2 files to create your conversational AI app:

main.dsl -- this is where you’ll write your DashaScript Language code to create the workflow of your conversational AI app. With Dasha Studio extension on and with the directions in this post, it’ll be an easy job for you.

data.json -- you will set the intents and entities (AKA NER, AKA Named Entity Recognition) in this file. The neural network will use intents and entities you’ll create to learn.

Additionally, you will want to use the index.js file to write out external functions. External functions are needed to process data with the SDK. For example, you may need to process data, get access to databases or APIs or use it for any other purposes.

index.js -- it’s a NodeJS file that launches the Dasha SDK. Here you’ll be adding any external functions you deem necessary once adapting the code to your company’s needs. One of your candidate screening app’s external functions would be the applicant’s phone number.

Now that you’re familiar with the files you’ll be using you can get coding!

AI in HR: creating your own candidate screening app

Note that while this code is just an example, you can use it as a base, improve it, rewrite the lines, etc. In other words, adapt it to your company’s and job posting’s requirements.

First, open the main.dsl file and start off by importing the common library:

// Import the commonReactions library so that you don't have to worry about coding the pre-programmed replies
import "commonReactions/all.dsl";

This common library has a variety of digressions that become handy when it comes to the candidate going off on a tangent. For instance, it’s not uncommon for a person to ask to give him a moment, either to take some time to think or to attend to something that’s happening. Such digressions are essential and make the app more human-like.

library

digression @wait
{
    conditions { on #messageHasAnyIntent(digression.@wait.triggers)  priority 900; }
    var triggers = ["wait", "wait_for_another_person"];
    var responses: Phrases[] = ["i_will_wait"];
    do
    {
        for (var item in digression.@wait.responses)
        {
            #say(item, repeatMode: "ignore");
        }
        #waitingMode(duration: 60000);
        return;
    }
    transitions
    {
    }
}

At this point I’d like to point your attention to the var responses: Phrases[] = ["i_will_wait"];. Once a person asks the AI to wait, it’ll respond with one of the phrases that are stored in the phrasemap.json file. This file is useful when it comes to having diversity in AI’s responses. Here’s an example:

      "i_will_wait": {
        "random": [
          [{ "text": "Okay, I'll wait" }],
          [{ "text": "Sure, I'll wait" }],
          [{ "text": "Okay, no problem!" }]
        ]
      },

The phrases that come after #sayText(“ are static. If you need variety in responses, go ahead and use the phrasemap.json file. Here’s more on how to use this file.

At this point you’d want to move forward and declare the input and output variables in the context:

context
{
// Declare the input variable - phone. It's your candidate's phone number and it will be used at the start of the conversation.  
    input phone: string;
    output new_time: string="";
    output new_day: string="";
}

Throughout the conversation (depending on which course the conversation takes) we’ll be getting information about the time and day from the candidate, which is why we put these as an output.

For the purposes of this demo, I’ve decided the open position to be for a sales representative at an imaginary JJC Group.

To start writing your candidate screening conversational AI app for this position, you’ll need to write a start node named root. In it, we’ll program the conversational AI app to connect to the candidate’s phone number, make the AI wait for 1 second before saying the welcome message, and write out the welcome message itself.

In this node, we want to ask the candidate if they have some time to talk to us and move forward based on their availability.

start node root
{
    do
    {
        #connectSafe($phone); // Establishing a safe connection to the candidate's phone
        #waitForSpeech(1000); // Waiting for 1 second to say the welcome message or to let the candidate say something
        #sayText("Hi, my name is Dasha, I'm calling in regard to your application for the sales representative position at JJC Group. I'd like to ask you some questions. Is it a good time to talk?"); // Welcome message
        wait *; // Wating for the hotel guest to reply
    }
    transitions // Here you give directions to which nodes the conversation will go
    {
        will_call_back: goto will_call_back on #messageHasIntent("no");
        education: goto education on #messageHasIntent("yes");
    }
}

After we get a reply from the candidate, the conversation will either transition to the will_call_back or the education node. Let’s take a look at each:

node will_call_back
{
    do
    {
        #sayText("No worries, when may we call you back?");
        wait *;
    }
    transitions
    {
        call_bye: goto call_bye on #messageHasData("time");
    }
}

node call_bye
{
    do
    {
        set $new_time =  #messageGetData("time")[0]?.value??""; // remembers and stores the time to call the candidate back
        #sayText("Got it, I'll call you back on " + $new_time + ". Looking forward to speaking to you soon. Have a nice day!"); 
        exit;
    }
}

In these two nodes, we get information about the time the candidate is available for the call. We store it and will use it to make a call back at the specified time.

Given the candidate has some time to talk, we go on to ask our first question. In this case, we need to know if the candidate has an education level higher than high school.

node education
{
    do 
    {
        #sayText("Alright, so, let's begin. Could you first tell me what is the highest level of education you have obtained to date?"); //call on phrase "question_1" from the phrasemap
        wait *;
    }
    transitions 
    {
        disqualified: goto disqualified on #messageHasIntent("high_school"); 
        experience_years: goto experience_years on #messageHasIntent("college"); 
    }
}

We follow the same logic to ask the candidate additional qualification questions. For the purpose of this demo, we have the following pre screening questions to ask candidates:

how many years of experience the candidate has,
if they have over 2 years of experience with cold calling,
how they’d rate their own cold calling skills,
if they are okay with spending hours on the road,
if they mind frequent business trips,
if they’ve consistently achieved their sales goals,
if extra work hours is something they are okay with,
and if the compensation level we provide is acceptable for them.

Since writing these (or any other similar questions) will be an easy task for you, I won’t write the code here. You can always open the repository to see the full code.

In node education, we wrote 2 transitions out. Based on the received intents, the conversation would either go to the next question (experience_years) or trigger candidate disqualification and take the conversation to node disqualified. Let’s take a look at the latter:

node disqualified
{
    do
    {
        #sayText("Thank you so much for letting me know! It saddens me to say that it doesn't match out basic qualification requirements. That being said, we will keep your CV on file and contact you once a matching position appears. Thank you for your time and have a wonderful day! Bye!");
        exit;
    }
}

Note that the candidate can be disqualified at any moment of the pre-screening interview if one of the minimum qualifications isn’t met.

In the best-case scenario, we get a candidate who is a fit for the position and meets all the requirements for it. Should that happen, the conversational AI app will arrange an in-person interview:

node interview_day
{
    do
    {
        #sayText("Thank you very much for your replies. At this point I would like to invite you to an in-person interview. What day would work best for you?");
        wait *;
    }
    transitions 
    {
       confirm_day: goto confirm_day on #messageHasData("day_of_week");
    }
    onexit
    {
        confirm_day: do 
        {
        set $new_day = #messageGetData("day_of_week")[0]?.value??""; // remembers and stores the preferred day to schedule the interview
        }
    }
}

node confirm_day
{ 
    do 
    { 
        #sayText($new_day + ", you say?");
        wait *;
    }
        transitions
    {
        interview_time: goto interview_time on #messageHasIntent("yes");
        repeat_day: goto repeat_day on #messageHasIntent("no");
    }
}

node repeat_day
{
    do 
    {
        #sayText("Sorry about that, what day would you be able to come for the interview?");
        wait *;
    }
    transitions 
    {
       confirm_day: goto confirm_day on #messageHasData("day_of_week");
    }
    onexit
    {
        confirm_day: do {
        set $new_day = #messageGetData("day_of_week")[0]?.value??"";
       }
    }
}

Notice that we’ve already seen a similar type of node layout when we programmed the conversational AI app to register the time to call the candidate back. Also, note that it’s always best to give feedback to the human in form of repeating the data we’ve got from them. That helps fix the errors the moment they occur and fix them right off the bat in a human-like manner. You can see that done under node confirm_day { do #sayText($new_day + ", you say?");.

After we scheduled the interview day and time, we end the conversation with node end_interview:

node end_interview 
{
    do
    {
        #sayText("Wonderful! Um... This concludes our call, I will relay your replies to the hiring manager. Looking forward to seeing you at the interview. Have a fantastic rest of the day. Bye!");
        exit;
    }
}

Create a candidate screening app that matches the position you’re hiring for

Your company could be looking for a candidate for a position other than a sales representative. However, this app would serve you as a great starting base.

Start off by getting a list of pre screening questions to ask candidates from the HR department and get the AI to do the work. Such an app would save your company time and money, and let your HR professionals focus on more meaningful tasks.

This app took me less than 2 hours to create, so try writing one yourself and let the Dasha Community know what you’ve created. We can’t wait to celebrate your success with you!

Best restaurant online ordering system? Conversational AI! Or how to make pizza ordering easy with AI

Dasha — Tue, 10 Aug 2021 19:08:20 +0000

According to Morgan Stanley’s research, 47% of restaurant customers prefer to call the restaurant directly to make an order. Phone ordering isn’t declining at the expected rate and phone call automation is one of the biggest reasons why.

Voice ordering for restaurants is on the rise. Food chains are adopting artificial intelligence as means to cut operational costs, free their staff, and boost customer experience rates. Pizza restaurants are no exception.
Domino’s was the first large pizza chain to take advantage of AI and automated telephone order taking for pizza.

In this post, we will take a look at why restaurants use AI to automate delivery and takeout orders. We will also go through a tutorial on creating your own conversational AI pizza ordering app.

Why you should use an automated restaurant ordering system

Automation redefines customer experience, decreases costs, and increases efficiency. Some restaurants use delivery bots, others use restaurant online ordering systems (app, website). Others use a combination for the best CX. Taking orders is a fraction of restaurant operations. Yet when you take into account that without automating this part you would have to hire someone to be by the phone to take orders and incur costs. Making your existing staff take phone orders prevents them from giving undivided attention to the customers. It also distracts them from other essential tasks.

A restaurant might decide to resort to third-party food ordering services. Yet statistics show that the preferred method is having your own automated phone ordering system. Why? The answer is quite simple. The survey conducted by Preoday showed that 68% of food and drink professionals pay commission to their restaurant ordering system supplier. Most customers who want to support a restaurant itself rather than a tech supplier order food directly from the restaurant.

Nowadays, people prefer to order food delivery versus dining in a restaurant. Even more so during the pandemic. Let’s look at some numbers that show how customers think when it comes to ordering food.

70% of customers call the restaurant directly when making an order, rather than use third-party platforms, as per Hospitality Technology, since “consumers want restaurants to take their money, not technology suppliers”,

as per Upserve, once a week 60% of customers order delivery or takeout,

20% of the customers say they spend more money when ordering delivery, as per Restaurant Business Online.

Since dining in is the least preferred option, Domino’s decided to use AI to automate the restaurant ordering system. The pizza chain created a virtual assistant that incorporates voice recognition. It integrates with nearly every platform available, be it Google Home, Amazon Alexa, smartwatches, and even Ford Sync! Domino’s customers can now literally ask their car to order pizza for them just by giving a simple voice command.

Now, if Domino’s can create a voice AI pizza ordering assistant, why can’t you? It’s time to create a simple pizza ordering app with Dasha conversational AI as a Service.

Building a pizza ordering conversational AI app with Dasha AI

Before you start you can check out this video that shows how exactly the conversation will flow once you're done writing the code:

Embedded content: https://youtu.be/fRDlbrMUPyY

Now off to the app making process.

First things first, you should open your “playground”, AKA Visual Studio Code where the magic will happen. Then, go to Github and download Dasha First App (it’ll serve you as a base to create your pizza ordering AI app). If you don’t know what’s going on and are new to this, I recommend this starting guide. When done setting everything up, just get back to this post.

Now you should have your VS Code open with Dasha First App in it.

Go to main.dsl and delete everything you see there, as it needs to be empty for you to write your code. Next, go intents.json and change the name to data.json (that will let you have both [entities and intents). If you get confused at any moment, you can go back to Github and download the pizza ordering app that already has everything we’re about to go through laid out.

Go back to your empty main.dsl and start typing the following:

import "commonReactions/all.dsl";

context 
{
    input phone: string;
    food: {[x:string]:string;}[]?=null;
}

The first line means that you are importing the common libraries and the part that says context provides the variables that the app will store and remember (and use during the chat, if needed).

The next thing to do is to plot the conversation. We will need to have the conversational AI app safely connect to the customer’s phone (#connectSafe($phone);), wait for 1 second (#waitForSpeech(1000);), say the introductory phrase, and wait for the response.

start node root 
{
    do 
    {
        #connectSafe($phone);
        #waitForSpeech(1000);
        #sayText("Hi, this is Yummy Pizza, how may I help you today?");
        wait *;
    }    
    transitions 
    {
        place_order: goto place_order on #messageHasIntent("yes");
        place_order_pizza: goto place_order_pizza on #messageHasIntent("order_pizza");
        no_dice_bye: goto no_dice_bye on #messageHasIntent("no");
    }
}

The conversation can go multiple ways and we have to account for that right off the bat. To the “how may I help you” question a customer can respond something like:

I’d like to make an order (place_order),
I wanna order a pizza (place_order_pizza),
Sorry, wrong number / changed my mind, sorry, bye (no_dice_bye).

That’s what our transitions are for. In order for the transitions to work, we have to use nodes. Let’s take a look at how that works.

node place_order
{
    do 
    {
        #sayText("Got that! What can I get for you today?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food");
    }
    onexit
    {
        confirm_food_order: do {
        set $food = #messageGetData("food");
       }
    }
}

We see quite a lot going on in this node. It will serve us in case a customer responds with “I’d like to make an order, please” or similar - you’ll have to write down the intents in the data.json file. That’s how my intents look like for this specific case:

"place_order": 
    {
      "includes": [
        "I want to place an order",
        "I want to pick up some food",
        "Can I get some food?",
        "order",
        "food",
        "I want to place an order for pick up",
        "I'd like to pick up some food",
        "can I pick up some food", 
        "I'd like to make an order",
        "I'd like to order something"
      ],
      "excludes": [
        "pizza",
        "I'd like to get a pizza",
        "I'd like to order a pizza",
        "I want to order a pizza",
        "I want pizza",
        "I'd like a pizza",
        "pizza",
        "I'd like to order a pizza",
        "I would like to order a pizza",
        "I want a pizza",
        "I want to order a pizza",
        "yes, I want a pizza",
        "yes, I'd like to order a pizza",
        "I'd like a pizza",
        "yes, I'd like to order a pizza",
        "I'd like to have a pizza",
        "I want to buy a pizza",
        "I wanna get a pizza",
        "I'd like to get a pizza"
      ]
      },

It has includes and excludes parts since I want this specific intent only to be triggered once a customer specifies only that they want to make an order without saying that want pizza (since I’m going to be using a different node for that, we’ll get to that in a bit).

Now that the conversational AI app recognized the intent, it will ask the customer what they’d like to order:

do 
    {
        #sayText("Got that! What can I get for you today?");
        wait *;

Here we assume that the customer will say they want pizza since it’s a pizza place they’re calling. You could add other transitions if you’d like. For instance, you could program your conversational AI app to be able to answer questions that might follow this node like “what do you guys have?” or “could you walk me through the menu?”.

If a customer has a specific pizza in mind, such as a Pepperoni, and answers something along the lines of “I’d like to get a Pepperoni”, the app would remember this piece of information, store it, and transition to the node confirm_food_order:

node confirm_food_order
{
    do
    {
        #sayText("Perfect. Let me just make sure I got that right. You want ");
        var food = #messageGetData("food");
        for (var item in food)
            {
                #sayText(item.value ?? "and");
            }
        #sayText(" is that right?");
        wait *;
    }
     transitions 
    {
        order_confirmed: goto payment on #messageHasIntent("yes");
        repeat_order: goto repeat_order on #messageHasIntent("no");
    }
}

The var part stands for the variable (remember we put it in the context?). You want to make your conversational AI remember that the customer wanted Pepperoni. In this part, we ask for confirmation that we got the order correctly and then move on to the payment part, more on that later. If the AI didn’t hear the customer properly or misunderstood them, we have to make sure we take the order all over again:

node repeat_order
{
    do 
    {
        #sayText("Let's try this again. What can I get for you today?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food");
    }
    onexit
    {
        confirm_food_order: do {
        set $food = #messageGetData("food");
       }
    }
}

After the AI asks for the order details, we need to once again program it to remember the food item (pizza kind) before moving on to confirming the order once more:

 onexit
    {
        confirm_food_order: do {
        set $food = #messageGetData("food");
       }
    }

Now, let’s say that after the intro in the node root the customer says they want to order pizza, but don’t specify which one exactly they want. We need to create a new node (node place_order_pizza) for that and ask them to specify what kind of pizza they want:

node place_order_pizza
{
    do 
    {
        #sayText("What kind of pizza would you like?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food");
       pizza_kind: goto pizza_kind on #messageHasIntent("pizza_kind");
    }
    onexit
    {
        confirm_food_order: do {
        set $food = #messageGetData("food");
       }
    }
}

The customer won’t always know which one they feel like ordering or are unaware of what’s on the menu, so we need to program that part too:

node pizza_kind
{
    do 
    {
        #sayText("Umm, we have Pepperoni, Hawaiian, Margherita, Buffalo, Cheese, and Veggie pizza. Which one would you like?");
        wait *;
    }
    transitions 
    {
        confirm_food_order: goto confirm_food_order on #messageHasData("food");
        recommend: goto recommend on #messageHasIntent("unsure");
        no_dice_bye: goto no_dice_bye on #messageHasIntent("changed_mind");
    }
     onexit
    {
        confirm_food_order: do {
               set $food =  #messageGetData("food", { value: true });
       }
    }
}

In the transition part we have 3 options for customer’s reply:

I’d like Buffalo and Cheese pizza (confirm_food_order),
Not sure which one I want, could you recommend something? (unsure),
You know what, I changed my mind, I don’t want pizza anymore (no_dice_bye).

For each one of these, we have to write down corresponding intents and nodes. Let’s take a look at the recommend part:

node recommend
{
    do 
    {
        #sayText("Our most popular one is Pepperoni and I personally love it too. Would you like to try it?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasIntent("yes");
       place_order_pizza: goto place_order_pizza on #messageHasIntent("no");
    }
    onexit
    {
        confirm_food_order: do {
               set $food =  #messageGetData("food", { value: true });
       }
    }
}

In this case, we say that the most popular pizza at Yummy Pizza is Pepperoni and recommend ordering it. If a person agrees, we bring them to our well-known (confirm_food_order) node. Once again, before leaving this node, we remember the kind of pizza the customer wanted to get. If the customer declines our offer, we ask them what kind of pizza they’d like based on the pizza options they heard from us just before.

Note that the conversation doesn’t have to have a linear structure (and most likely it won’t), so we need to write down digressions, which can be triggered at any moment of the conversation. For instance, if at any time the customer decided to say “I wanna get a pizza”, it would go directly to the digression we specified, like this:

digression place_order_pizza
{
    conditions {on #messageHasIntent("order_pizza");}
    do 
    {
        #sayText("What kind of pizza would you like?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food");
       pizza_kind: goto pizza_kind on #messageHasIntent("pizza_kind");
    }
    onexit
    {
        confirm_food_order: do {
               set $food =  #messageGetData("food", { value: true });
       }
    }
}

As you can see, it’s pretty much exactly the same as the node with the same name. The only difference here is that in the digression you have to write out the conditions for it to be triggered. In this case, if the app recognizes the intent order_pizza, it’ll trigger this digression and then make a transition to what should follow - confirming the order or walking the customer through the pizza options.

The same logic applies to other nodes, like pizza_kind and place_order.

Shall a customer not want to continue the conversation, we need to end it. We do that by writing our node no_dice_bye:

node no_dice_bye 
{
    do 
    {
        #sayText("Sorry I couldn't help you today. Have a great day. Bye!");
        #disconnect();
        exit;
    }
}

Now, imagine the customer decides to order something to drink. They can mention it at any moment, so it should be programmed as a digression too:

digression drinks 
{
    conditions {on #messageHasIntent("drinks");}
    do 
    {
        #sayText("We have vanilla milkshake and soda. Which one would you like?");
        wait *;
    }
    transitions 
    {
        soda: goto soda on #messageHasIntent("soda");
        milkshake: goto milkshake on #messageHasIntent("milkshake");
    }
}

node soda 
{
    do 
    {
        #sayText("Okay, soda it is. I added it to your order. Would that be all?");
        wait *;
    }
transitions 
    {
        payment: goto payment on #messageHasIntent("yes");
        can_help_then: goto can_help_then on #messageHasIntent("no");
    }
}

node milkshake 
{
    do 
    {
        #sayText("Okay, milkshake it is. I added it to your order. Would that be all?");
        wait *;
    }
transitions 
    {
        payment: goto payment on #messageHasIntent("yes");
        can_help_then: goto can_help_then on #messageHasIntent("no");
    }

}

We could describe all the drinks your pizza restaurant offers, but in order to not make this code too long, let’s just say we offer soda and vanilla milkshakes and the customer picks one or the other, which will bring us to either node milkshake or node soda. Once done, we’ll ask the customer if they’ll be paying at the store. For the purpose of this demo, I decided to not include the option of actual card processing, but you should definitely write it out when writing your own code.

node payment
{
    do
    {
        #sayText("Great. Will you be paying at the store?");
        wait *;
    }
     transitions 
    {
        in_store: goto pay_in_store on #messageHasIntent("pay_in_store") or #messageHasIntent("yes");
        by_card: goto by_card on #messageHasIntent("pay_by_card") or #messageHasIntent("no");
    }
}

node pay_in_store
{
    do
    {
        #sayText("Your order will be ready in 15 minutes. Once you’re in the store, head to the pickup counter. Anything else I can help you with? ");
        wait *;
    }
     transitions 
    {
        can_help: goto can_help on #messageHasIntent("yes");
        bye: goto success_bye on #messageHasIntent("no");
    }
}

node by_card
{
    do
    {
        #sayText("I'm sorry, I'm just a demo and can't take your credit card number. If okay, would you please pay in store. Your order will be ready in 15 minutes. Anything else I can help you with? ");
        wait *;
    }
     transitions 
    {
        can_help: goto can_help on #messageHasIntent("yes");
        bye: goto success_bye on #messageHasIntent("no");
    }
}

If the customer wants to ask something or need some other help, we ask how we could help (node can_help). Otherwise, we end the conversation (node bye).


node can_help
{
    do
    {
        #sayText("How can I help?");
        wait *;
    }
}

digression bye 
{
    conditions { on #messageHasIntent("bye"); }
    do 
    {
        #sayText("Thanks for your time. Have a great day. Bye!");
        #disconnect();
        exit;
    }
}

We saw the node success_bye on multiple occasions above. What we need to write in that node is a thank you message and end the conversation:

node success_bye 
{
    do 
    {
        #sayText("Thank you so much for your order. Have a great day. Bye!");
        #disconnect();
        exit;
    }
}

And now you have your pizza ordering conversational AI app ready!

Summing it up

Numbers don’t lie, people prefer ordering food to be delivered to their doorstep or walk to the restaurant to pick the food up themselves, and dine in the comfort of their own home. With this pizza ordering conversational AI app you can automate the ordering process for your pizza restaurant.

However, don’t just stop there. This was just a showcase of what your app could do. Try improving it, add more digressions and nodes, as we discussed above. Make this app answer all your customer’s demands, help you reduce costs, and free up your employees!

What is conversational AI and what use cases do different industries use it for?

Dasha — Fri, 06 Aug 2021 17:29:56 +0000

Originally posted on https://dasha.ai/en-us/blog/conversational-ai-use-cases

Conversational AI is a set of technologies that let a machine understand what is being said, evaluate what would be a contextually relevant response, and reply in a human-like manner.

To recognize human speech and be able to talk like a human a set of machine learning (ML), natural language processing (NLP), text-to-speech (TTS), speech-to-text (STT), and named entity recognition (NER) tools are used.

The conversational AI global market size is expected to grow from $4.8b (2020) up to $13.9b by 2025. Companies across various industries are quickly adopting conversational AI for business-specific purposes.

Let’s explore what industries use conversational AI and what real-world problems they solve with it.

Chatbot vs conversational AI

Chatbots are based on strictly scripted, limited conversations that use specific keywords. Chatbots are useful when it comes to simple interactions. Conversational AI on the other hand understands the subtleties of human words, intonation, and tone. By using speech recognition, it understands the spoken language of your customers. Natural language processing (NLP) helps it understand and analyze human language, be it written or spoken. Natural language understanding (NLU) helps it understand what the customers need to be done (intent classification.

Arthur wrote a fantastic article where he goes deep into differentiating chatbots and conversational AI. A highly recommended read!

Benefits of conversational AI

Here are some of the benefits companies get by employing conversational AI:

Increased productivity and effectiveness
Conversational AI automates repetitive processes, letting employees respond to more complex calls that require human creativeness.
The AI is available to take and make calls 24/7, has no sick days, is able to handle requests and answer questions no worse than a human can.
In a call center environment, for instance, the AI would let the employees advance to sales positions and qualify only the high-quality leads. Conversational AI would do all the preliminary work and qualify all the incoming leads.

Lower operating costs
Businesses spend over $1 trillion on customer service calls and conversational AI lowers that cost drastically
Conversational AI is able to handle hundreds of calls simultaneously.
Businesses save money on employee’s salaries and training. The AI reduces the number of customer support employees needed while reducing average wait time.

Increased customer satisfaction and experience
Higher engagement: customers will no longer need to wait for hours for an agent to free up or wait for working hours to start. They can get their issues solved anytime, anywhere.
Conversational AI can augment live agents’ work. The AI can provide all the information gained during the conversation, making the agents solve customer’s issues faster once the call is transferred to them.
Customer satisfaction can be maximized by the AI analyzing what happened in the past conversations. It can predict how the customer would react and what they would say based on the existing data.

Increased employee satisfaction
Conversational AI helps to reduce employee churn that occurs due to the repetitive nature of the calls. The employees can spend more time handling complex calls. It would give room to increase both hard and soft skills, and build stronger relationships with customers.
Customer support employees handle around 50 calls per day, which is extremely stressful to some. Conversational AI alleviates this problem.

Let’s now take a look at different industries that use conversational AI to achieve business-specific goals.

What industries use conversational voice AI and what use cases do they have?

Conversational AI use cases for the automotive industry

There are two primary ways car companies use conversational AI: vehicle discovery and maintenance and in-car voice assistants. The latter one is getting popular fast. In the United States, 60% of people are inclined to buy a car with an assistant installed. Nearly 130 million people have already tried using one in their car and over 80 million enjoyed using their in-car voice assistant so much that they’re using it constantly.

Let’s take a look at the two use cases in more detail:

Vehicle discovery and maintenance

Conversational AI makes it easy for customers to discover new cars, book test drives, compare different models of cars, and find a car that matches their requirements. Customers can also have the ease of making inquiries about car loans and payment options.

Automotive industry companies also use conversational AI to automate car check and repair appointments.

Connected vehicles

Nowadays, cars are smarter than ever. Car manufacturers incorporate conversational AI into cars so that drivers can have a safer and more efficient driving experience. For example, in-car voice assistants can make calls, control smart home devices, shop for products, and book a table at a restaurant.

It doesn’t stop there, though. In-car voice assistants can control virtually all car functions. Consumers want their in-car assistants to have more than just basic functions. Customers are expecting their assistants to support various areas of life and help control in-car conditions. To name a few, the control conditions within the car include opening and closing of the windows or the trunk, locking/unlocking the doors, help with parking, AC control, and managing car settings in response to time of the day and weather conditions.

We have created in-car voice assistant app as a proof of concept. .

Conversational AI for banking industry

Conversational AI is transforming the way banking industry companies retain their customers and gain new ones. It is expected that 90% of communication between the banks and their customers will happen through a bot. It’s also expected by 2023 that banks will save $7.3B
of the operational by cost bots. These contribute to the wide adoption of AI in the banking sector.

Here are some of the possible ways banks use AI:

FAQ

Asking a frequently asked question doesn’t require the customer to provide any additional information to prove their identity. This makes this use case one of the simplest ones. Since banks don’t operate on a 24/7 basis and neither do their customer support lines (for the most part), having conversational AI that solves this is a valuable addition.

Loan application automation

There’s no more need for a customer to physically be at the bank or wait on the phone for a representative to free up to create a loan application. When integrated with other sources, AI can analyze documents, make notes, and perform data verification. This makes the job of the bank representative easy when it comes to the loan approval process.

Scheduling an appointment with a bank representative

It might be tough to get a hold of a bank representative once a customer is at the bank. Scheduling an appointment in advance saves customers’ time and lets them create plans beforehand. Appointment scheduling can be easily automated via a conversational AI app.

Payment processing

Customers might need to transfer money from one bank to another or from one account to another at any moment of time. Accounting for such a use case, Dasha AI created a simple app banks can use to automate payment processing.

Feedback surveys

Phone feedback surveys used to be expensive, however, with the rise of conversational AI, that’s no longer the case. Phone surveys are proven to be the best channel to get feedback from customers - they have an over 90% response rate on picked up lines. Here’s a simple app that illustrates how to create customer feedback conversational AI app .

Conversational AI for healthcare industry

The Healthcare Global Forecast projected that by 2026, the healthcare industry will experience an immense boost in revenue and see improvements in patient health management due to AI adoption. Healthcare companies use AI in myriad different ways: drug discovery, patient care, illness diagnostics, etc. Conversational AI is also on the list:

Appointment scheduling

Nurses and administrators are already busy enough tending to the patients, so it’s necessary to free them from easily automatable calls. With Dasha AI it’s easy to make a conversational AI app that lets patients search for doctors and arrange appointments all within one conversational interface. An appointment scheduling app can also ask screening questions since it would provide the doctor with background information prior to the appointment.

Mental health management

With machine learning techniques, a mental health management conversational AI app can analyze the tone and the speed of the patient’s voice and provide recommendations based on that. It also could be programmed to analyze patterns of a patient’s mood, activities, and overall mental state over time and, if necessary, make appointments with healthcare professionals. For instance, if it recognizes either by speech tone or words that the patient is stressed out, it could suggest a pre-programmed range of meditations or provide a range of relaxation techniques. Such conversational AI apps could be integrated with various sources of health trackers (heart rate, sleep, diet, blood pressure, sugar level) and make recommendations according to those indicators.

Yet when creating a mental health conversational AI app you should exercise caution. For instance, it’s important not to use such AI to diagnose or treat suicidal patients, as a human with medical education is the right fit.

Such a mental health management AI app can be easily created with Dasha conversational AI API and integrated with various services and health trackers to provide further benefits for the patients.

Health plan research and management

Insurance companies employ conversational AI to generate customers out of leads by walking them through existing insurance policies and helping them pick the one that suits their needs. The AI can assess risks based on the customer’s historical data and provide them the best insurance recommendations. Here’s an example of a conversational AI app that lets you qualify leads better and faster.

Symptom checkers

This use case encompasses more than simple symptom checking.

Conversational AI can call patients who are in rehabilitation after surgery to check on their health, ask about their symptoms and suggest some pain-alleviating strategies if needed. Patients can also make a call to ask a pressing health-related question, be it about medication or illness, and be provided with a preliminary diagnosis and referred to a specialist. If conversational AI deems that the symptoms are serious, it can either call emergency services on behalf of the patient or make a strong recommendation to call 911.

Companies outside of the healthcare industry can make use of conversational AI symptom checkers. For example, a company might want to check their employee’s health status prior to their shift. We’ve created a conversational AI symptom checker app that assesses whether a shift worker has any Covid-19 symptoms. In case they do, the AI suggests they stay at home, otherwise, it lets them know they’re expected to come to work.

If you’re interested in other ways the healthcare industry uses AI, check out this post

Conversational AI for hospitality industry

Restaurants, hotels, amusement parks, cruises, entertainment, and tour agencies can all use conversational AI. Customer support is the one that can be automated regardless of what the business sector is.

Automated hotel operations

Hotels, for instance, can automate the room booking process, 24/7 access to information about the hotel, its services, hotel vicinity questions, or other traveling information. When hotels employ conversational AI they can expect rapid growth of their business. The AI helps to increase customer loyalty, as a happy traveling experience starts with having a great place to stay.

Automated restaurant operation

Restaurants can have table booking calls automated, making it possible for hosts to focus on welcoming customers. Another possibility is automating food ordering and delivery. We’ve created a simple food ordering app that helps pizza restaurants take orders in a seamless way, you can check the use case here.

Conversational AI for logistics industry

To increase customer satisfaction, logistics companies automate the way customers get package delivery updates. One of the best ways to do that is through conversational AI.

Delivery status, tracking, and rescheduling

Over 530 million packages are delivered per day by UPS, USPS, and FedEx alone. In order to manage such volume without the risk of losing customers due to overwhelmed customer support, logistics companies use automation.

The conversational AI can pull the package information from the database once the customer provides a tracking number. From there it can solve virtually any issue customers can have: rescheduling the delivery date and/or time, checking the status of the delivery, check for other deliveries, etc.

Check out this conversational AI app logistics companies can use to automate package tracking.

Conversational AI automation is easy - and mega efficient

While we took a closer look at only a few industries, there are many other ones that find value in using conversational AI. While the use cases are different for all, one remains constant: customer support automation.

Happy customers mean loyal customers that are ready to support your business financially for a long period of time. That’s why companies are obsessed with having superior customer support. Employing conversational AIl makes companies even more customer-centric. Most of the customers’ inquiries can be solved by AI in a prompt and personalized manner, while more complex ones can be handled by human employees.

Dasha AI makes automating virtually any process with conversational AI easy, so why don’t you try creating an app yourself? You can start with this tutorial. Be sure to join our developer community first.

How to build a conversational AI front desk receptionist app for a hotel in just 2 hours

Dasha — Fri, 06 Aug 2021 10:54:04 +0000

Originally published on https://dasha.ai/en-us/blog/AI-hotel-front-desk-receptionist

Today we’ll build an automated AI receptionist. Know a small business hotel owner? Build this human-like conversational AI app, test it with them and deploy. Hook your friends up, they will probably be so thankful as to give you some free hotel stays.

The best part is that you’ll build this app in less than 2 hours. The app creation process with Dasha AI is super intuitive, even a non-developer (or a citizen developer like me, who built this app) can do it.

Hotel front desk AI: why are we building this thing?

There is one great reason to automate repetitive customer interactions with conversational AI. It frees up the humans who used to do these tasks to do more meaningful work, increasing the customer experience all around. That being said, I thought it would be fun (and relevant) to build a robust application that can take a hotel guest’s food order, schedule dry cleaning, bring up some necessities, or tell them a bit about the local area. Also, this is a great learning opportunity if you are just starting to write DashaScript and to use the Dasha platform.

Without further ado, let’s start building the conversational AI app.

Creating a conversational AI hotel front desk receptionist

Once you’ve built the AI receptionist, this is how the completed app will perform:

Embedded content: https://youtu.be/2Glp_HC-VHc

Step 1: Prep work for creating an AI front desk receptionist app

Dasha conversational AI platform is used by developers to create human-like conversational workflows. These can be used for voice interfaces for apps, as well as for customer communication, such as in the example today. Conversational AI uses STT (speech to text) to “read” human speech, NLP, and NLU (natural language processing and understanding) to recognize the user’s intent and NLG (natural language generation) and TTS (text to speech) to respond to the user. As a developer, you don’t need to be a data science expert, you get to use all of these technologies as a service of the Dasha Platform. For a deeper dive, take a look at this post.

In the case of the hotel receptionist app, these AI as a Service technologies make the user/customer/hotel guest feel like they are talking to a considerate human receptionist.

To get started you need to define the conversation flow. There are three parts to it:
Define the perfect world flow(s) - how will the conversation go if the user/customer engages with the receptionist as you want them to;
Define additional/logical extension workflows. In which direction will the conversation need to go, based on some of the interactions;
Define digressions - ways in which the user may send the AI on a tangent. Digressions are an essential component of a human-like conversation. Digressions can also be used as an integral part of a perfect world conversational flow. For example, if the user can give a dozen different intents that they seek to achieve in the course of the conversation. More on this in the tutorial.

You can refer to this article which takes you through creating a conversational map step-by-step.

Step 2: Your conversational AI workplace setup

You will need VSCode (Visual Studio Code), NPM, and Node.js, latest versions. Next, join Dasha developer community so that you can get your API key and be able to get assistance from our developers at any moment you need.

To ease your coding process, you’ll need to get the Dasha Studio extension in VSCode and install Dasha CLI (command line interface by typing npm i -g "@dasha.ai/cli" in the VSCode terminal. For more on Dasha CLI usage, refer to this post.

In case you need assistance, ask in our developer community, and here is a step-by-step tutorial on getting started.

Now, clone and open a project with this Dasha app source code here.

Once done with setting everything up you can move on to the coding part itself.

Step 3: Get to know what you’ll use to create an AI front desk receptionist

There are 3 files you’ll need to use to create your conversational AI hotel front desk receptionist: main.dsl, data.json, and index.js. Let’s take a quick look at the functions of these three.

Main.dsl - this is where you’ll write your DashaScript Language code to create the workflow of your conversational AI app. With Dasha Studio extension on and with the directions in this post, it’ll be an easy job for you.
Data.json - this is where you set the intents and entities(AKA NER, AKA Named Entity Recognition). The neural network will use intents and entities you’ll create to learn.

Index.js - it’s the NodeJS file that launches the Dasha SDK. Here you’ll be adding any external functions you deem necessary once adapting the code to your hotel’s needs.

Now that that’s off the table, let’s get to the fun part - the coding!

Step 4: Build your conversational AI app

The first thing to do is to download Dasha First App, which will serve as a base for your code. Once uploaded to VSCode, go to main.dsl and data.json(it could also be called intents.json) and delete everything you see there.

Now, start off by importing the common libraries:

// Import the commonReactions library so that you don't have to worry about coding the pre-programmed replies
import "commonReactions/all.dsl";

Next, establish the context your AI hotel front desk receptionist app will use:

context
{
// Declare the input variable - phone. It's your hotel room phone number and it will be used at the start of the conversation.  
    input phone: string;
    output new_time: string="";
    output new_day: string="";
// Storage variables. You'll be referring to them across the code.
    food: {[x:string]:string;}[] = [];
    pizza: {[x:string]:string;}[]?=null;
    appetizers: {[x:string]:string;}[]?=null;
    main_dishes: {[x:string]:string;}[]?=null;
    drinks: {[x:string]:string;}[] = [];
    forgotten_thing: {[x:string]:string;}[]=[];
}

The start node root serves as a welcome message and a starting point for the phone conversation:

// A start node that always has to be written out. Here we provide instructions to the AI app on how to behave once the connection is established. 
start node root
{
    do
    {
        #connectSafe($phone); // Establishing a safe connection to the hotel room's phone.
        #waitForSpeech(1000); // Waiting for 1 second to say the welcome message or to let the hotel guest say something
        #sayText("Hi, this is Butterfly Resort Hotel reception. How may I help you?"); // Welcome message
        wait *; // Waiting for the user to reply
    }
    transitions // Here you give directions to which nodes the conversation will go
    {
        // Transitions could be written out here, in which case you'd need to write out corresponding nodes. Otherwise, the conversation will go to a digression triggered by specific intent. In this case, we are routing the conversation with digressions. 
    }
}

As you can see, there’s noting under transitions. That doesn’t mean you don’t need or have to write anything under it. The reason why I left this part blank is that the code is almost entirely based on digressions.

Digressions in the code exist since it’s human and natural to go off on a tangent and we, as developers of a conversational AI app, have to account for that. Digressions can be triggered at any moment of the conversation and either lead to another digression or a transition to the corresponding node established under transitions. Let’s take a look at one of the digressions:

digression cleaning // Digressions can be triggered at any moment of the conversation. 
{
    conditions {on #messageHasIntent("cleaning");} // This digression is triggered when a person says something that is related to the room cleaning service. The intents are written out in the data.json file.
    do // Once this digression is triggered, here's what Dasha AI will do
    {
        #sayText("Absolutely, someone will come up to your room in approximately 10 minutes. Is there anything else I can help you with?");
        wait *; // Waiting for the person to either end the call, proceed to ask more questions, etc. The AI doesn't say anything before hears a human speak.
    }
}

Notice that there are no transitions here. The conversation can go to any digression specified in the code at this moment. Now, let’s take a look at a digression that has transitions specified:

digression order 
{
    conditions {on #messageHasIntent("order");}
    do
    {
     #sayText("Sure thing. What would you like to order?");
     wait *;
    }
    transitions
    {
        menu: goto menu on #messageHasIntent("menu") or #messageHasIntent("unsure"); // In this case we expect the hotel guest not knowing what's on the hotel restaurant's menu, therefore we will make a transition to the menu node
    }
}

There can be as many transitions as you deem necessary. For the purposes of this demo, I’ve only written one - menu.

node menu
{
    // Note that you don't write conditions for nodes (compared to digressions), because a node always has another node (or digression) directly leading into it.
    do    {
        #sayText("We have various appetizers, pizza, main dishes and drinks. What would you like to get?");
        wait *;
    }
    transitions // 4 options of different types of food/drinks. 
    {
        appetizers: goto appetizers on #messageHasIntent("appetizers");
        pizza: goto pizza on #messageHasIntent("pizza");
        main_dishes: goto main_dishes on #messageHasIntent("main_dishes");
        drinks: goto drinks on #messageHasIntent("drinks");
    }
}

Four transitions here. Each of the transitions leads to one of the menu options, depending on what exactly the hotel guest is feeling like eating.

Now is the perfect time to note that we have #messageHasIntent("drinks"). The conversation will transfer to the corresponding node in case the guest have said something that triggers the intent “drinks”. However, very soon we’ll see that we have an entity with the same exact name, but ”drinks” at that time will serve us an entirely different purpose.

Back to the code. Let’s imagine the guest isn’t too hungry and wants appetizers. That’s what we’re going to write:

node appetizers
{
    do 
    {
        #sayText("We've got fried calamari, french fries, spring salad, and a soup of the day. What of these would you like to order?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food"); // We have an entity here - food. It's written out in the data.json file under entities.
    }
     onexit // Specifies an action that Dasha AI should take, as it exits the node. The action must be mapped to a transition
    {
        confirm_food_order: do {
               set $appetizers =  #messageGetData("food", { value: true }); // Dasha AI will remember what has been ordered and will update the "food" variable. "value: true" will return all results that have a value field
       }
    }
}

digression appetizers
{
    conditions {on #messageHasIntent("pizza_kind");}
    do 
    {
        #sayText("We've got fried calamari, french fries, spring salad, and a soup of the day. What of these would you like to order?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food"); 
    }
     onexit
    {
        confirm_food_order: do {
               set $appetizers =  #messageGetData("food", { value: true });
       }
    }
}

Note that there is both a node and a digression here. It’s not impossible that the guest already knows what’s on the menu (maybe he ordered food earlier in the day), and we should account for that.

After your AI hotel receptionist got the information, it’ll transfer to the confirm_food_order node:

node confirm_food_order
{
    do
    {
        var sentence = "Perfect. Let me just make sure I got that right. You want ";
        set $food = #messageGetData("food");
        for (var item in $food) {
            set sentence = sentence + (item.value ?? " and ");  // In case the guest decides to order multiple items of food
        }
        set sentence = sentence + ". Is that right?";
        #sayText(sentence); 
        wait *;
    }
     transitions 
    {
        order_confirmed: goto order_confirmed on #messageHasIntent("yes");
        repeat_order: goto repeat_order on #messageHasIntent("no");
    }
}

At this point, we’ve given feedback to the guest explaining that we’ve understood and noted what they want and now should either confirm the order or repeat it:

node order_confirmed
{
    do
    {
        #sayText("Your order will be ready in 15 minutes. We'll bring it straight to your room! Anything else I can help you with? ");
        wait *;
    }
     transitions 
    {
        can_help: goto can_help on #messageHasIntent("yes");
        bye: goto bye on #messageHasIntent("no");
    }
}

node repeat_order
{
    do 
    {
        #sayText("Let's try this again. What can I get for you today?");
        wait *;
    }
    transitions 
    {
       confirm_food_order: goto confirm_food_order on #messageHasData("food");
       confirm_drinks: goto confirm_drinks on #messageHasData("drinks");
    }
}

In case the conversational AI app got the order correctly, we’ll proceed to ask what else we could help the guest with, or end the conversation shall the guest says “bye” or a derivative (again, all written down in the intents part in the data.json file).

In the node repeat_order it’s best we write out 2 transitions: one going back to confirming food order, another one going back to confirm the drinks order, since drinks and food are two separate entities.

node drinks
{
    do 
    {
        #sayText("We have orange juice, Sprite, and vanilla milkshakes. What would you like to get?");
        wait *;
    }
    transitions 
    {
       confirm_drinks: goto confirm_drinks on #messageHasData("drinks");
    }
    onexit
    {
        confirm_drinks: do {
        set $drinks = #messageGetData("drinks");
       }
    }
}

digression drinks
{   
    conditions {on #messageHasIntent("drinks");}
    do 
    {
        #sayText("We have orange juice, Sprite, and vanilla milkshakes. What would you like to get?");
        wait *;
    }
    transitions 
    {
       confirm_drinks: goto confirm_drinks on #messageHasData("drinks");
    }
    onexit
    {
        confirm_drinks: do {
        set $drinks = #messageGetData("drinks");
       }
    }
}

Once again, same as with the food, we want both a node and a digression.

And finally we see the messageGetData("drinks"). As mentioned before, this “drinks” part comes from entities. Let’s take a quick look:

    "drinks": {
      "open_set": false,
      "values": [
        { "value": "orange juice", "synonyms": ["OJ", "juice", "orange drink"] },
        { "value": "vanilla milkshake", "synonyms": ["milkshake", "vanilla drink", "vanilla one"] },
        { "value": "Sprite", "synonyms": ["soda"] }
      ]

Take a look at the way entities for “food” are written in order to see the difference.

  "entities": 
  {
    "food": {
      "open_set": true,
      "values": [
        { "value": "Pepperoni", "synonyms": ["pepperoni", "pepperoni pizza", "a pepperoni", "the pepperoni pizza"] },
        { "value": "Margherita", "synonyms": ["Margherita pizza", "a margherita pizza", "a margherita", "margherita"] },
        { "value": "Veggie", "synonyms": ["vegan pizza", "vegan", "vegans", "vegeterian", "with vegetables", "without meat"] },
        { "value": "fried calamari", "synonyms": ["calamari", "the fried calamari", "the calamari"] },
        { "value": "french fries", "synonyms": ["fries", "the french fries", "the fries"] },  
        { "value": "spring salad", "synonyms": ["the salad", "a salad", "spring one"] },
        { "value": "soup of the day", "synonyms": ["the soup", "soup", "whatever soup", "a soup"] },
        { "value": "mushroom tortellini", "synonyms": ["tortellini", "the tortellini", "the mushroom thingy"] },
        { "value": "baked honey mustard chicken", "synonyms": ["the honey mastard one", "honey mustard", "honey one", "chicken", "baked chicken", "baked honey chicken", "baked mustard chicken", "mustard one"] },
        { "value": "pasta carbonara", "synonyms": ["pasta", "carbonara"] },
        { "value": "vietnamise porkchops", "synonyms": ["vietnamese dish", "pork", "porkchops"] }
      ],
      "includes": [
        "I'd like a (pepperoni)[food] please",
        "I'll take a (veggie pizza)[food] now",
        "I'll like to get a (margherita)[food]",
        "I'll like a (margherita)[food]",
        "I'll have a (Pepperoni)[food] please",
        "I'll order the (soup of the day)[food]",
        "I'll have some (french fries)[food]",
        "I'll order a (spring salad)[food]",
        "I'll take (french fries)[food]",
        "I'll take the (mushroom tortellini)[food]",
        "I'll get the (muchroom thingy)[food]",
        "I'll take the (soup)[food]",
        "I'll take the (honey one)[food]",
        "I'll take the (huney mastard)[food]",
        "order the (pasta)[food]",
        "get a (pasta carbonara)[food]",
        "take that (vietnamese dish)[food]"
      ]
    },

Here, we don’t want to write a new entity for each food item like pizza, appetizers, etc. We’d rather have it all in one place. It’s also important to note that for the app to learn properly, it’s best to write out an ”includes” section, specifying a couple of ways the hotel guest can say his order.

Now, let’s take a look at another example similar to the “food” and “drinks” one. Humans can be forgetful and it’s not uncommon for them to not bring something they need to the hotel. Let’s create a case for this. Here and below please refer to the comments within code body for details:

digression forgot_sth
{
    conditions {on #messageHasIntent("forgot_sth");}
    do
    {
        #sayText("That happens, don't worry. I'm sure we have whatever you need. What did you forget to bring?");
        wait *;
    }
    transitions
    {
        forgotten_thing: goto forgotten_thing on #messageHasData("forgotten_thing");
    }
}

node forgotten_thing
{
    do
    {
        var sentence = "Okay, we're about to bring  ";
        set $forgotten_thing = #messageGetData("forgotten_thing");
        for (var item in $forgotten_thing) {
            set sentence = sentence + (item.value ?? "and");
            }
        set sentence = sentence + " to you. Did I get that right?";
        #sayText(sentence); 
        wait *;
    }
     transitions 
    {
        confirm_forgotten: goto confirm_forgotten on #messageHasIntent("yes");
        repeat_forgotten: goto repeat_forgotten on #messageHasIntent("no");
    }
}

node confirm_forgotten
{ 
    do 
    { 
        #sayText("We're gonna bring it to to your room in 5 to 10 minutes. May I help with any other questions?");
        wait *;
    }
     transitions
    {
        can_help: goto can_help on #messageHasIntent("yes");
        repeat_forgotten: goto repeat_forgotten on #messageHasIntent("no");
    }
}

node repeat_forgotten
{
    do 
    {
        #sayText("Let's try this again. What was it that we can bring you?");
        wait *;
    }
    transitions 
    {
       forgotten_thing: goto forgotten_thing on #messageHasData("forgotten_thing");
    }
    onexit
    {
        forgotten_thing: do {
        set $forgotten_thing = #messageGetData("forgotten_thing");
       }
    }
}

As you can see, this follows the same logic as the “food” and “drinks” sections. Now it’ll be easy for you to create similar cases that fit your hotel’s and guest’s needs.

That being said, here are some other cases your conversational AI hotel receptionist is able of solving:

Taking a request to take clothes to the dry cleaner shop

digression dry_cleaning
{
    conditions {on #messageHasIntent("dry_cleaning");}
    do
    {
     #sayText("Absolutely, we'll pick your clothes up soon and send it to the dry cleaning service. We'll bring your clothes back to you in 1 day. Is there anything else I can help you with?");
     wait *;
    }
}

Navigating the hotel guests on what to do and what to see

digression vicinity
{
    conditions {on #messageHasIntent("vicinity");}
    do
    {
     #sayText("There are parks, cinemas, restauntants and an amusement park in the area. What interests you the most at this moment?");
     wait *;
    }
}

digression park
{
    conditions {on #messageHasIntent("park");}
    do
    {
        #sayText("We have two parks nearby: sunrise valley park and oak tree park, both are super beautiful and open twenty four seven. Both are located right outside the hotel within a two minute walking distance. Is there anything else I can tell you about?");
        wait *;
    }
}

digression cinemas
{
    conditions {on #messageHasIntent("cinemas");}
    do
    {
        #sayText("There’s ABA cinema that's located just 5 minutes away to the south of the hotel. It's open from 9 AM to 1 AM. Is there anything else I can tell you about?");
        wait *;
    }
}

digression restaurants
{
    conditions {on #messageHasIntent("restaurants");}
    do
    {
        #sayText("The 2 amazing restaurants around are Kimchi One restaurant, which is open from 9 AM to 9 PM and Bonjorno restaurant, open from 8 AM to 11 PM. Is there anything else I can help with?");
        wait *;
    }
}

digression amusement_park
{
    conditions {on #messageHasIntent("amusement_park");}
    do
    {
        #sayText("There's an amusement park which is within a 15 minute drive. You can take the free shuttle that's located right outside the hotel entrance to get there. But make sure to go there within its working hours, it closes at 4pm these days. Is there anything else I can help with?");
        wait *;
    }
}

Changing the checkout day

You can make this a date instead of a day. Should that be the case, you’ll need to write down an external function that would be connected to your hotel guest/room scheduling system.

node check_out_diff_day
{
    do
    {
        #sayText("What day would you like to check out?");
        wait *;
    }
    transitions 
    {
       new_checkout_day: goto new_checkout_day on #messageHasData("day_of_week");
    }
    onexit
    {
        new_checkout_day: do 
        {
        set $new_day = #messageGetData("day_of_week")[0]?.value??"";
        }
    }
}

digression check_out_diff_day
{
    conditions {on #messageHasIntent("check_out_diff_day");}
    do
    {
        #sayText("What day would you like to check out?");
        wait *;
    }
    transitions 
    {
       new_checkout_day: goto new_checkout_day on #messageHasData("day_of_week");
    }
    onexit
    {
        new_checkout_day: do 
        {
        set $new_day = #messageGetData("day_of_week")[0]?.value??"";
        }
    }
}

node new_checkout_day
{ 
    do 
    { 
        #sayText("Just changed your checkout day to " + $new_day + ". Is that right?");
        wait *;
    }
        transitions
    {
        can_help: goto can_help on #messageHasIntent("yes");
        repeat_new_checkout_day: goto repeat_new_checkout_day on #messageHasIntent("no");
    }
}

node repeat_new_checkout_day
{
    do 
    {
        #sayText("Let's do it one more time. What day would you like to check out?");
        wait *;
    }
    transitions 
    {
       new_checkout_day: goto check_out_diff_day on #messageHasData("day_of_week");
    }
    onexit
    {
        new_checkout_day: do {
        set $new_day = #messageGetData("day_of_week")[0]?.value??"";
       }
    }
}

Changing the checkout hour

node check_out_diff_hour
{
    do
    {
        #sayText("What time would you like to check out?");
        wait *;
    }
    transitions 
    {
       new_checkout_hour: goto new_checkout_hour on #messageHasData("time");
    }
    onexit
    {
        new_checkout_hour: do 
        {
        set $new_time = #messageGetData("time")[0]?.value??"";
        }
    }
}

digression check_out_diff_hour
{
    conditions {on #messageHasIntent("check_out_diff_hour");}
    do
    {
     #sayText("What time would you like to check out?");
     wait *;
    }
    transitions 
    {
       new_checkout_hour: goto new_checkout_hour on #messageHasData("time");
    }
    onexit
    {
        new_checkout_hour: do 
        {
        set $new_time = #messageGetData("time")[0]?.value??"";
        }
    }
}

node new_checkout_hour
{ 
    do 
    { 
        #sayText("You got it. I just changed your checkout time to " + $new_time + ". Did I get that correctly?");
        wait *;
    }
    transitions
    {
        can_help: goto can_help on #messageHasIntent("yes");
        repeat_new_checkout_hour: goto repeat_new_checkout_hour on #messageHasIntent("no");
    }
}

node repeat_new_checkout_hour
{
    do 
    {
        #sayText("Let's do it one more time. What hour would you like to check out?");
        wait *;
    }
    transitions 
    {
       check_out_diff_hour: goto check_out_diff_hour on #messageHasData("time");
    }
    onexit
    {
        check_out_diff_hour: do {
        set $new_time = #messageGetData("time")[0]?.value??"";
       }
    }
}

Answering questions about the things to do inside of the hotel

Perhaps your hotel has a SPA or/and a swimming pool inside the hotel or somewhere in its vicinity. Nothing is stopping you from writing those nodes and digressions out, make your guests aware of everything you have to offer and make their stay as pleasant as possible :)

digression hotel_restautant
{
    conditions {on #messageHasIntent("hotel_restautant");}
    do
    {
     #sayText("We do have a restaurant on the first floor. It's open from 7am to 11pm and we're looking forward to seeing you there. May I help with anything else?");
     wait *;
    }
}

That’s only the beginning of a wonderful, profitable journey with conversational AI

This app is just a demo. Improve on it, edit it, make it answer the needs of your guests. Create an unforgettable hotel experience for the user so that they want to only choose your hotel as a future place to stay.

Join Dasha Developer Community for guidance throughout this exciting journey. It’s a great community to meet like-minded developers.

Thank you and the best of luck! Let me know what you think of this post and this code in the community :)