DEV Community: Arthur Grishkevich

Conversational AI is now available via Zapier. 3 steps to a simple app

Arthur Grishkevich — Tue, 12 Oct 2021 06:06:18 +0000

We finally integrated Dasha with Zapier. This is pretty awesome because now any conversational app you write for Dasha can be used as an input/output function using any other apps on Zapier.

For example - we can input into a Dasha app the user's first name and phone number collected from a lead form on a website using Zapier. Dasha app calls the user and collects data which is then output into Hubspot CRM or Google Calendar or anything else you can think of.

Here is a demo of the result:

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 fifteen minutes. 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.

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.

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.

Conversational AI should be in every developer toolbox. Here's why.

Arthur Grishkevich — Wed, 15 Sep 2021 01:35:49 +0000

Hi folks. I’ve posted a few conversational AI tutorial articles here. I realize that I failed to talk about one important thing - why you, as a developer, should even think about adding conversational technologies to your stack of tools.

Fair warning: I work for a startup with the world’s most advanced conversational AI APIs and a studio built specifically for developers. Because of this, the examples of use cases and approaches below will be based on the art of the possible with Dasha. I will also talk to you about Google Dialogflow and Rasa AI which offer great sets of tools for some use cases.

Why think about conversational voice technologies in the first place

Voice is the native interface for human-human communication. And that’s it. That’s your reason for why you should think about conversational AI technologies. The tactile way in which we communicate with machines today is a stepping stone.

Look at science fiction to show you the way (I have been doing this since I learned to read and it hasn’t steered me wrong). HAL 5000 in 2001: A Space Odyssey, Eddie the ship's computer in HHGTTG, Jarvis in Iron Man. These are all machines that communicate with humans at a level indistinguishable from a human being. In this communication commands are born not in the simple command-response ways of today’s Alexa.

These machines parse deep intent from the words of the human that is conversing with them, from their intonations, emotional tone and from the wider context of the conversation. Which is the same thing that humans do. Which makes the human feel comfortable in conversing with the machines. Which, in other words, passes the Turing test.

In order for voice user interfaces to become ubiquitous, we need conversational AI that communicates at a level indistinguishable from a human, without falling into an uncanny valley trap.

Where is conversational voice AI today

What is done with conversational AI today:

Chatbots. Mainly simple, often multiple-choice apps. Great for taking an order or routing a customer to the right support agent. I felt I had to mention, though the focus of this article is on voice.
Basic voice user interfaces - Alexa Skills, Siri assistant and such. They are great for fulfilling a single function, for example, tell you the weather or play a song. As these are command-response interactions, they do not aim to pass the Turing test and they are limited in scope of application.
Voice AI business automation. Call center automation from simple voice (not touch tone) menus to more complex outbound applications. Some of these applications (mainly outbound today) do aim to pass the Turing test and oftentimes do pass it.

We’re not yet at the point where conversational AI can fully replace tactile interfaces. Yet we are getting there. Here is me giving a demo of a conversational app which I recently built:

This is a fairly simple demo. It only took me a few of hours to build from scratch. Using the same technology already today some Dasha users are building conversations with hundreds of logical nodes. In live call center environments, some apps are performing better than their human agent counterparts were before them.

If you want to try building an app like the one in point 3, just look at my post history for some tutorials or pop in to our conversational AI dev community. You'll get an API key and instructions automatically upon joining. @ me in the intro channel, I’ll help where I can.

What will adding conversational AI to your toolbox give you, as a developer?

It will give you two things. The ability to build voice interfaces for your apps and the ability to run automated telephone conversations with an API call.

Voice user interfaces

With a deep voice interface you can let your users engage every interaction in your app with their voice.

A few use cases for this:

If your app is designed to be used on the go (walking, running, driving), for example, it’s a navigation app, a music app, etc.
If there is a use case in which your app runs in the background, while the user switches to another app.

I think in the future, VUIs will be standard fare in most new software products.

In the meantime, you can implement a voice user interface with Dasha using a connector to our Node.js SDK. Next year, we will roll out Swift and Kotlin SDKs.

Automated telephone conversations

Kind of like Twilio giving developers the ability to use SMS text messages with the call of an API, a proper conversational AI API gives you the ability to conduct automated calls with the call of an API.

Here are just a few use cases you might want to use this for:

Call a user who abandoned their shopping cart and ask if they need any help completing the purchase or have some questions they need answered.
Call a user to verify some details or call them up as a part of an onboarding process.
Set up a fully automated customer service line for your product. You can take calls through telephony or in-app using voice over GRPC.
Call back a newly generated lead in less than a minute to convert them into a user.
Build a voice Discord bot that can do pretty much anything you can think of.
Literally build a replacement for a call center agent and impress your boss at the big bank.

What skills do you need to build with conversational AI?

Analytical

Analytical skills are important for two reasons. One - you need to logically structure your conversation before you begin developing it. Two - you will need to analyze live conversations that your AI app has with real human users and implement changes to improve the app. Rasa AI calls this second part Conversation Driven Development. I love this term. We at Dasha call it training the application.

Coding

Google Dialogflow

Interestingly enough, with Google Dialogflow, the analytical skill is the only one you will need to create conversations - it is an in-browser GUI for creating automated dialogues. You can provide intents training data, create scripts, STT and TTS comes out of the box. Two software engineers who tested all three platforms felt that their learning curve was higher with Dialogflow even though it was a no-code environment, than with Rasa or Dasha. Pros: no-code platform. Biggest cons: speech synthesis sounds very robotic, hard to make dialogue paths handle digressions. You may need a bit of technical knowledge to set up integrations through web hooks.

Rasa AI

To use Rasa, you will need to have Python installed to use Rasa Open Source. Knowledge of Python will be needed as you build. You can specify intents, as a part of training data. As mentioned earlier, Rasa is a technology for chatbots. If you want to use it with voice, you will need to connect external text to speech and speech to text. Connecting to external services obviously adds delays which detracts from the conversational user experience.

There are multiple dialogue policies which can be used simultaneously and which dictate conversation flow (I found this a bit confusing). Rasa has a great low-code/no-code GUI for conversational design. You describe dialogue using stories and intents using NLU data. You can also specify bot responses, forms (collecting data) and rules. The open source Rasa server runs on your machine and connects to your app.

Its main pro is that you can quickly build simple, straightforward text conversations. Its main drawback is that it is a bot builder. It does not aspire to let you create conversations which are human-like in form and content.

Dasha AI

To use Dasha, you will need to have Node.js installed. You will also want to know JavaScript. DashaScript is a domain-specific language which you use to script the dialogue between the machine and the user.

You specify intents training data, much as you do with Rasa, but with Dasha you can also define named entities which can be used for slot filling. You define AI responses in the phrase map or right within the body of your dialogue script. You can define digressions (send conversation to a specific node at any point based on what the user has said), to emulate how humans do dialogue. Human-like speech synthesis and text to speech come out of the box. Dasha SDK runs within your Node.js app, the conversation gets executed in the Dasha Cloud.

Dasha’s main pro is that you can build simple human-like conversations quickly or take longer to build complex conversations of nearly unlimited depth. Its main drawback is that we are still in Beta and polishing up some details with user feedback. All the more reason to join our community and be one of the folks giving their input to this AI as a service engine. Don’t get it twisted though, we have paying customers using the product even in its Beta. Dasha AI is processing close to 10 million conversations monthly.

In closing

To summarize, you’ll be able to add conversational AI to your stack of developer tools even if you have only a few months of programming experience. I’m a case in point - I started building with Dasha, then started teaching myself JavaScript with FreeCodeCamp. I have used Rasa Open Source and had no problem with it even though my Python skills are almost non-existent.

You should hold some of these tools in your stack because they let you engage with users in ways that differentiate the user experience.

Have you used conversational AI dev tools before?

How to lose a hackathon in 7 steps

Arthur Grishkevich — Tue, 31 Aug 2021 12:04:42 +0000

I took part in a hackathon recently. My team lost miserably. Here are the steps we followed to secure this loss.

You may find these valuable if you do want to win the next hackathon you participate in. Or if you want to lose it.

Losing a hackathon

Step 1 - Don’t prepare until an hour or two before the event starts

This step is absolutely key. If you ignore it you might actually have a chance of winning. We had thought about reviewing the APIs we would be working with and getting together a week prior to the hackathon. Had we done so, we might have had time to brainstorm and come up with a concept for our product. We might even have mapped out our architecture and integrations, if at a high level. Or we may have defined our areas of responsibility. Certainly we would have been one step closer to winning, so we did not do it. Instead, we got together at the official start of the hackathon, bounced some ideas around, picked the worst one (more on that below) and ran with it.

Step 2 - Come to the hackathon exhausted

This step really helps. Stay up for 12-18 hours before you begin your 24 hours of coding. Due to my current timezone constraints, I and one of my teammates were up working at 6am that day and sat down to the hackathon at 10pm.

Dare I claim this feat made us more productive? Hell no. As a matter of fact, by the time we had gone to get some rest at 6am, we thought we were close to 50% done with our app but after getting some sleep, ended up having to rewrite some of the application code. We also were nowhere near finished in terms of integrating the whole thing together and deploying. I’d guess we were 20% done by the 6am mark, a far shot from the 50%.

Step 3 - Solve a problem that doesn't exist

This one is the cherry on the cake. Instead of making sure your app solves a real world problem, create a problem out of thin air. We wanted to showcase our own technology and in our brainstorming session (see Step 1 above) we came up with two use cases. One solved a real problem (replacing call center agents). The other did not (onboarding new customers with voice) but looked cool. We picked the latter.

Step 4 - Don’t use the tech made available to you by event organizers

Obviously this step only applies to those hackathons where organizers want participants to make use of their technologies. This one is quite self explanatory isn’t it? If the organizers want you to use their tech, make a token gesture to it. A nod. This is a sure way to lose the hackathon.

We made a big mistake in picking our use case (Step 3). We picked the one which used exactly two methods in the US Bank APIs. The Brits might call this “taking the piss.” In contrast, the winner made use of what looked like 80% of the available methods.

Step 5 - Make it perfect!

Instead of building fast and shipping a rough but enticing product, focus on polishing the user experience. This one is all me. I was the team member responsible for the user-facing conversational AI interface and I spent A LOT of time reworking it, adjusting for more and more complex pathways and running test conversations over and over.

Step 6 - Forget about the time

You know how you are going to have to create a presentation and practice presenting, make sure your deploys are working and data is rendering properly and actually run through the full demo a half dozen times to make sure you can fit the entire thing in five minutes? Yeah, forget about that. Instead, focus on Step 5. When you have 20 minutes left before the submission deadline, throw together a half assed deck and submit your code one minute after the cut off. Then find out that you are the second presenter in line and presentations are moved up 1.5 hours and start… right now. If you follow this step, you are guaranteed to lose.

Step 7 - Ignore the presentation software

WebEx never works like it’s meant to. But that’s no reason for you to worry. Yes, don’t worry about it. When it’s time for you to present, just open the thing in Safari and when you find out that you can’t share your screen, shrug it off and start telling a bad joke while the desktop version downloads. This is sure to put the judges in a good mood and not to penalize you at all. And, yes, this also really happened.

What we built

Reading over this now, it looks like such a trainwreck. It’s making me ask - did we do anything right? I think we did.

We split up our areas of responsibility and stuck to them, yet helped each other out where needed. We stayed in a Discord voice channel and communicated the entire time we were online and working. We were civil to each other even as the deadline approached.

For our product, we built an automated voice user onboarding workflow. The user opens the app, enters their phone number, gets a call from an AI agent who asks them a series of questions, helps them to open their account, suggests they may want to create a virtual credit card and takes them through the card creation process. We also built (I think) a fairly cool app concept.

We used ReactJS, HTML5 on the front-end, ExpressJS, Node.js and MongoDB on the back-end, Websocket for communications, and consumed the bank’s card as a service API. We used Dasha AI Studio to create the conversational workflow and the Dasha SDK in our Node.js back-end to make the conversational workflow an integral part of the application. Here is me giving a demo of the app for some friends after we lost (if you like the conversational part, you can join our developer community where we build AI apps):

Final words

Congratulations. Now you know how to lose any hackathon. By extension, you now know what to avoid in order to increase your chances of winning a hackathon. Good luck and godspeed.

Make a small business owner happy by building an AI receptionist for them

Arthur Grishkevich — Tue, 31 Aug 2021 07:03:23 +0000

I don’t know about you but for me my experience with many a business begins with a phone call. Yes, I’m old-fashioned like that. I will glance through the website but if I don’t find what I’m after in under 30 seconds, I will call and ask my questions.

The best experience I get on the phone is a pickup on the second ring and a well-informed receptionist who is able to answer all my questions and (sometimes) schedule an appointment at a perfect (hopefully) time to get my beard trimmed. Okay, okay, you got me. Since COVID these appointments have been few and far between. Yet this is why a great experience (starting with the phone and ending with the coffee) is so important to me. These days - a cut is an experience in and of itself.

The worst experience I get on the phone… I won’t talk about. I’m sure you have your own worst experience to roll your eyes at.

What is the best virtual receptionist for a small business?

Not every small business, especially today, has the manpower for a full-time receptionist. As a matter of fact, due to a perfect storm of 2020, as many as 51% of U.S. small businesses report that they are understaffed.

If you are losing customers because you lack the staff to professionally attend to your phone, you have at least a few options. The most expensive one is hiring a new receptionist. The others concern virtual receptionists. Here you have two choices - you can hire an answering agency and get the help of a human online receptionist. Or you can set up a human-like AI digital receptionist to answer your phones and… you guessed it, delight your customers.

Pros and cons of a human phone answering service:

Pros

Flexible on the phone
Sound human
Can chat about the weather

Cons

Disinterested in your business
May lack access to your latest schedules/calendars
May speak with an accent
Any change in your service has to be communicated to management, in hopes it gets to the agents in time
While cheaper than hiring internally, can be pricy

When considering a human answering service, bear in mind that the agents are generally overworked and underpaid and highly disinterested in the service they are providing. There is a reason that the call center industry attrition rate hangs around the 120% per year mark.

Pros and cons of an AI phone answering service*:

Pros

Never has a bad day, always as interested and excited, as the minute you launched it
Actually sounds like a human and understands your customers like a human would
Through integrations has direct access to your calendars and CRM
Any changes to the script can be made in minutes
Always on and always available (even at 4:20am)
Very inexpensive
Can transfer to a live person, if needed

_Cons _

It will only respond and interact with the customer on pre-programmed pathways
At the end of the day it is limited by its programming and interactions
It is not a human

** This section is referring to Dasha AI phone answering app, because our tech is the only one we feel we know enough about to speak of. *

How to set up your AI phone answering service using Dasha AI

So you are thinking about an AI digital receptionist to answer phone calls for you. Companies already use Dasha AI to automate their inbound customer service conversations, including with AI answering services. The cool thing about our tech is you can start testing it and using it a low volume with no contracts or payments.

If you are not a programmer, this section may look daunting at first. I understand because I, too, am not a software developer, but a marketer. Yet I found myself writing AI apps with Dasha in under two hours. The language syntax is self-explanatory and the entire low-code studio is designed in such a way, as to let any citizen developer* use it with minimal difficulties.

** A citizen developer is any person who uses low-code/no-code development environments to create simple applications that directly solve for business needs, without resorting to the help of a professional software developer *

Here are the steps that we will go through:

Install Dasha Studio and load an app
Modify the app
Test the app

Installing Dasha Studio and loading a pre-built AI virtual receptionist app

Head over to https://nodejs.org/en/download/ and download and install the latest version of Node.js. Node.js is one of the world’s most common JavaScript frameworks. You won’t need to do anything with it but it will need to be installed on your machine for Dasha Studio to run its code.

Now go to https://code.visualstudio.com and download the latest version of Visual Studio Code for your machine.

Finally, go to http://community.dasha.ai and join Dasha’s developer community. A team member will reach out to you and give you instructions on how to install Dasha Studio, as well as receive your API key. We are issuing API keys manually for now, as we are in closed beta, and want to be sure each new developer (or citizen developer) has access to our Customer Success engineering team to answer any questions they may have.

Click through to the Dasha Code Sample repository on GitHub. You are looking for the SMB receptionist sample app: https://github.com/dasha-samples/dasha-smb-receptionist-demo

Click on the green “download Code” button and select “Download Zip”, as illustrated below.

Unzip the archive into a folder. Now, open your Visual Studio Code and click File >> Open >> your folder.

Voila, you have opened the Dasha SMB Receptionist conversational AI app. Now, make sure that you have Dasha Studio extension installed in your Visual Studio Code. Navigate to extensions on the left side bar, type in Dasha Studio, click on Dasha Studio 1.2.3 and hit the Install button. (since I already have it installed, my button says “disable”).

Now, turn on your terminal. The Terminal (sometimes referred to as the command line or console), lets you run tasks and commands without using a graphical user interface (GUI). You will use your terminal to test Dasha apps.

Perfect, now you’re all set and we get to the fun part.

In the terminal type in:
npm i -g "@dasha.ai/cli"
This will install the Dasha CLI (command-line interface). if you are on MacOS, you may need to preface the command with sudo - this will let your machine know to run the command, as top-level administrator user with full access rights. The full command will be sudo npm i -g "@dasha.ai/cli" and once you run it, will ask for your password. This is the password you use to log into your machine.

Perfect. The Command line interface is installed and initiated. Now type in the command npm i.

You’re all set. Now let’s figure out how the whole thing works. I promise - it’s not too complex.

Understanding the DashaScript code and making changes to the AI virtual receptionist app

First - click on > app in the left-hand menu and doubleclick on main.dsl and intents.json. These two are the most important files you will work with. Main.dsl is literally the actual conversion script. Intents.json lets you train the neural network on which responses signify which

Now, if you click on main.dsl, you will see a little icon off to the right that looks like a dialogue pathway. Click that. Now you should see this:

This map is a visualized dialogue pathway of the AI receptionist app. Here we only see the high-level nodes. To get into the nitty gritty of their behavior, we need to look at the code in main.dsl. Do refer back to the map, as you study the application code in main.dsl to help you better understand the flow.

Let me help you to understand what is happening in the code.

Lines 7-16

start node root
{
   do
   {
       #connectSafe($phone);
       #waitForSpeech(1000);
       #sayText("Church's Barbershop and Sodapop! How can I help you?");
       wait *;
   }
}

This is the root node, the first node. This is where the conversation begins. When the connection is safely established to the phone number specified, the AI receptionist waits for 1000 milliseconds. If it hears speech within 1000ms, it responds with "Church's Barbershop and Sodapop! How can I help you?” If it hears silence on the other end of the line, after 1000 ms (1 second), it states the same greeting. Then it waits for a response.

This is a very straightforward sample app and the AI is really expecting a single type of response back - the user wants to come in for a hair appointment.

Let’s navigate over to intents.json file to understand what types of interactions our AI is prepared for.

There are two major parts to this file:

"includes": {
}

Refer to phrases that elicit a response in the AI.

"excludes": {
}

Refer to phrases that the AI ignores.

We have the following intents in the file:

   "schedule_haircut"
   "cancel_appt"
   "bye"
   "monday"
   "tuesday”
   "wednesday"
   "thursday"
   "friday"
   "saturday"
   "sunday"

As you can guess - the intent cancel_appt tells the phone answering software that the customer wants to cancel their appointment, bye is the intent that tells the AI that the customer wants to end the conversation, the days of the week tell the AI when the user wants to come in and schedule_haircut tells the AI phon answering app that the customer wants to schedule a haircut.

Let’s look at that last one to understand how the neural network sorting intent is programmed. You, as the user, need to specify a few variations of the phrase that the customer might use in conveying their intentions to the AI. In this case, we have specified six ways of saying the same thing. This is most of the time enough data to train the neural network to recognize a variety of variations in which the customer might go about requesting the same thing.

"schedule_haircut": [
     "I need a haircut",
     "I want my hair cut",
     "schedule haircut",
     "can I have a haircut",
     "schedule an appointment",
        "haircut"
   ],

Let’s try and add a new intent to the file. The AI virtual receptionist introduced itself as “Church’s barber and soda fountain.” How about we ask what sodapop is available on tap.

To do this we will need to copy one of the existing intents and paste it right below. Then we need to change the name of the intent to soda_on_tap and add a few definitions of the intent for the neural network to train itself.

Here is the resulting code:

     "soda_on_tap": [
     "what soda do you have?",
     "what sodas do you have on tap?",
     "can I get a soda?",
     "what about soda",
     "soda?"
   ],

Now hit Control+S or Cmd+S to save the file. (Your Visual Studio Code likely has auto save features, however, we want to be on the safe side.

Well done - you have created your first intents. In a bit, you will instruct Dasha AI Platform to train a neural network to recognize them. How cool is that?

Anyway, now we need to use these intents in the course of the conversation. Our conversation structure (the script) is kept in the main.dsl file. Click it now.

You already met node root (lines 7-16). Now if you look at lines 18-31, you see digression _schedule_haircut _

As you can probably tell, this piece of code is called upon when the customer wants to schedule a haircut. Yet, you may have noticed it is called a “digression” and not a “node” What is the difference between a Digression and a Node? A Digression is a node that can be called up by the customer at any point in the conversation. Sort of like, when you’re speaking with your friend and at any point in the conversion, irrespective of what you’re talking about, you could say “oh by the way, how is the weather where you are?” and your friend will understand the question and respond. By the same token, a Digression prepares Dasha AI to answer a given question at any point in the conversation.

This is a very useful function for our purposes. As we saw when we looked at intents.json the app is now trained to answer three requests - scheduling a haircut, cancelling an appointment or ending the conversation. However, with adding a new intent soda_on_tap we need to add a new digression, to make use of the intent.

To do this we need to copy lines 18-31 and paste them into the file. Right below, at line 32 is fine. Great. Now, let’s go through the code line by line.

digression schedule_haircut
{
}

This line specifies that the code that follows within the curly brackets is a digression and names the digression, in this case schedule_haircut let’s change that name to soda_on_tap since this is what we called our intent.

conditions {on #messageHasIntent("soda_on_tap");}
   do

Here we instruct the AI receptionist app to do a specific action when it recognizes a specific intent. In other words, if the AI app recognizes an intent, this digression is launched and the action is performed.
Since the intent we created earlier is called soda_on_tap, this is what we replace the intent name with

note: digression name and intent name can be different. I’m using the same here to make it easier on us

do
   {
       #sayText("You want to get a haircut, did I hear you correctly?");
       wait *;
   }

Here, we instruct the AI app what action to take. In this case - say a specific text and wait for the customer to respond. Let’s tell the customer about our soda options and ask if they want a haircut.

We’ve got Dr. Pepper, Coke Zero, Raspberry Sprite and a mystery flavor. You’re welcome to unlimited soda. Would you like to book your haircut appointment now? You can use this text, or write your own version.

transitions
   {
       schedule_haircut_day: goto schedule_haircut_day on #messageHasSentiment("positive");
       this_is_barbershop: goto this_is_barbershop on #messageHasSentiment("negative");
   }

We had the AI virtual receptionist ask the customer if they want to go ahead and book their haircut appointment now. In this block of code here, we instruct the AI app what to do if the customer says “yes” or “no”. Note that we did not have an intent for “yes” or “no” in the intents.json file. That is because positive and negative sentiment is recognized at the native level by the platform. To call a upon it, the function #messageHasSentiment("sentiment"); is used. In this case, if the sentiment is positive, the AI app goes to node schedule_haircut_day to ask the customer what day they want to come in. If the sentiment is negative, the AI app goes to can_help_then, a node that asks the customer how they can be helped.
We will not change anything in this code, because it does exactly what we want it to do.

Here is the code we just created.

digression soda_on_tap
{
   conditions {on #messageHasIntent("soda_on_tap");}
   do
   {
       #sayText("We’ve got Dr. Pepper, Coke Zero, Raspberry Sprite and a mystery flavor. As you get barbered, you’re welcome to unlimited soda. Want to book your haircut now? And before you ask - we do have a restroom.");
       wait *;
   }
   transitions
   {
       schedule_haircut_day: goto schedule_haircut_day on #messageHasSentiment("positive");
       this_is_barbershop: goto can_help_then on #messageHasSentiment("negative");
   }
}

Congratulations - you have successfully created your first Dasha AI app - a virtual receptionist.

Talking to the AI phone answering software

Now, you’ll want to talk to the the Dasha AI app you have just created. To speak to the AI, type into the terminal

npm start phone_number

Where phone_number is your number starting with country code. For example, for mine it looks like this:

npm start 19733588889

As you are building and testing, you may want to just chat to the AI, to save time. To do that, type into the terminal:

npm start chat

Parting words

As a non-developer, I tried my best to make this tutorial as easy to understand as possible. If you want to get deeper knowledge of building with Dasha ai - check out our documentation docs.dasha.ai or keep an eye peeled for content here on the blog or in our Twitter.

If you found this tutorial helpful - let me know: arthur@dasha.ai. If you didn’t find it helpful - all the more reason to let me know.

Good luck and godspeed.

Teach an AI to call any inbound lead instantly and qualify them

Arthur Grishkevich — Fri, 27 Aug 2021 12:52:25 +0000

Business ops already automate the emails going out to the newly generated leads, why not automate the calls, if you can do it at a level indistinguishable from a human being? Also, it's a fun build.

Read on for:

How to prepare to build your app
How to build your app
How to test your app

Designing your inbound lead qualification conversational AI app

Start off by mapping your conversational app. Here are detailed instructions on how to go about it. Here is the file that was the outcome of my conversation mapping for this super simple qualification script.

The basis of the script is as follows - we’re a company in invoicing software. We get an inbound lead, we call them back, ask if now is a good time to talk, ask 3 qualifying questions, then set a day and time for a call. There are a few digressions (tangents) at play here, to address things such as the prospect asking what the call is about or for a reminder of who called them.

Here is a copy of the file I ended up with as a result of the mapping exercise (instructions above). Do copy to your Google Drive or download as Excel file to make use of it.

The cool thing about the conversational map, is you can go back to it to expand upon the basiс structure of the conversation. And make no mistake, the app I built here (and you will too), in just a couple of hours is quite basic.

How to qualify inbound leads with conversational AI: build your first app

Is this your first rodeo? Then kick it off by reading Angelika’s getting started building conversational apps with Dasha conversational AI guide here.

Now, kick this off by cloning this (simple app)[https://github.com/dasha-samples/dasha-first-app] from our code sample GitHub repo. You can clone directly from your terminal or download, unzip and open the folder in Visual Studio Code.

Now, open up main.dsl and intents.json. These are the two main files that we will be working with in the course of this tutorial.

Let’s get to work by building the key workflow in main.dsl. The ideal workflow is - get confirmation that lead can talk now, ask 3 qualifying questions and book a time to meet.

Here is the workflow in the conversation map:

Take a look at Variables column. Since in the course of this conversation we are asking questions of the user and then storing their responses, we need to use some variables to store the data. We need to start off by initializing these variables.

Open up main.dsl in Visual Studio Code. We need to start off by declaring and initializing the variables.

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

   software: {[x:string]:string;}[]?=null;
   invoices: {[x:string]:string;}[]?=null;
   lead_source: {[x:string]:string;}[]?=null;
   calltime: {[x:string]:string;}[]?=null;
   callday: {[x:string]:string;}[]?=null;
   callback: {[x:string]:string;}[]?=null;

   visitedNodeTime: boolean = false;
   visitedNodeQuestion1: boolean = false;
}

We’ve got three sets of variables here.

Set 1 - input variables are what you start the conversation off with. In this case, we presume that there is a phone number of the person who left the website form request and their name. You can input these variables as you launch your test call in the Terminal.

Set 2 - variables we will use for storing data collected from the user in the course of the conversation. Note that we are initializing them as arrays because that is the type of data which is collected by the named entity recognition function.

Set 3 - “visited” variables are used to denote a node which has previously been visited by the user. We will use this variable to let the Dasha Platform know to use a different phrase when coming back to the node versus the one we’ve already used.

Now that we have got the variables, let’s begin the conversation.

We start the conversation off with node root - the root node (duh).

start node root
{
   do
   {
       #preparePhrase("greeting", {name:$name});
       #connectSafe($phone);
       // Wait for 5 seconds or until speech is detected.
       #waitForSpeech(5000);
       #sayText("Hi " + $name + " this is Dasha with Acme Software. I just received a request for a demo from you. Do you have two minutes now?");
       wait*;
   }
   transitions
   {
       question_1: goto question_1 on #messageHasIntent("yes");
       call_back: goto call_back on #messageHasIntent("no");
   }
}

Pretty self explanatory. Dasha connects to the user’s phone, waits for 5 seconds, then speaks. Or speaks after it hears the user’s greeting. Dasha asks whether the user has a minute now, and either progresses on our perfect world flow or goes off into the call back node. For now, let’s get through the perfect world flow which means we are successfully qualifying inbound leads.

Node 2 is node question_1. Right, this is the first question we ask.

node question_1
{
   do
   {
       if ($visitedNodeQuestion1==false) #sayText("Great! I will book you in for a discovery call with an account executive but first, I'll have to ask you a couple of questions . Question 1 - are you using any other software at the moment that solve for invoicing?");
       else #sayText("Going back to the question 1 - are you using any other software at the moment that solve for invoicing?");
       set $visitedNodeQuestion1=true;
       wait *;
   wait*;
   }
   transitions
   {
       question_1_a: goto question_1_a on #messageHasIntent("yes");
       question_2: goto question_2 on #messageHasIntent("no");
   }
}

Note that we are making use of the $visitedNodeQuestion1 variable here. Good reason for that - in the course of the conversation you may have to come back to this node, in which case you will want to say something different, not the same thing that you have said previously, amirite? Otherwise it won’t sound realistically human to your user.

Pro tip: there is a better way to solve this with the **phrasemap, for the purposes of this tutorial I am using #sayText - a function of main.dsl. I will do a write up on using phrasemap later.

If the user says that they are presently using invoicing software, we are sent to node question_1_a.

node question_1_a
{
   do
   {
       #sayText("Great and what software are you using?");
       wait *;
   }
   transitions
   {
      question_2: goto question_2 on #messageHasData("software");
   }
   onexit
   {
       question_2: do {
       set $software = #messageGetData("software", { value: true })[0]?.value??"";
      }
   }
}

Here you instruct Dasha to ask a question and, upon hearing a response which fits to the instructions provided to it in our data.json file, to go to node question_2.

What instructions are these? These are the named entity recognition training data. Let’s take a look.

{
 "version": "v2",
“entities”: 
"software":
   {
     "open_set": true,
     "values": [
       {
         "value": "Xero",
         "synonyms": ["Xero"]
       },
       {
         "value": "Quickbooks",
         "synonyms": ["Quickbooks"]
       },
       {
         "value": "Quicken",
         "synonyms": ["Quicken"]
       },
       {
         "value": "Stripe",
         "synonyms": ["Stripe"]
       },
       {
         "value": "Square",
         "synonyms": ["Square"]
       }
     ],
     "includes": [
       "We use (Quicken)[software]",
       "We mainly use (Stripe)[software]",
       "Just (Quickbooks)[software]",
       "(Square)[software]",
       "(Xero)[software]",
       "(Stripe)[software]",
       "(Quickbooks)[software]",
       "(Square)[software]",
       "(Xero)[software]"
     ]
   },

With this code snippet we provide a set of training data to train Dasha’s Named Entity neural networks in recognizing when the user mentions a software that they are using. Please note that the open_set parameter is set as true this means that if the user names a software which we did not list as part of the training data, it will still be recognized as software and written to our variable $software as per instructions in node question_1_a in main.dsl above. Dasha conversational AI API provides the AI as a service of the platform.

To learn more about Named Entity Recognition and Intent recognition, take a look at Ilya’s posts here and here.

With these code samples you are equipped to write the nodes for node question_2, node question_3, and even. Note that in node time you will need to collect two variables - callday and time. To collect the time, we will use a native function of Dasha called numberword. Here is what it will look like: set $calltime = #messageGetData("numberword", { value: true })[0]?.value??"";

If you have trouble putting these together, here is the application source code to help you along.

Great. Now that we’ve collected all the data, let’s make sure that we got the call time correctly.

node time_confirm
{
   do
   {
       #sayText("Perfect. Let's confirm, you can take a call on " + $callday + " at " +$calltime + " is that right?");
       wait *;
   }
    transitions
   {
       correct: goto success on #messageHasIntent("yes");
       incorrect: goto time on #messageHasIntent("no");
   }
}

Here Dasha will read out the results to the user. If the user confirms, we got to node success, if the user does not confirm, we go back to node time.

Success is pretty straightforward (in the context of DashaScript). I’ll still list it here so that you can reuse it to close the conversation in other points (e.g. node bye).

node success
{
   do
   {
       #sayText("Perfect. You will have an invite later today. Thank you so much! We'll speak soon! Bye!");
       exit;
   }
}

Alright. So we got through the perfect world workflow and your conversational AI app is midway done.

Now, let’s address the workflow where the user says they can’t talk right now and asks to call them back. We need to instruct Dasha to ask when to call the user back and to collect the user’s response.

Here is how this code will look like in DSL:

node call_back
{
   do
   {
       #sayText("No worries, when may we call you back?");
       wait *;
   }
   transitions
   {
      callback_confirm: goto callback_confirm on #messageHasData("callback");
   }
   onexit
   {
       callback_confirm: do
       {
       set $callback = #messageGetData("callback", { value: true })[0]?.value??"";
       }
   }
}

Here are the training data I put together for the purpose of identifying callback:

     "callback":
     {
       "open_set": false,
       "values": [
         {
           "value": "tomorrow",
           "synonyms": ["tomorrow", "next day"]
         },
         {
           "value": "tomorrow at the same time",
           "synonyms": ["same time tomorrow", "tomorrow same time"]
         },
         {
           "value": "the day after tomorrow",
           "synonyms": ["In two days", "Day after tomorrow"]
         },
         {
           "value": "in an hour",
           "synonyms": ["in an hour", "in two hours"]
         },
         {
           "value": "later today",
           "synonyms": ["later today"]
         }
       ],
      "includes": [
         "call me back at (tomorrow)[callback]",
         "(tomorrow)[callback]",
         "(the day after tomorrow)[callback]",
         "(tomorrow)[callback] is fine"
       ],

I will let you write the confirmation node on your own - you can reuse some of the code we used for node time_confirm and success earlier.

Use digressions to add human-like realism to the conversation

Digressions. You should have noticed them in the conversation map:

The purpose of digressions is to account for the unpredictable human behavior. At any point in time a person you are talking to might ask about the weather or a million other things. Digressions are how you prepare your AI app to handle these seemingly random requests. More on digressions you can find in this post. The cool thing is - you can predict some or maybe even most digressions but not all of them. You get to find out what all the ones you did not predict are in live conversations that your AI app has with real human beings, once you begin training it. More on that later.

Digressions are activated by intents. Just like you defined named entities in data.json, you define intents in the same file.

 "intents":
{
   "who_call":
   {
     "includes": [
       "who is this again?",
       "who is calling?",
       "what is this about?",
       "who are you?"
     ]
     },
   "what_do": {
     "includes": [
       "what does your company do?",
       "what company is this again?",
       "what do you do?"
     ]
}

And so on.

Here is how the digressions for these intents look like:

digression who_call
{
   conditions {on #messageHasIntent("who_call");}
   do
   {
       #sayText("This is Dasha with Acme Software. You reached out to us a few minutes ago on our website.");
       return;
   }
}

digression what_do
{
   conditions {on #messageHasIntent("what_do");}
   do
   {
       #sayText("Acme Software provides invoicing software as a service for SMB. ");
       return;
   }
}

What happens here is simple - the user calls up a digression at any place in the conversation, Dasha responds, and goes back to the node from which the digression was called. Equipped with this code, you can construct the other digressions as well.

And really that’s it.

launching and testing your inbound lead qualification conversational AI app

Once you get through putting together the rest of the app, you will end up with code that is similar to what you’ll find in this repository.

To run a test conversation, type into your terminal

npm i

And then

npm start chat Jane where Jane is any name you want to give your user. This will launch a text chat. To launch a voice call, type:

npm start 12223334455 Jane where 12223334455 is any phone number in the international format without the + symbol.

Congats. You’ve got the base from which you can build your super fly inbound lead qualification app. In the next installment we’ll talk about connecting this application to external services to initiate calls and to store collected data.

You can access the full application source code to get you started.

Stay tuned.

Take an hour to build a deeply conversational chatbot for Intercom

Arthur Grishkevich — Fri, 27 Aug 2021 03:59:20 +0000

Co-authored by Aleksandr Aleksashin

Intercom lets businesses communicate with customers or prospective customers in-app or on-website. Intercom is used to initiate support conversations, as well as sales conversations. On the business side, Intercom is generally manned by an employee, although it lets users (businesses) create simple bots.

It’s a great technology. I think it can be made greater yet if one could automate the customer conversations that happen through it at a human level.

How Intercom does bots today

Intercom offers chatbot building functionality out of the box with a drag-and-drop, no code interface. These are rather simplistic command-response/multiple choice chat bots.

Here is what a conversation with an Intercom bot might look like today:

You might ask “what’s wrong with multiple choices”. They are great for taking the cream off the top. However, if a user’s request does not fit within the bounds of the commands served up by the bot, the user will quickly become frustrated and seek to speak with a human agent. The problem with human agents is that they are often unavailable or take a while to respond.

Importantly, according to Intercom’s own research only 15% of customers would prefer talking to a bot over a human agent.

So we got to thinking. What if we can deploy a conversational AI app that can communicate through Intercom and provide a truly human-like experience to the customer? How would customers feel about a thing like that? How would it impact their perception of the brand?

Also, we just think it’s a cool little project. Here is the repository with the source code for your reference.

Dasha AI

Dasha conversational AI platform is a suite of developer tools. Using Dasha Studio, SDK and Cloud Platform, any developer can design, build, train and deploy fully human-like, deeply conversational AI applications. DashaScript is a derivative of TypeScript, the SDK is Node.js. No ML or AI experience is required. It’s a perfect platform to create a human-like chatbot for Intercom.

Challenges to overcome

Here is what we need to make happen for this thing to start talking to customers:

Integrate a Dasha AI app with Intercom
Design and develop the Dasha conversational AI app
Deploy and test the app

In our journey we will create a simple conversational bot for customer support via Dasha platform. In terms of the conversational app functionality - we will keep it exceedingly simple for the purposes of this tutorial, yet will illustrate all the features of Dasha platform that you can use to create fully human-like conversational applications.

Before we go any further, let’s make sure that you are equipped with the tools to use Dasha conversational AI. Firstly, you’ll want to head over to our developer community, where you will get instructions on how to get your API key. Secondly, download and install the Dasha Studio extension for Visual Studio Code. Thirdly, you’ll want to install the Dasha CLI

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

. For more on our command line interface, read this post.

And finally, you want to clone and open a copy of the source code for the app we are building togay, so that you can follow along the instructions in the tutorial.

Integration

Our Dasha AI app has to be able to do the following things through Intercom:

Be notified of newly-initiated conversations that have yet to be responded to by a human agent
Read the content of the customer’s communication.
Notify the customer that their message(s) have been read.
Decipher the customer’s intent and select an appropriate response.
Respond to the customer in the conversation.

To integrate, we will look at intercom API and search for a library that can perform the following actions:

Search conversation by parameters;
Reply to a specific conversation;
Create/open/close/reopen conversations;
Read messages from any given conversation.

Since clients for Dasha SDK are currently written only in JavaScript (TypeScript), we need a JavaScript library for Intercom. Intercom has a Node.js SDK in their API references (https://github.com/intercom/intercom-node). Unfortunately, this library cannot create new conversations.

Step one. Getting the access token for Intercom

First off we need to get acquainted with the Intercom API.

As we can see, all requests must have an access token. To get your access token, go here and to settings->developers->developer-hub and click “New app” to create a new application.

Once you create your application, head over to App > Configure > Authentication to find your access token.

Equipped with the access token, we can start sending requests to the Intercom rest API. For our HTTP client we will use Axios.

Step two. Apply integration to your code

We are using TypeScript to write our app. Open up main.ts. First, we need to import the intercom integration library.

import { IntercomClient } from "./src/intercomClient";

Then, we need to create an instance of a Dasha application and an instance of an intercom client. On the creation of the Intercom client instance we should pass the access token and url for Intercom as arguments of the function.

We are creating both within the function main.

 const application = await dasha.deploy("./graph", { groupName: "Default" });
 const intercom = await IntercomClient.create("https://api.intercom.io", {
   accessToken: process.env.INTERCOM_APIKEY!,
 });

Next, we instruct the Dasha application how and where to execute the conversation and to let us know all is going well:

try {
   application.connectionProvider = async (conv) =>
     dasha.chat.connect(await dasha.chat.createConsoleChat());
   application.setExternal("send_report_on_manager", (args, conv) => {
     console.log({ set_args: args, conversation: conv });
     return "ok";
   });

Then we need to connect the Intercom client with the Dasha SDK application:

   await intercom.simpleConnectToDashaApp(application);

And set a logger to log the actions.

 intercom.setLogger(console);

Details of Intercom integration library

Function for connecting Dasha application to Intercom

We use the “simpleConnectToDashaApp” function in our code. Let’s take a look at its implementation. Go to .src/intercomClient.ts, line 412.

Look at the signature of this method. This method has one argument - an instance of platform application.

public async simpleConnectToDashaApp(
   application: dasha.Application<
     Record<string, unknown>,
     Record<string, unknown>
   >
 ): Promise<void>

In the first part of the function below we prepare to interact with the integration:

   if (this.isSimpleUsed) {
     return;
   }
   this.isSimpleUsed = true;
   const closeTrigger = false;
   const conversations = new Map<string, IntercomConversation>();

In the next part of the function, we set up a callback to become active on certain events in the application.
On the "starting" event, it is necessary to check that the incoming conversation has not been started yet. After this you need to execute the function for connecting intercom and application chats, and accept this job. Let’s check out the implementation of this callback:

     const dashaChat = await dasha.chat.createChat();
     const chat = await this.runChatInConversation(
       conversations.get(conv.input.conversationId as string)!.id,
       conversations.get(conv.input.conversationId as string)?.open ?? false,
       {
         closeAfter: {
           messageOnClose:
             "Conversation was closed because dialog was finished",
         },
         periodReading: 100,
         startOptions: {
           skipLastMessage: !conversations.get(
             conv.input.conversationId as string
           )?.open,
         },
       }
     );

Third step is to connect the intercom client to Dasha application chat.

     chat.run(dashaChat).catch(this._logger?.error);
     return dasha.chat.connect(dashaChat);
   };

   application.queue.on("ready", async (id, conv) => {
     this._logger?.info(`Got new starting conversation ('${id}').`);

     // Checking that the conversation belongs to this intercom client instance
     if (!conversations.has(id)) {
       this._logger?.info(
         `Try starting conversation from not this instance of intercom client new conversation ('${id}'). ` +
           `Conversation was been rejected`
       );
       return;
     }
     this._logger?.info(`Prepare intercom conversation for chat ('${id}').`);

     this._logger?.info(
       `Connecting to dasha sdk chat protocol for conversation ('${id}').`
     );
     conv.input = {
       conversationId: id,
       continueConversation: conversations.get(id)?.open,
     };

Fourth step is to reply to Dasha SDK that the conversation can be started.

     conv.on("transcription", async (transcription) => {
       if (this.onTransctiption) {
         await this.onTransctiption(conversations.get(id)!, transcription);
       }
     });
     this._logger?.info(`Conversation was been accepted ('${id}').`);

The events "failed", "completed", "timeOut" have the same implementation up to the call of the corresponding functions. Look at the implementation for conversation result event:

       const result = await conv.execute();
       try {
         this._logger?.info(`Conversation finish ('${id}').`);
         if (this.onCompletedJob) {
           await this.onCompletedJob(conversations.get(id)!, result);
         }
       } finally {
         conversations.delete(id);
       }
     }

Similarly you will see functionality for rejected, timed out and failed conversations. At line 523 we begin a loop where we search for new conversations.

   await this.watchConversations(
     async (conv) => {
       try {
         // Checking that a conversation is already in progress
         if (conversations.has(conv.id)) {
           return;
         }

         this._logger?.info(`Got new conversation ('${conv.id}')`);
         conversations.set(conv.id, conv);
         const date = Date.now();
         const notBefore = new Date(date);
         const notAfter = new Date(date + 3600 * 1000);
         await application.queue.push(conv.id);
         this._logger?.info(
           `Conversation ('${conv.id}') was enqueued into dasha sdk`
         );
       } catch {
         this._logger?.error(
           `Could not enqueue conversation ('${conv.id}') into dasha sdk`
         );
       }
     },
     () => {
       return closeTrigger;
     }
   );
   this.isSimpleUsed = false;
 }

See how we change the state of the instance to start a new simple conversation with this.isSimpleUsed = false;.

The function that lets us search ouyt a new conversation

We use the “watchConversations” function in our code. Let’s see their implementation. Write simple checking conversations to have a new one or a not replied one.

 public async watchConversations(
   // We need callback to start work with conversation
   callback: (conv: IntercomConversation) => Promise<void>,
   // Hook, for end watching conversations
   stopTrigger: () => boolean
 ): Promise<void> {
   // Search over all conversation and find only those which have not replied message
   while (!stopTrigger()) {
     // take first 20 conversation from first page in listing method
     let conversation = await this.getConversation(20, 1);
     // skip all conversation which was been replied by admin
     for (const conv of conversation.conversations.filter(
       (x) =>
         x.statistics.last_contact_reply_at > x.statistics.last_admin_reply_at
     )) {
       // send new potential conversation for working
       callback(conv);
     }
     // now we go over all other conversation and do same action like above
     while (conversation.pages.total_pages >= conversation.pages.page) {
       conversation = await this.getConversation(
         20,
         conversation.pages.page + 1
       );

       for (const conv of conversation.conversations.filter(
         (x) =>
           x.statistics.last_contact_reply_at >
           x.statistics.last_admin_reply_at
       )) {
         callback(conv);
       }
     }
     // timeout in order not to spam requests
     await new Promise((resolve, reject) => setTimeout(resolve, 1000));
   }
 }

Now we can work with applications and conversations, but we cannot start conversations.

Function for start chatting

These methods prepare Intercom for conversation and to start a chat. This function has two logical parts. In part one, we prepare the client for the conversation:

 public async runChatInConversation(
   conversationId: string,
   // is the conversation open at the moment
   conversationWasOpen: boolean,
   options: {
     // if define than conversation after and need close
     // else conversation does not closing
     closeAfter?: {
       messageOnClose: string;
     };
     // if nod defined than used first available user message in conversation
     // else use last available user message in conversation
     startOptions?: {
       // ignore last message, and awaiting new message
       skipLastMessage: boolean;
     };
     // period of receiving new messages from the api intercom
     periodReading: number;
   }
 ): Promise<IIntercomChat> {
   // Create client for each conversation
   const intercomConversationClient = new IntercomConversationClient(
     this,
     conversationId,
     options.startOptions === undefined
       ? 0
       : await this.getLastTime(
           conversationId,
           options.startOptions.skipLastMessage
         ),
     options.periodReading
   );

In next part we use a hook to start the conversation:

   return {
     // hook which was triggered when conversation was started on the dasha platform.
     run: async (chatChannel: dasha.chat.Chat): Promise<void> => {
       try {
         // open conversation if it`s needed
         if (!conversationWasOpen) {
           await this.openConversation(conversationId);
         }

         // run conversation chat
         await intercomConversationClient.run(chatChannel);
       } finally {
         // close conversation if it`s need
         if (options.closeAfter !== undefined) {
           try {
             await this.closeConversation(
               conversationId,
               options.closeAfter.messageOnClose
             );
           } catch (e) {
             this._logger?.error(JSON.stringify(e));
           }
         }
       }
     },
   };
 }

Implementing a class to chat within a single conversation.

This is the magic class which lets the Dasha conversational AI chat with Intercom. Go to intercomConversationClient.ts.

Let’s take a look at the construction of this class.

export class IntercomConversationClient implements IIntercomChat {
 // Id of conversation on Intercom.
 public readonly conversationId: string;
 // Used Intercom client.
 private readonly client: IIntercomClient;
 // Delay for reading new messages from Intercom conversation.
 private readonly delayReading: number;
 // This property indicate that this client in a close state.
 private close = false;
 //Creation time of the last message we read from Intercom conversation.
 private lastTime = 0;

 public constructor(client: IIntercomClient, conversationId: string, lastTime: number, delayReading: number) {
   this.client = client;
   this.conversationId = conversationId;
   this.lastTime = lastTime;
   this.delayReading = delayReading;
 }

This class should have two functions. The first of them needs to run and control the conversation flow:

 public async run(chatChannel: dasha.chat.Chat): Promise<void> {
   // listen message from dasha sdk application and write into intercom
   chatChannel.on("text",async(text)=>{
     await this.client.reply(this.conversationId, text);
   });
   chatChannel.on("close",()=>{
     this.close = true;
   });
   chatChannel.on("error",(error)=>{
     this.close = true;
     console.warn("chat error:", error);
   });
   // listen message from intercom and write into dasha sdk chat channel
   await this.readConversation(chatChannel);
 }

The next function reads messages from the conversation and sends them to the Dasha application.

 private async readConversation(chatChannel: dasha.chat.Chat): Promise<void> {
   while (!this.close) {
     await new Promise((resolve, _) => setTimeout(resolve, this.delayReading));
     // read new messages in intercom conversation
     const obj = await this.client.readMessages(this.conversationId, this.lastTime);

     // mark conversation as read. This see user in intercom
     await this.client.markAsRead(this.conversationId);

     this.lastTime = obj.lastTime;
     // send new message from intercom into dasha sdk application
     for (const msg of obj.messages) {
       await chatChannel.sendText(msg);
     }
   }
 }
}

Quite simple.

The Dasha conversational AI app

On to the fun part. Let’s look at the conversational AI app that will interact with our Intercom customer/user.

You will need to open the following files:

.graph/main.dsl is the DashaScript file which you use to construct the conversational pathway that Dasha is to take. Here you can make your conversation as absolutely complex or simple as you wish. For the purposes of this tutorial we will opt for simple.
data.json is the file where you store data that is used to train the neural networks to properly understand the customer’s/user’s intent.
phrasemap.json is where you store all the phrases to be used by Dasha AI in the context of the conversation. (tip: you can list phrases directly in main.dsl by using the #sayText() function. Using the phrase map for it is, however, the better way for scalable apps.)

We will be discussing the following concepts in this part of the tutorial:

Node is literally just that - a node in the conversation. It’s a point of interaction between the user and the AI. A node must always have another node or digression leading into it.
Digression is, in essence, a node that does not have to have anything lead into it. A digression can be called up by the user at any point in the conversation. Digressions are used to imitate the way a human might adapt when the person they are talking to suddenly throws them off on a tangent. Read this for a deeper dive on digressions.
Intent refers to the meaning behind the user/customer’s phrases. When you are speaking to someone you figure out the meaning of their words and phrases and sentences based on context, a variety of clues and previous experience. Right now Dasha AI interprets meaning solely from text (we are working on emotional analysis). Intents refer to the . The Dasha Cloud Platform has neural networks dedicated to training for user intents and to analysing said intents in the course of a conversation. Take a look here for more on intents.
Named entities are fields referring to names, place names, objects, etc. that you need Dasha AI to identify within the customer/user’s responses. Named entities are also processed by neural networks and you provide training data using data.json in a format similar to intent training data. For more on named entities you can read this piece from the leader of the team which constructed the neural networks.

Let’s look at main.dsl. We start by importing common functions. In the case of Dasha this means common digressions and ways of responding to them.

import "commonReactions/all.dsl";

Then we need to declare some variables for context:

context
{
   input conversationId: string;
   input continueConversation: boolean;
   last_message: string = "";
   can_say: boolean = false;
   output status: string?;
   output serviceStatus: string?;
}

We also need to declare an external function. This is a way for a DashaScript app to call out to an external application to send or receive data. In this case the app is main.ts and we are sending the customer’s phrase data which refers to a manager who led to a dissatisfied customer.

external function send_report_on_manager(report: string): unknown;

Let’s look at the first node - node root.

start node root
{
   do
   {
       #connectSafe("");
       if(!$continueConversation)
       {
           #say("greeting", repeatMode: "ignore");
           #say("how_can_i_help_you");
       }
       goto hub;
   }
   transitions
   {
       hub: goto hub;
   }
}

Here we connect to the chat instance if check if our conversation should be continued, as per the code we wrote previously in the integration. If we continue the conversation, we greet the customer and ask how they can be helped.

It is expected that in most cases the customer will state the problem with which they are calling.

Here is where digressions come in. Let’s say the customer says “I have a problem with my phone.” If you look at the intents.json, you will find a "problem_with_phone" intent on line 98:

    "problem_with_phone": {
        "includes": [
          "I can't seem to make a phone call",
          "I have a problem with my phone",
          "I'm afraid I broke my phone",
          "Phone problem"
            ],

If you scroll down to line 144 in main.dsl, you will see this digression:

digression problem_dig
{
   conditions
   {
       on #messageHasAnyIntent(["problem_with_phone", "problem_with_manager", "have_problem"]);
   }
   do
   {
       digression disable problem_dig;
       goto problem;
   }
   transitions
   {
       problem: goto problem;
   }
}

The digression comes into play when any of the intents "problem_with_phone", "problem_with_manager", "have_problem" are identified. If they are identified, the conversation goes to node problem.

There are a variety of exciting funcitons of DashaScript that you should learn about if you want to develop further on it. The best place to go is our documentation. You can also make your way through a detailed tutorial, such as this one.

Launching and testing the Intercom conversation

Now that you’ve got the integration built out and the app is developed as well, let’s launch a test convo.

To do this, type npm i in the terminal and then ’npm run build` and ’npm run start`. The app should now be deployed.

Now, you need to launch a test conversation with Dasha. It’s a two step process. Step 1 - head over to the Intercom Developer Hub > Your apps. Select your app and click on it. Your address bar will read something of this sort:

You want to copy the number after /apps - this is your Intercom application ID.

Now, copy and paste this line into your address bar https://app.intercom.com/a/apps/yourAppIDgoesHere/test-conversation and replace yourAppIDgoesHere with your application ID. I know, it’s complicated and, yes this is the solution recommended by Intercom.

Now, you will be able to send a message from the chat interface and get a reply from Dasha. In this way you can test any conversation that your users can have with Dasha.

Let me know if this was helpful in the comments or in our developer community .

How to run automated telephone conversations through a telephony vendor

Arthur Grishkevich — Thu, 26 Aug 2021 11:47:01 +0000

Why use your own telephony for your Dasha apps

The goal of any development is to deliver some type of business value. In the case of Dasha conversational AI apps, the business value that our customers pursue varies. Yet in over 95% of cases today, it is delivered through the telephone channel. In that sense, most of our customers in production use Dasha to automate some part of their telephone communications with customers.

Most of these companies have a telephony vendor. Connecting the Dasha application to their existing telephony means that Dasha can seamlessly transfer calls to a live agent, if such a need arises. It also means that Dasha can make phone calls from phone numbers reserved for this company, and answer inbound phone calls which are directed to the company phone number.

In this tutorial we will go over connecting Dasha for both inbound and outbound telephone communication using Voximplant.

How to use Dasha with a third party telephony vendor?

First, you need to know if your vendor supports SIP Trunk connections. Here is a simple decision tree flowchart to help you navigate:

To give you an idea of how the integration happens, read below for instructions to integrate Dasha with the telephony vendor Voximplant via a SIP Trunk connection.

Preparatory actions on the 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.

You’ll want to load up a Dasha conversational AI app. For the purposes of this tutorial, you may want to load up either the inbound tester app for inbound calls. Or the outbound tester app for outbound calls.

Setting things up on the side of Voximplant (telephony vendor)

Login to your Voximplant account or create an account if you don’t have one.
Create a Voximplant application.
Purchase a Voximplant phone number in the Numbers section of the control panel and attach it to the app. This number will be used as callerid.
Go to your applications, click on the app you had created. Click on Numbers > Available and "attach". This number will be used as callerid.

For Outbound calls:

Go to Scenarios > Create Scenario, name the Scenario and hit the “plus” sign. You will need to paste the code below in the scenario.

    const callerid = 'number_you_bought'
    VoxEngine.addEventListener(AppEvents.CallAlerting,(e) => {
        Logger.write('a call from ' + e.callerid);
    // an inbound SIP call from Dasha (the first call leg)
        const inc = e.call;
    // an outbound call to PSTN (the second call leg)
        const out = VoxEngine.callPSTN(e.destination, callerid);
        out.addEventListener(CallEvents.Connected, () => {
    // answering the call
            inc.answer();
        })
        // adding default event listeners to pass signaling information between two calls
        VoxEngine.easyProcess(out, inc);
    })

This scenario be run from the Dasha integration. On an incoming SIP call from Dasha, the phone number which we want to call is passed to the callPSTN method. This is how we connect two calls. Once the call is answered, Dasha will start the conversation. If you want to handle inbound calls to SIP, use your SIP URI as callerid and replace the callPSTN method with callSIP. If you are using SIP Registrations on your PBX, you need to create a SIP Registration and use it instead of the SIP URI.

Next,go to the Users section and create a new user. Remember the username and password, they will be used for Dasha's config in the next step.

Now, click on Routing in the left hand menu. Create a new rule (leave the pattern as default), and attach your scenario to this rule.

Now, Connect your sip trunk with Dasha's using this command:

dasha sip create-outbound --server <ip_or_dns_of_server:port> [--domain <domain_name>] [--ask-password] --account <accountName> --transport [tcp|udp] <config_name>

accountName is the username you created in the Voximplant panel;
ip_or_dns_of_server:port is the name of our Voximplant app;
config_name is the name of the config we’ll use in the next step.

For example:

dasha sip create-outbound --server exampleApp.exampleAcc.n4.voximplant.com --account exampleUsername --ask-password vox_outbound
password: enter_your_password_here

For Inbound calls:

Connect your sip trunk with Dasha's using this command:

dasha sip create-inbound --application-name <your_app_name> <config_name>

your_app_name is your Voximplant application name;
config_name is the name of the config we’ll use later.

For example:

dasha sip create-inbound --application-name exampleApp vox_inbound

This command will give us a Dasha’s SIP URI to call. For example: sip:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx@sip.us.dasha.ai

To see the URI, write: dasha sip list-inbound.
Let’s put it in our Voximplant scenario instead of "your_SIP_URI".

Create a scenario inside the app by pressing a plus icon and paste this code in there:

    // SIP URI that we get in the next step
    const sipURI = <your_SIP_URI>;
    VoxEngine.addEventListener(AppEvents.CallAlerting, (e) => {
      const call = e.call;
      call.addEventListener(CallEvents.Connected, () => {
        const callToDasha = VoxEngine.callSIP(sipURI);
        VoxEngine.easyProcess(call, callToDasha);
      });
      call.answer();
    });

This is the scenario that will be run when we set everything up. We use the callSIP method to make a call to our SIP URI. On an incoming SIP call from Voximplant, the SIP URI that we want to call is passed to the callSIP method. This is how we connect two call legs. Once the call is answered, Dasha will start a conversation.

If you are using SIP Registrations on your PBX, you need to create a SIP Registration and use it instead of the SIP URI.

Click on Routing in the left hand menu. Create a new rule (leave the pattern as default), and attach your scenario to this rule.

Get your backend in order and start calling

The setup is ready, now we need a local app or backend to run our Voximplant scenario using Dasha.

Placing outbound calls:

Open your VS Code Dasha conversational AI app project. Open up index.js file and replace configName in dasha.sip.Endpoint with your config name. Do the same with the name field in package.json. To see all the available configs for sip outbound, run the dasha sip list-outbound command.

In the *.dashaapp file, change the name field so it matches our config name.

For outbound calls, run: node index.js <the number to call in international format e.g. 12223334455>. Now you can watch the application deployment and registration process in the console.

Taking inbound calls:

Open up your VS Code with the Dasha project open.
In the package.json file, replace the name field with your config name. To see all the available configs for sip inbound, run the dasha sip list-inbound command. In the inbound.dashaapp file, change the name field so that it matches your config name.

To test the integration, run npm i from your folder.

For inbound calls, run: node main.js. Now you can call to the phone number which you purchased in Voximplant’s dashboard.

You’ll be able to track application deployment in the console.

In conclusion

Congrats, you’ve successfully connected your Dasha conversational AI app to your custom telephony. This is exciting. You can now call anyone in the world.
If you haven’t yet, you can join Dasha community and let us know how useful this was to you. If you want a super quick answer - ask your questions on StackOverflow, using the #dasha hashtag.

Build a human-like conversational AI app in an hour

Arthur Grishkevich — Thu, 26 Aug 2021 11:20:32 +0000

Folks who work in insurance will tell you that it’s about as far from a sexy industry as one can get. Call me narrow-minded but I think any industry can be made sexier with a bit of AI. In today’s tutorial we will do just that: build a conversational AI app that will take a customer’s call, check their policy number and answer a few questions.

Pre-start

If this is your first time building a conversational AI app with Dasha, you want to join our developer community. This is where you will find all the answers to all of your questions (42). Also, as we are in a closed developer beta right now, this is where we will give you your API key to use Dasha.

This is the app you will build today:

To begin building with Dasha you will need to have Visual Studio Code, NPM and Node.js installed, ideally in their latest versions. Now do the following:

Install the Dasha Studio VSCode extension
Open the terminal in VSCode and install Dasha command line interface npm i -g "@dasha.ai/cli"
Now, run the command dasha account login and follow the browser prompt when it pops up.

You should probably join our developer community we obsess over answering all our community members ASAP.

If you prefer video tutorials, here you go:

%[https://www.youtube.com/watch?v=H22H-WBdZko]

Conversation structure

In order for you to better understand the conversation flow of what we are building, here is the basic structure of the conversational AI app.

Perfect world conversation

The user/customer calls in and asks to confirm some information about the insurance policy.

The AI asks for their policy number. The AI then reads the policy number back out to the user to confirm it. If the number is confirmed, Dasha looks up account details. If such an account exists, it tells the user as much and asks what they are after. If no such account exists, it tells the user as much.

The user may then proceed to ask one of a number of questions, such as, “does my policy cover accidents” or “what is the status of my claim”.

That’s pretty much it. Sounds simple enough. Before we get to the app, let’s go over the Dasha AI Platform architecture.

Dasha AI Platform architecture

There are three main parts to the product which makes building, training, developing and maintaining your human-like conversational apps possible. They are - Dasha Studio, Dasha SDK and Dasha Platform.

Dasha Studio

Is an extension to VSCode. You use the Studio to create your conversational workflow, provide data to train the neural networks to recognize intents, define ways in which the AI is to respond to the user, as it is talking to the user. The Studio lets you create these apps using DashaScript, an event-driven, domain-specific language derived from TypeScript. In essence, DashaScript is a collection of commands which tell the AI services in the Dasha Cloud Platform how to behave in various situations.

Dasha SDK

Is a library used to integrate your applications or services to the Dasha Cloud. It uses GRPC for two way communication between your application and Dasha Cloud Platform

Dasha Cloud Platform

The Dasha Cloud is where the magic happens. It provides the AI-as-a-Service components which enable you to create apps that are wildly human-like in the way they interact with users. Best in class speech to text, text to speech, natural language processing, understanding and generation, all come as a service of the Dasha Platform. And we are constantly improving existing services and building new ones. With any application you build using our technology, you will have access to all the newest updates. For more details on the Cloud Platform’s services, peek here.

The insurance customer service conversational AI app

Go ahead and open the source code to the application in your VSCode. You can either clone and open the app in your terminal or download, unzip and open the folder in VSCode using File > Open.

You will now want to open four files. These are essentially what make your conversational AI app built with Dasha possible.

index.js

This is the Node.js file from which your conversational AI application is launched. You use index.js to load the Dasha SDK. By the same token, you can incorporate this file, or the code which launches your application into any other Node.js project, from whence you wish to make use of the Dasha Cloud to run conversational apps. In this case, you will obviously need to include the Dasha application code in a separate folder.

Below is the JavaScript code you would use to launch a basic Dasha SDK connection and Dasha app:

const dasha = require("@dasha.ai/sdk");
const fs = require("fs");
async function main() 
{
  const app = await dasha.deploy("./app");

  app.connectionProvider = async (conv) =>
    conv.input.phone === "chat"
      ? dasha.chat.connect(await dasha.chat.createConsoleChat())
      : dasha.sip.connect(new dasha.sip.Endpoint("default"));

  app.ttsDispatcher = () => "dasha";

  await app.start();

  const conv = app.createConversation({ phone: process.argv[2] ?? "", name: process.argv[3] ?? "" });

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

  const logFile = await fs.promises.open("./log.txt", "w");
  await logFile.appendFile("#".repeat(100) + "\n");

  conv.on("transcription", async (entry) => {
    await logFile.appendFile(`${entry.speaker}: ${entry.text}\n`);
  });

  conv.on("debugLog", async (event) => {
    if (event?.msg?.msgId === "RecognizedSpeechMessage") {
      const logEntry = event?.msg?.results[0]?.facts;
      await logFile.appendFile(JSON.stringify(logEntry, undefined, 2) + "\n");
    }
  });

  const result = await conv.execute();

  console.log(result.output);

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

  await logFile.close();
}

main().catch(() => {});

main.dsl

Main.dsl is located in the /app/ directory. This is the DashaScript file which gets compiled and executed in the Dasha Cloud Platform. This file contains all the instructions that you provide to the Dasha AI Cloud on how to run your application. In essence, this is the conversational structure.

data.json

Data.json is the super-power file. It gives you the super power of training neural networks with simple JSON datasets. It is used for two things mainly - to define intents - ways of helping the AI to understand what real meaning the user places into their replies and named entities - data points located within the user’s replies. You can read more about both functions at the links above.

phrasemap.json

Phrasemap.json is another superpower file. Here you instruct what phrases your AI app should use in responding to the user. You can also instruct it to vary the phrases, to say different things if the same node gets called up a second or third time, etc.

Understanding the conversational AI app

Now that we’ve got a high-level overview of the technology and the files you are working with, let’s look at main.dsl more closely.

Run a test

To start off, let’s launch a test conversation. To do so, you will need to have the code open in your VSCode. Run npm i. Now, run npm start chat. A chat session will launch in your terminal. You can also run npm start 12223334455 where 12223334455 is your phone number in international format. You will get a call from the AI and can talk to it.

Now, let’s look at the code.

Imports and declarations

We start off by importing the library of commonly used digressions, intents, etc. By the way, digressions are nodes that can be called up at any point in the conversation. They do not have a node leading into them. Digressions are great for two things. One is preparing your AI appfor a variety of tangents which a human user might bring up in the course of a conversation. Two is letting you teach your AI app to say something along the lines of “how can I help you today” and then listen in for a response. You can read more about digressions here.

Then we declare context variables - input (ones that are pushed to the app on conversation start) and storage ones. Following this, we declare external functions.

External functions are a way to pass and receive arguments to and from the index.js file, in which the Dasha app runs as a function. You can in turn write instructions on what to do with these arguments, for example, calculations or, more importantly, you can push data to or pull data from an external service from the Node.js file. Or both. In the app you are looking at now we make use of external functions and will go over it.

I will paste examples of code. Unfortunately, due to the nature of Dasha apps, these code snippets do not pass the copy-paste test, as they need multiple files to run. As you have opened the repo, you can run the entire code base.

import "commonReactions/all.dsl";

context 
{
    // declare input variables here
    input phone: string;

    // declare storage variables here 
    name: string = ""; 
    policy_number: string = ""; 
    policy_read: string = "";
    policy_status: string = "";
    rating: string = "";
    feedback: string = "";
    claim: string = "";
}

// declare external functions here 
external function check_policy(policy_number: string): string;
external function convert_policy(policy_number: string): string;

Conversation flow

The conversation starts in earnest with line 22.

We kick it off with a starting node named root. Once the connection is established, the AI says the __”greeting”__ phrase, as indicated in the phrasemap.json. In the greeting phrase it asks for a name. Upon finding the data name, as defined in data.json, the conversation moves to the next node. In node node_2, we store the collected name data in the previously defined storage variable name and then use it to greet the user by their name.

start node root
{
   do //actions executed in this node
   {
       #connectSafe($phone); // connecting to the phone number which is specified in index.js that it can also be in-terminal text chat
       #waitForSpeech(1000); // give the person a second to start speaking
       #say("greeting"); // and greet them. Refer to phrasemap.json > "greeting"
       wait *; // wait for a response
   }
   transitions // specifies to which nodes the conversation goes from here
   {
       node_2: goto node_2 on #messageHasData("name"); // when Dasha identifies that the user's phrase contains "name" data, as specified in the named entities section of data.json, a transfer to node node_2 happens
   }
}

node node_2
{
   do
   {
       set $name =  #messageGetData("name")[0]?.value??""; //assign variable $name with the value extracted from the user's previous statement
       #log($name);
       #say("pleased_meet", {name: $name} );
       wait*;
   }
}

Now, please refer to phrasemap.json to see how the phrases are defined. You can see that we provide an alternate phrase under the label ”repeat”. This lets Dasha know that if it comes back to the same node a second time, a different phrase must be used. Note the use of dynamic variables in node node_2 and ”pleased_meet” phrase. Note that you can also define phrases directly and use dynamic variables in the body of main.dsl using the #sayText() function and string concatenation.

      "greeting": 
      {
        "first":
      [ { "text": "Hello! Thank you for calling ACME Insurance claims help line. My name is Dasha. I will be your artificially intelligent agent today. Can you please introduce yourself?" } ],
      "repeat":
      [ {"text": "I was just saying, can you please introduce yourself? " } ]
      },

      "pleased_meet": 
      {
        "first":
      [
        { "text": "Pleased to meet you " },
        { "id": "name", "type": "dynamic" },
        { "text": ". How can I help you today? " }
      ],
      "repeat":
      [        {"text": "I was just saying. How can I help you today " },
        {"id": "name", "type": "dynamic" },
        { "text": "?" }
        ]
      },

Now, let’s take a look at data.json to get a grasp of the neural network training data. We are looking at the named entities section of the file. Under ”values” we define the types of names that a person might have. Note that the ”open_set” parameter is set to true. This means that the AI is free to substitute various other names for the ones we provide to it as an example. To help it recognize where the names can be located in the body of the user’s response, we provide ”includes”.

 "entities":
 {
   "name":
   {
     "open_set": true,
     "values": [
       {
         "value": "Jim Smith",
         "synonyms": ["Jim Smith"]
       },
       {
         "value": "Tony Montana",
         "synonyms": ["Tony Montana"]
       },
       {
         "value": "Jill Jones",
         "synonyms": ["Jill Jones"]
       }
     ],
     "includes": [
       "My name is (Tony Montana)[name]",
       "My name is (Jill Jones)[name]",
       "This is (Jim Smith)[name]",
       "(Jim Smith)[name] calling",
       "(Jill Jones)[name]",
       "I'm (Tony Montana)[name]",
       "(Tony Montana)[name]"
     ]
   },

Moving further down in main.dsl we come upon digression policy_1. This digression gets called up when the AI identifies intent which corresponds to ”policy_check”, as stated in data.json.

Here is where it gets interesting. Take a look at the following three nodes:

digression policy_1
{
    conditions {on #messageHasIntent("policy_check");}
    do 
    {
        #say("what_policy");  //ask for policy number
        wait*;
    }
    transitions
    {
        policy_2: goto policy_2 on #messageHasData("policy");
    }
}

node policy_2
{
    do 
    {
        set $policy_number = #messageGetData("policy")[0]?.value??""; //set $policy_number wit the value acquired from the user 
        set $policy_read = external convert_policy($policy_number); //call up external function to add spaces between numbers to help the AI read out the numbers more legibly
        #log($policy_read);
        #say("confirm_policy" , {policy_read: $policy_read} ); //read policy number back out to user to confirm it was heard correctly
        wait*;
    }
    transitions
    {
        yes: goto policy_3 on #messageHasIntent("yes");
        no: goto policy_1_a on #messageHasIntent("no");
    }
}

node policy_3
{
    do
    {
        set $policy_status = external check_policy($policy_number); //call up an external function to check the policy 
        #say("verification_result", {policy_status: $policy_status} );
        wait*;
    }
    transitions
    {
        yes: goto can_help on #messageHasIntent("yes");
        no: goto bye_rate on #messageHasIntent("no");
    }
}

As you can tell from the code and the comments, we ask the user to state their policy number in digression policy_1, the number is identified as per instructions to the neural networks in data.json under ”entities” > ”policy”. In node policy_2, we store the policy number, call up an external function to send the number value to index.js, where we put spaces between the numbers. The reason for this is - a string of numbers that have no spaces between them will be read by Dasha out as the integer value, for example, one thousand fifty, versus one zero five zero. We put the spaces between the numbers, pass the value back to our app and store it as $policy_read. This number is then read out to the user, to confirm that it was heard correctly. If the number is read incorrectly, the AI asks the user to repeat it. If it is confirmed by the user, we go to node policy_3. Here we call up an external function to check the policy number and verify that there is an active policy with this number. In the case of this demo, we simply pick one or two outcomes with random chance. In the case of a real application running in production, you will want to integrate with your database and get the data from there.

 // external function convert policy number.
app.setExternal("convert_policy", (args, conv) =>
{
 var policyRead = args.policy_number.split('').join('. ');
 console.log(policyRead);
 return policyRead;
});

 // external function check policy number. Here we are providing a random evaluation, you will want to refer to your membership database
 app.setExternal("check_policy", (args, conv) =>
{
 const policyNumber = args;
 console.log(policyNumber);
 const foo = Math.random();
 if (foo >=.4)
 {
   return "This is a valid policy number. And there is currently one active claim associated with this policy number.";
 }
 else return "There is no active policy with this number. I'm sorry.";
});

Going back to node policy_3 - if the user has no additional questions, the conversation progresses to node bye_rate. Before letting the user go, Dasha asks to rate the interaction on the scale of 0 to 10. If the rating is six or below, Dasha will ask the user to clarify what they did not like about the experience.

You can find this code in main.dsl lines 104-177. Below I will only show the code for node rating_evaluation, as it is the only node dealing with functions that we have not used previously in this tutorial. As you can tell here, we save data collected from the user (rating 0-10) to a variable $rating, which we then convert to an integer. We have to do this because all user replies are saved as strings by Dasha. We then see whether the rating is greater than or equal to 7 or otherwise. Based on the outcome, the conversation develops.

node rating_evaluation
{
   do
   {
       set $rating =  #messageGetData("rating")[0]?.value??""; //assign variable $rating with the value extracted from the user's previous statement
       #log($rating);
       var rating_num = #parseInt($rating); // #messageGetData collects data as an array of strings; we convert the string to an integer in order to evaluate whether the rating is positive or negative
       if ( rating_num >=7 )
       {
           goto rate_positive; // note that this function refers to the transition's name, not the node name
       }
       else
       {
           goto rate_negative;
       }
   }
   transitions
   {
       rate_positive: goto rate_positive; // you need to declare transition name and the node it refers to here
       rate_negative: goto rate_negative;
   }
}

Starting at line 193 and to the end of main.dsl, the remaining digressions begin. These are concerned with the additional questions that a user might ask, once their policy number has been confirmed. These digressions deal with questions such as “what is the status of my insurance claim” and “I’d like to redeem my completed claim.”

In conclusion

Now that you have gone through the conversational AI app, make some changes to it and run some tests, using the commands stated earlier. For your reference:

Run npm i. Now, run npm start chat. A chat session will launch in your terminal. You can also run npm start 12223334455 where 12223334455 is your phone number in international format. You will get a call from the AI and can talk to it.

Let us know in the comments or in Dasha Developer Community what you build.

How to design and build your first conversational voice AI app

Arthur Grishkevich — Thu, 05 Aug 2021 08:45:33 +0000

In this tutorial I'll go over analyzing your proposed conversation, tailoring a conversational script, preparing and implementing it as a voice app using Dasha AI platform.

/* We're in closed beta now. This is a repost of two posts form our blog. If you want to try a conversational AI for a pet project, head over to community.dasha.AI to join our developer community; you'll be welcomed and provided instructions on how to get your API key + you'll have the support of all our CS engineers. */

AI as a service in the context of Dasha AI

A key value proposition of Dasha AI Platform suite of tools is letting you use the latest and greatest in conversational AI without knowing a single thing about machine learning, neural networks or AI for that matter. To this end, we provide AI as a service of the Dasha Cloud Platform.
Here is the architecture at a glance, for more please refer to the Platform Overview section of the documentation. Everything you see in the Application Layer is the AI as a service component.

Preparing your script and adapting it for the AI conversational interface

For the purpose of this article we will take a simple conversation that I want to automate with an AI app. It’s an app that will replace an administrator at your favorite restaurant. You call the restaurant, the AI picks up, takes your order and tells you when to come by to pick it up. Of course, we may need to answer a few questions along the way. To figure out how the conversation usually goes, we sit down with the current receptionist. Here is the conversation, as he conveyed it to us.

Administrator: Hi, this is John at Acme Burgers Main Street location. Would you like to place an order for pick-up?
Customer: Yes, please.
Administrator: What can I get for you?
Customer: I’d like a burger, some fries and a milkshake.
Administrator. Perfect. Let me just make sure I got that right. You want a burger, fries and a milkshake, correct?
Customer: That’s right.
Administrator: Great. Will you be paying at the store?
Customer: Yes, please.
Administrator: Perfect. Your order will be ready in 20 minutes at Acme Burgers Main Street location. Please go straight to the pick up counter. Can I help you with anything else?
Customer: No, that’s it. Thanks.
Administrator: And thank you for placing your order with us. Have a lovely day and enjoy!

The Administrator also told us that sometimes customers ask about food availability, delivery, ability to eat in, among other things. Let’s structure this script for your use in your conversational AI app development. I like to use a table to do this, as it helps me to get a bird’s eye view of the app I’m building. You can copy this spreadsheet to your Google Drive here or download it as an Excel spreadsheet to use on your machine.

In order to build your conversational AI app, break your conversation into three main areas:

Perfect world workflow - that’s the script the administrator shared with us earlier. Note that all nodes here are node which means that they can only be reached from another node or digression
Additional nodes (logical extensions) - these are talking points that will have to come up based on some of the responses to the script above. In this case, if the user answers “No” to “Would you like to place an order for pick-up?”, a logical response will be “How can I help you then?” Since this is not described in our perfect world workflow, we place this node in the logical extensions section.
Digressions (tangents) - our hypothetical restaurant administrator told us that sometimes customers ask about things outside of the script. In order to sound human-like on the phone (pass the Turing test), the AI has to be prepared to respond to these digressions. Here we prepare it for such. Note that, unlike a node, a digression can be brought up at any point in the conversation. Please note column C. It references an intent name. Intent classification categorizes phrases by meaning. This is how the AI app makes sense of what the user is saying to it. You can train your AI app to recognize the specific intent that you are looking for in the phrases of the user. To do so, you modify the data.json file and, you guessed it, you need to assign a specific name to each intent. In this spreadsheet we fill out intent names in Column C.

Pro tip: here's a post explaining the difference between **nodes* and digressions in detail. You can find it here. Also Iliya wrote a detailed explanation of how to use intent classification.*

Here is our spreadsheet with the intent names filled out:

Planning and structuring your conversational AI app

You should have noticed that a few of the columns in our spreadsheet are empty. Let’s see what they are and what their significance is to building your conversational AI app.

Let’s start with column F.

Node name - here you will name the node; you will use the name in your DashaScript code

Digression name - by the same token, you will name your digression here

I have gone through and named all of our nodes and digressions. You can see the result here (here is the spreadsheet link again just in case )

We’ve now got the node and digression names. By the way, you probably noticed that digression names and intent names are identical. They don’t have to be but for ease of mapping I like to keep them identical.

Note that we have a node place_order and a digression place_order. We need to duplicate the functionality because you can only transition into a node, yet at any point in the conversation the user might request ordering food. You can have the same name for a digression and a node.

Let’s map transitions (we’re getting to the fun part). The funnest (and most helpful) part about mapping transitions is realizing how many logical nodes are missing from our initial vision of the conversation map.

So now we have specified exactly what action the AI app should take upon any given user response. Bear in mind that we are not mentioning digressions here because the user can bring the digression up at any point in the conversation. That’s why they are digressions.

Building your conversational AI app - intents and entities

Now that we have our conversation mapped out, implementing it using DashaScript and JSON in Dasha Studio is a breeze.

First, you’ll want to open an existing simple Dasha app. I will use this one as the example. If you need instructions on how to get your Dasha Studio set up, you can refer to the second section of this post.

Once you’ve got the app opened in Visual Studio Code, make sure you have the following files open: main.dsl, intents.json. You will also want to open the visual graph editor - you can refer to it, as you are building your app, for a bird's eye view of transitions.

Perfect. I usually like to start with my intents. It helps me to think through things properly. Oh! And I just realized that we forgot to map our Yes and No intents. There is a system function for sentiment negative/positive, however for an app where Yes and No may be expressed in less than usual ways, I suggest creating custom intents.

Open Intents.json, select all and delete. Now paste in this code to get you started.

{
 "version": "v2",
 "intents":
 {
   "yes":
   {
     "includes": [
       "yes",
       "correct",
       "sure",
       "for sure",
       "absolutely",
       "right",
       "righto",
       "yep",
       "you got it",
       "I would"
     ],
     "excludes": [
       "fuck off"
     ]
   },
   "no": {
     "includes": [
       "no",
       "hell no",
       "definitely not",
       "wrong",
       "incorrect",
       "I do not",
       "I don't",
       "I would not"
     ],
     "excludes": [
     ]
   }
 },

     "entities":
     {

     }
}

You will now need to use the same format to fill out of all the intents that you had defined in the conversation map spreadsheet. You are stating the name of the intent and then listing examples of phrases that should be interpreted as signifying this intent and examples of phrases that should always be excluded as signifying this intent. Intents.json is the data you provide to train the intent classification neural networks in Dasha Cloud. For most intents 5-10 examples are enough, for some you may need more.

When you’re done you should have something like this.

You probably noticed the section “entities” which is something that we have not discussed. Named entities are a way to extract specific data from speech. In this case, we are using named entities to get the user’s order over the phone. To use entities, we have to define them and state examples in the JSON file. To gain a better understanding of using Named Entity Recognition in Dasha, read Iliya’s write up here.
Here is the code we will use for the entities:

"entities":
 {
   "food":
   {
     "open_set": true,
     "values": [
       {
         "value": "burger",
         "synonyms": ["burger", "hamburger", "a burger", "a hamburger", "a tasty hamburger"]
       },
       {
         "value": "fries",
         "synonyms": ["fries", "some fries", "french fries", "delicious fries"]
       },
       {
         "value": "milkshake",
         "synonyms": ["milkshake", "shake", "a milkshake", "strawberry milkshake", "a tasty milkshake"]
       },
       {
         "value": "hot dog",
         "synonyms": ["hot dog", "french dog", "a hot dog", "a french dog", "big dog"]
       },
       {
         "value": "grilled cheese",
         "synonyms": ["grilled cheese", "cheese sandwich", "grilled cheese sandwich", "a grilled cheese sandwich", "a cheese sandwich"]
       },
       {
         "value": "coke",
         "synonyms": ["soda", "coke", "a soda", "a coke"]
       }
     ],
     "includes": [
       "(burger)[food], (fries)[food] and a (milkshake)[food]",
       "(burger)[food], (fries)[food] and a (coke)[food]",
       "(grilled cheese)[food], (fries)[food] and a (milkshake)[food]",
       "(grilled cheese)[food], (fries)[food] and a (milkshake)[food]",
       "(hot dog)[food], (fries)[food] and a (milkshake)[food]",
       "(hot dog)[food], (fries)[food] and a (coke)[food]",
       "I'd like a (burger)[food], (fries)[food] and a (milkshake)[food]",
       "I'd like a (burger)[food], (fries)[food] and a (coke)[food]",
       "I'd like   (grilled cheese)[food], (fries)[food] and a (milkshake)[food]",
       "I'd like a (grilled cheese)[food], (fries)[food] and a (milkshake)[food]"
     ]
   }
 }

Synonyms are various ways in which the user might identify the entity value. Includes are ways in which the sentence, containing the entity value, might be phrased.

Go ahead and paste the section above to replace the “entities” section already in the JSON file. You may want to add some variations in phrasing to further train the neural network powering your conversational AI’s classification engine.

Setting up the nodes and digressions

Now, switch over to the main.dsl file. First we need to declare a function that will receive the data collected from the conversation with the user. Later in the conversation we will use this function to read the data back to the user to confirm the order. Here is the function declaration statement and here is what the first 5 lines of your new app should look like:

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

Now, let’s move to the nodes. Your first task is to transfer over all the nodes and to map out their transitions. Start with node root. You will want to change the text to reflect what we had defined in the conversation map and you will want to map the transitions accordingly. As the outcome, you should have this statement:

start node root
{
   do
   {
       #connectSafe($phone);
       #waitForSpeech(1000);
       #sayText("Hi, this is John at Acme Burgers Main Street location. Would you like to place an order for pick-up?");
       wait *;
   }   
   transitions
   {
       place_order: goto place_order on #messageHasIntent("yes");
       can_help_then: goto can_help_then on #messageHasIntent("no");
   }
}

Your second node will be place_order. Here we need to use the NLU control function #messageHasData to collect named entity data that we have defined in our intents.json file. This is what it will look like.
As you recall, we declared $food to be a data array variable in line 4 of the file. Now we are populating it with the data the user provides.

node place_order
{
   do
   {
       #sayText("Great! 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");
      }
   }
}

Refer to your conversation map. The next step from here is to confirm the food order. In this node we will read the data collected and stored in variable $food back to the user.

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 ?? "");
           }
       #sayText(" , correct?");
       wait *;
   }
    transitions
   {
       order_confirmed: goto payment on #messageHasIntent("yes");
       repeat_order: goto repeat_order on #messageHasIntent("no");
   }
}

With these three examples you will be able to create all the other nodes, as are required by your conversation map.

Now on to the digressions. As discussed previously, digressions are nodes that can be called up at any point of the conversation. They are used to make the conversation more human-like. (for more on digressions, read this post)

Let’s start with the delivery digression.

digression delivery
{
   conditions {on #messageHasIntent("delivery");}
   do
   {
       #sayText("Unfortunately we only offer pick up service through this channel at the moment. Would you like to place an order for pick up now?");
       wait *;
   }
   transitions
   {
       place_order: goto place_order on #messageHasIntent("yes");
       can_help_then: goto no_dice_bye  on #messageHasIntent("no");
   }
}

You can use the same framework to recreate all the other digressions, as you planned to in the conversation map. The only one to pay attention to will be the digression place_order. Make sure you reuse the code from node place_order to properly utilize named entities for data collection.

When you are done, your main.dsl file should look something like this.

You can get the code to the entire app in our GitHub repository here.

Testing the conversational AI app you have just built

Type npm start chat into your terminal. Give the cloud platform a minute to process the training data and train your intents and entities. A chat will launch within terminal.

Depending on the route you take, it may go something like this:

Type npm start number into your terminal, where number = your phone number in the international format e.g.: 12813308004. You will get a call, when you pick it up give it a second and the AI will begin the conversation, just as you had instructed it to do.

And that's about it. Have fun playing with our tech, also be sure to pop into our developer community. And let me know how I did in the comments. First post and all.

Citizen development

Arthur Grishkevich — Thu, 05 Aug 2021 07:49:22 +0000

Every company is a software company today. And if they are not today, they will be in the forthcoming future.

What is one thing every software company has in common? A shortage of IT specialists. In other words, more work than there are developers to do it. And that is where the citizen developer comes in.
If you face problems that can be solved with IT and know how you would solve them but lack the technical skills, you just might be a citizen developer in the making.

Citizen developer: meaning, context, models of operation

A citizen developer is any business professional who applies their generalist technical knowledge to solve their own business problems directly through technology, without a specialized developer’s assistance. These solutions can take on a variety of forms.

To define a citizen developer:

A sales professional in a small organization is tasked with setting up their sales tech stack. She maps out the workflow and reads the technical documentation to, with ample swearing, integrate Salesforce with Outreach and ZoomInfo. She is a citizen developer.

A logistics manager at a large home electronics manufacturer is fed up with having to manually fill out spreadsheets. After some searching he tries out a suit of tools from the citizen developer RPA (robotic process automation) vendor Electroneek and builds a bot that replicates his actions in Excel. Soon, all of his peers are using the same automation, and innovations is looking into what other impactful activities can be automated across the company. He is a citizen developer.

A director of call center operations is short-staffed. She manages a team of nearly 900, yet there are not enough agents to meet the ever increasing customer demand. After some digging around, she tries out Dasha’s suit of tools. With the help of our Customer Success engineers, she is able to put together a simple AI app that takes over for an agent and is able to save 1 minute on each 3-4 minute conversation. This change lets her safely scale total volume of call throughput by 20% without hiring a single new agent. She is a citizen developer.

I can’t quite pinpoint where my own journey as a citizen developer began. It definitely started before I became aware of the term, with checking server status and server logs on applications that my development team was working on. It progressed to building and deploying WordPress websites and designing intricately integrated sales and marketing technology stacks. Then I learned to build apps with Dasha AI, as a way to quickly put together demos for my customers.

My expectation is that citizen application development in the 2020’s will be like Excel in the 2000’s. You can’t imagine a job applicant coming to an interview who can’t use MS Word, Excel, Google Docs or email. That’s table stakes. By the same token, citizen application development will become table stakes by the end of the decade. Ranil Boteju, Global Head of Data Analytics WPB at HSBC, argues that the biggest shift will come with widespread use of accessible interfaces for data science analysis, enabling any professional to run big and small dataset analyses right at their computer.

I’m making citizen development sound like the best thing since flat whites (thanks Australia). Let’s try and figure out what its real benefits and pitfalls are.

How citizen development is fundamental to digital transformation: the pros

Speed of delivery No need to get put on a wait list and kick rocks until IT resources get freed up 6 months down the line. With a culture of citizen development, your lines of business are able to solve their tech problems themselves and to do so quickly and efficiently.
No disconnect No matter how close your IT and lines of business are, they are two separate functions. You can explain your problems to IT well enough but will they live these problems? No, they have their own. An operations manager who can quickly solve their own problem with tech will solve exactly the problem, until the solution does just what they are after.
Quality assurance By the same token - our citizen developer operations manager will test the solution they create within a real working environment, as soon as it's ready. Because it solves their problems. This will shorten the QA cycle and eliminate any risks of broken telephone.
Direct visibility into business difficulties This one goes without saying. An employee becomes a citizen application developer because they see that something needs fixing and there is no one to step up to the challenge and fix it.

What citizen development is not

Replacement for IT Having a robust citizen development culture does not mean you can do without the help of IT professionals and software engineers. While citizen developers can solve some of their own problems with technologies you put at their disposal, they are still line of business employees first and foremost. This means you will still need tech pros to maintain all your systems and for more complex development.
Set it and forget it You can’t expect to just give your line of business managers and directors a citizen developer lecture and to have them running off and building tools on their own. This will lead to an influx of what is referred to as shadow IT - a situation in which your company is using technology that was not vetted by IT, nor approved by your infosec experts. What you should do instead is vet a set of tools and have your IT present these tools to your line of business experts, so that they can use them for their work. A best practice is to illustrate the usefulness of these tools with some real world use cases. I see you rolling your eyes - your IT teams are already overloaded. This is where some internal selling chops will come in handy. Your IT team needs to understand that this initial time investment will mean significant time savings for them down the line.
A garden of wild roses A citizen developer culture will require nurturing. In our experience, the best way to help your citizen developers excel is to do two things - give them a platform to communicate and give them a way to quickly distribute successful applications to other team members who can use them with benefit.
A career path I saw some discussions online claiming the idea of the citizen developer is a dead end because there are no job postings for “citizen developer” roles. And there shouldn’t be. Citizen development is only worthwhile as an additional layer of value that a professional in their respective field can offer to a company. There are no “citizen developer” jobs for the same reason there are no “Microsoft Word expert” jobs. It is an instrument, not a vocation.

How to become a citizen developer or create a culture of citizen development

Let’s start with a simple check list.

Have you ever identified a problem or inefficiency in your work that can be solved with IT?
Have you ever pitched IT to solve this problem for you, just to realize that they are much too busy now, and for the foreseeable future?

You might want to consider becoming a citizen developer or introducing this concept into your company culture.

How to go about it. As I mentioned earlier, my journey started of its own accord. It arose out of necessity. I clearly don’t have these numbers but I would imagine that the story is similar for a majority of citizen developers. And if you are reading these lines, chances are necessity already arose.

Were I to be going on the citizen developer journey now, I would follow some sort of a roadmap to identify which tools I should be focusing on.

Step 1:

Identify your problems.

Step 2:

Identify which type of citizen developer tools might solve these problems.

Some examples are:

RPA (robotic process automation) (e.g.: Electroneek, UI Path)
Applications development (e.g.: Mendix, Microsoft Power Apps, Salesforce Lightning)
Common API and visual API tools (e.g.: Zapier, PieSync)
Legal document automation (e.g.: Documate, Clio)
Conversational automation - here I would be a fool not to suggest Dasha AI

In closing

I hope this was helpful. If you want to learn more about citizen development with Dasha AI - we’ve got a whole section of blog articles dedicated just to that. If you’ve got more questions than answers, feel free to schedule a time to speak with me here.

Build a human-like conversational voice AI app and collect customer feedback

Arthur Grishkevich — Tue, 03 Aug 2021 03:53:40 +0000

Some years back Gartner predicted that 89% of all companies will compete on customer experience. Today no one gets surprised by this. We love Apple, Amazon and Netflix because of the seamless experiences their respective platforms provide. Customer feedback surveys, collecting net promoter scores and customer satisfaction index are a big part of CX strategy for many companies and should be a big part for many more.

Email and sms customer feedback surveys suck. Phone surveys are cool because they are so rare… and expensive. At least they were expensive. Now you can build a Dasha conversational AI app that will reach out to your customer after an interaction, ask some questions, collect the ratings and collect some open, actionable feedback. It just works. Also, it’s a fun little project.

You can watch the video below to see a live demo of what you will have built:

GitHub repository.

In this tutorial we will go over:

Designing the conversation map.
Outsourcing your phrases to phrasemap.json to clean up the body of your main.dsl application.
Calling on external functions in your index.js and passing variables from your DashaScript code.
Running calculations within the body of your DashaScript application. Using #getMessageText(); to save entire user phrases as strings.

We will also touch on some things we’ve covered previously, such as:

Creating custom intents and named entities, setting up data to train the neural network.
Creating digressions and ensuring their native flow within the conversational app.
Structuring “perfect world” node flow.

If this is your first time building conversational apps with Dasha, I recommend you join our developer community and read this post.

How to ask for feedback from customers: Customer feedback surveys, tools and net promoter scores

Excuse the digression but here is some background information. Brands ask customers for feedback because they want to ensure that their product/service is as tailored to their customers’ needs as they can possibly get it. To a web or mobile developer, this may seem like a crazy notion, after all you are used to setting up A/B tests and figuring out the best ways to engage with the user in this manner. But even here, your product team probably monitors App Store reviews and asks for additional customer feedback/engagement from the users providing feature request or other feedback. Also, let’s not forget about test user focus groups.
In an industry like insurance or banking, for example, you are going to have a much harder time doing the same for anything other than the mobile app. To that end, legacy industries run customer feedback surveys. The common ways to conduct these are - email, SMS/text messages and telephone calls.

What are the costs/effectiveness of different customer feedback survey channels?

Email customer feedback surveys are free or very cheap but only get a meager 5-30% response rates
SMS/text message surveys are slightly more expensive and get 10-40% response rates
Telephone surveys are an order of magnitude more expensive than either of the above; however their results are significantly better - with over 90% response rates on picked up lines

Needless to say that telephone surveys get very little love due to how expensive they are. Let’s fix that.

Preparing the script for your customer feedback survey conversational AI app

A conversational AI application is literally a way of applying conversational AI technology to solve a specific real world problem, for example - how to get feedback from customers. The conversational app interacts with the user (customer) through speech - understanding, interpreting and generating natural language. For more on how Dasha Cloud Platform uses its conversational AI as a Service to make your apps human-like, you can read here.

In order to create an app, you need to have a basic understanding of the type of interactions you expect the AI to have with the user. This includes user replies, requests, the AI’s phrases and the direction in which you want it to take the conversation. In a way, this first step is similar to how you may document the UX of a mobile or web app.

For the sake of the present conversation, let’s envision a conversation in which Dasha calls ACME Bank’s customer a few hours after they had visited the bank’s office. She then proceeds to ask if they have got two minutes to fill out a survey. If they do, she asks three customer feedback questions with a rating of 1-5. If the rating is identified as negative, we will have Dasha ask the customer to specify what could have been done better. For the last question “what was your overall experience like,” we will ask to elaborate on the details of the experience even if it was positive, as well as negative.

I like to throw together a simple conversation map to outline my conversation. For detailed instructions on how to create your conversational map, you can refer to this post.

For the project we are building, this is the conversational AI app map I ended up with:

You can find the spreadsheet here. Feel free to copy to your Google Drive and edit it as you may see fit to change your conversational app.

Here is what we’ll cover next:

Creating the “perfect world” conversation flow
Adding digressions

In the course of this we will cover everything promised above - using the phrasemap, creating neural training data, running calculations using DashaScript.

Building the “perfect world flow” version of your customer feedback survey conversational AI app

First, make sure you’ve got the latest version of Node.js and Visual Studio Code. Now, head over to our developer community where you will get instructions to your Dasha API key. You will also want to install the Dasha Studio extension in VS Code, a well as the Dasha command line interface npm i -g "@dasha.ai/cli". AIf you need a quick start guide, please refer to this post. If you have any difficulties, just ask in our developer community.

Now open a Dasha app in VS Code. I propose you start with the first app.

Now, open up the following files:

main.dsl - you use your main DashaScript file to define the conversational workflow.
phrasemap.json - you use the phrase map to store phrases for Dasha to pronounce in the course of the conversation. You map to the phrases from main.dsl.
intents.json - here is where you store the data with which to train the neural network to recognize custom intents and named entities. Pro tip: rename to data.json, because the file includes named entities, not only intents.
index.js - the NodeJS file which launches the Dasha SDK. This is where you can use external JS functions to augment your conversational workflow or build out integrations to external services.

Go to main.dsl. You can refer to the application source code here if you wish but I strongly encourage you to build from scratch using a blank canvas.

Select all code and delete it.

Let’s start by importing common libraries

import "commonReactions/all.dsl";

Now, let’s declare some variables. We are going to use these to store variables. Here and onwards, refer to the in-code comments for additional specifications:

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;
   input name: string = "";

   // declare storage variables
   q1_rate: string = "";
   q2_rate: string = "";
   q3_rate: string = "";
   q1_feedback: string = "";
   q2_feedback: string = "";
   q3_feedback: string = "";
   final_feedback: string = "";
   call_back: string = "";
}

Next, let’s declare an external function. External function is how you call out to index.js from DashaScript (main.dsl) to make use of JavaScript functions.

// declaring external function for console logging, so that we can check the values of the variables, as the conversation progresses 
external function console_log(log: string): string;

We’ll look at this external function a bit later. Now, let’s move to the actual conversation flow. The first node in the conversation is called the node root. As above, please refer to the comments below. They will help to paint the full picture.

start node root
{
   do //actions executed in this node
   {
       #connectSafe($phone); // connecting to the phone number which is specified in index.js that it can also be in-terminal text chat
       #waitForSpeech(1000); // give the person a second to start speaking
       #say("greeting", {name: $name} ); // and greet them. Refer to phrasemap.json > "greeting" (line 12); note the variable $name for phrasemap use
       wait *;
   }
   transitions // specifies to which nodes the conversation goes from here and based on which conditions. E.g. if intent “yes” is identified, the conversation transitions to node question_1
   {
       question_1: goto question_1 on #messageHasIntent("yes"); // feel free to modify your own intents for "yes" and "no" in data.json
       all_back: goto when_call_back on #messageHasIntent("no");
   }
}

Note that in the function #say("greeting", {name: $name} ); we refer to greeting. The #say() function maps to the reference phrase in phrasemap.json. This means we need to add the values to your phrasemap. Open it up. You will see up top the following 9 lines of code. Keep it. This code controls the speech synthesis. Feel free to play around with it but these are the preferred values.

{
 "default": 
   {
   "voiceInfo": 
     {
     "lang": "en-US",
     "speaker": "V2",
     "speed": 0.3,
     "variation": 4
     },

We will add some phrases to this file as we go along. If there are leftover phrases which are unused by our present app, it will not hurt the performance of the app. However, I encourage you to look through your JSON code and clean out all unused pieces of code.

Let’s add the phrase “greeting”, so that it can map to the relevant code in main.dsl.

     "greeting": [
       { "text": "Hi " },
       { "id": "name", "type": "dynamic" },
       { "text": " this is Dasha with Acme Credit Union. You visited one of our offices earlier today. I'd like to ask you a few questions about the experience. Do you have two minutes now? " }
     ],

Now scroll down, until you see __


:__ and add this line:



```json
      "greeting": {},

Remember that for every phrase you add to the phrase map, you need to have a corresponding macro. If you forget, your IDE will let you know you made the mistake. Now your app knows how to greet the user. Note that we are substituting a dynamic variable “name” to refer to the user by their name.
The input variable name is also used in the function we were just looking at #say("greeting", {name: $name} );. As you run your conversational app, you would input the value for “name” following for the phone number. The terminal command to launch a call would look something like this: npm start 12223334455 John. Now, in order for the application to recognize “John” as mapping to variable name, we need to provide instructions in the SDK. Open index.js and search for const conv = app.createConversation modify this line to read.

 // in the line below, to account for name input context variable, you declare below: name: process.argv[3] ?? ""
 const conv = app.createConversation({ phone: process.argv[2] ?? "", name: process.argv[3] ?? "" });

This code is found in lines 57-58 of index.js, as found in the GitHub repository.
Great work. Now let’s assume that our user replied in the positive to Dasha’s request for two minutes and move on to the perfect world flow below. We finally get to ask the first question of our automated customer feedback survey.

node question_1
{
   do
   {
       #say("question_1"); //call on phrase "question_1" from the phrasemap
       wait *;
   }
   transitions
   {
       q1Evaluate: goto q1Evaluate on #messageHasData("rating");// when Dasha identifies that the user's phrase contains "rating" data, as specified in the named entities section of data.json, a transfer to node q1Evaluate happens
   }
}

Pretty straightforward stuff. Dasha pronounces the phrase for question_1 from the phrasemap, waits for a response and, on recognizing rating data, transfers to node q1Evaluate. You will need to add question_1 to the phrasemap file. I will show you this one last example, the rest of the phrasemap modifications you will do on your own, using previous ones as examples.

     "question_1":
       {
         "first":
         [{ "text": "Perfect, thank you. First question - how would you rate the bank employees with whom you interacted on the scale of 1 to 5." }],
         "repeat":
             [{ "text": "I was saying. how would you rate the bank employees with whom you interacted on the scale of 1 to 5." }]
       },

Note the ”repeat” value. This lets us provide an alternative phrase for the AI to substitute for the original in case this node gets called on a second time. Such a thing would usually happen when coming back from a digression. To learn more about digressions, you can take a look at this article.

The second part I want to draw your attention to in the node above is the transition to node q1Evaluate. The function #messageHasData() tells Dasha to check for a specific set of data, as defined in the “entities” section of data.json. Go to the file. You will need to append the code below after the closing curly bracket for ”intents”.

 "entities":
 {
   "rating":
   {
     "open_set": false, 
     "values": [
       {
         "value": "1",
         "synonyms": ["1", "one", "zero", "horrible", "worst ever", "the worst", "awful", "horrid", "despicable", "detestable", "very bad"]
       },
       {
         "value": "2",
         "synonyms": ["2", "two", "bad", "quite bad", "pretty bad", "not good", "crappy"]
       },
       {
         "value": "3",
         "synonyms": ["3", "three", "alright", "okay", "just okay"]
       },
       {
         "value": "4",
         "synonyms": ["4", "four", "good", "pretty good", "quite good", "good enough"]
       },
       {
         "value": "5",
         "synonyms": ["5", "five", "amazing", "incrdible", "just grand", "perfct", "wondrful", "very good", “ten”, “10”, “6”, “6”]
       }
     ],
     "includes": [
       "I would say it was (1)[rating]",
       "(4)[rating]",
       "I had an (3)[rating] experience",
       "It was (4)[rating]”,
    “Totally (2)[rating]”
     ]
   }
 }
}

Note the "open_set": false,. This tells the AI that it cannot substitute just any values for the ones defined in the file. The match has to be exact. Now, this only applies to the ”value”, not to the “synonym”. For example, with time the neural network will recognize “brilliant”, as signifying “5”, even though it is not mentioned in the training data. But it will never recognize “6” as a reasonable value to save in place of “1” or “5”. If you were to set the parameter to “true”, it would.

Also, pay attention to the ”includes” section. It provides a few variations of the types of constructions the AI may expect to hear from the user, so that it knows in which place to look for the value, in case it is not an exact match to one of the “synonyms”.
We got through node question_1. Let’s assume the user gave us an acceptable value which was rightly interpreted by the neural network and we are on to the next node. In this one, we evaluate the received value to estimate if the response is positive or negative.

node q1Evaluate
{
   do
   {
       set $q1_rate =  #messageGetData("rating")[0]?.value??""; //assign variable $q1_rate with the value extracted from the user's previous statement
       var q1_num = #parseInt($q1_rate); // #messageGetData collects data as an array of strings; we convert the string into a number in order to evaluate whether the rating is positive or negative
       if ( q1_num >=4 && q1_num <=5 )
       {
           goto question_2; // note that this function refers to the transition's name, not the node name
       }
       else
       {
           goto question_1_n;
       }
   }
   transitions
   {
       question_2: goto question_2; // you need to declare transition name and the node it refers to here
       question_1_n: goto question_1_n;
   }
}

Named entity variables are stored as an array of strings. In order for us to interpret the extracted value, we need to convert it to an integer. Once it is converted to integer, we can compare the value. If it is greater than or equal to 4, we go on to node question_2. If it is less than 4, we want Dasha to ask the user how their experience could have been made better. Let’s do just that now.

node question_1_n
{
   do
   {
       #say("question_1_n");
       wait*;
   }
   transitions // specifies an action that Dasha AI should take, as it exits the node. The action must be mapped to a transition
   {
       q1_n_to_q2: goto q1_n_to_q2 on true; // "on true" is a condition which lets Dasha know to take the action if the user utters any phrase
   }
   onexit 
   {
       q1_n_to_q2: do
       {
           set $q1_feedback = #getMessageText();
           external console_log($q1_feedback); // call on external function console_log (we want to see that the data was collected properly), you can then use the variable to push to wherever you want to use it from index.js
       }
   }
}

Take a look at the onexit section. This is where we use our external function which we initialized in the beginning of main.dsl. We want to be able to check that the values were collected properly in this part of the conversation. To do so, we need to store the value collected from the user’s reply in the previous node as variable ($q1_feedback) and send the value to our JS file and execute the console.log() function.

Of course, in order to use the function, we need it to exist in our index.js file, so let’s head over there and add the code below within the async function main() function.

// in the next 4 lines you set up a function for checking your acquired variables with external function console_log
app.setExternal("console_log", (args, conv) =>
 {
   console.log(args);
 });

This is line 50 if you are looking at the file found in the GitHub repo.
Now that we collected the open feedback we can head over to the next question. However, logic and good upbringing call for us to say something encouraging to the customer who poured their heart out to us. Unfortunately, there is no way to say a phrase after the onexit section, so we head to a transition node.

node q1_n_to_q2
{
   do
   {
       #say("transition");
       goto question_2;
   }
   transitions
   {
       question_2: goto question_2;
   }
}

Quite self-explanatory. From here we head over to node question_2. I will leave it up to you to recreate questions 2 and 3, along with all the phrase maps based on the example nodes above. Do bear in mind that question 3 has branches - positive and negative, not negative and next question. When in doubt refer to the conversation map. There is also the final question that we ask before disconnecting - does the customer have anything else to add. That leads into the final node:

node final_bye
{
   do
   {
       #say("final_bye");
       exit;
   }
}

You should also add two nodes for the call back flow.

Digressions - what to do when your user strays from the customer feedback survey script

A digression is activated when Dasha identifies that the user has mentioned a specific intent. A digression can be activated in any point in the conversation. You can read up more on digressions here.

As you can see in our conversation map, we have defined quite a few digressions. Let’s create the digression for “how_are_you”. First, you will want to define the intent, so that Dasha knows when the digression is called. Add this code to the ”intents” part of the data.json file.

    "how_are_you": 
    {
      "includes": [
        "how are you?",
        "how is everything?", 
        "you okay?",
        "how are you",
        "what it do"
      ]
    }

Next, head over to main.dsl. Scroll down to the bottom and add this code for the digression.

digression how_are_you
{
   conditions {on #messageHasIntent("how_are_you");}
   do
   {
       #sayText("I'm well, thank you!", repeatMode: "ignore");
       #repeat(); // let the app know to repeat the phrase in the node from which the digression was called, when go back to the node
       return; // go back to the node from which we got distracted into the digression
   }
}

Again, quite self explanatory thanks to the comments. When intent ”how_are_you” is recognized, the platform says “I’m well, thank you!” (note that I’m using #sayText, not #say here. This means I can type up the text right in the node and don’t have to refer to the phrase map). Then it goes back to the node from which it was so rudely interrupted and repeats the phrase that Dasha pronounced after which the user initiated the digression. If you provide alternative phrasing in your phrase map, Dasha will use it.

And there you go. If you follow these instructions you will have built a basic customer feedback survey conversational AI app. Just in case you haven’t visited yet, here is the link to the source code in the GitHub repository again.

If this tutorial was helpful, do let me know in Dasha developer community or at arthur@dasha.ai. If it was hard to understand, please do the same. Good luck and godspeed!