• Conversational AI Chat Bot
  • Introduction
    • Block Diagram
    • Prerequisites
    • Hardware
    • Recommended Domain Knowledge
  • Getting Started
    • Step 1: Clone the repository
    • Step 2: Build the reference implementation
    • Step 3: Start the reference implementation
    • Step 4: Dive In
  • General Guidance
    • How to build service individually
  • Quickstart - Update the environment variables. - Run wave-ingestion - Run Live Speech Ingestion
  • Expanding the Reference Implementation
  • Release Notes

This guide helps you build and run the Conversational AI Chat Bot Reference Implementation.

Upon completing the steps in this guide, you will be ready to integrate services to build your own complete solution.

The following items are required to build the Conversational AI Chat Bot. You will need additional hardware and software when you are ready to build your own solution.

• Ubuntu 18.04
• Docker >= 19.03.5
• Docker Compose >= 1.25.3
• Git
• GNU make

Here's how to install git, curl, and make on an Ubuntu 18.04 system - other operating systems may vary:

sudo apt-get update -y
sudo apt-get install -y git curl build-essential

• 8th Generation (and above) Intel® Core™ Processor, 32GB RAM and 100GB of HDD.
• ReSpeaker™ or equivalent USB Mic Array
• Auxiliary (AUX) Port Speaker or USB speaker
• Network with speed greater than 60 mbps preferable while building the docker images.

• Open Bank Project
• OpenVINO™ Toolkit

To use the chatbot, we need the credentials of an Open Bank Project compatible server. This reference implementation uses a sandbox server hosted here. For this demo, create credentials here.

git clone https://github.com/intel/conversational-ai-chatbot

You must build the provided component services and create local docker images. To do so, run:

$ sudo chmod a+x setup
# set env variables
$ source <repo-root>/setenvvars.sh
$ ./setup build

NOTE: This command may take a while to run depending on your internet connection and machine specifications.

For development or a quick demo, you can follow the quickstart instructions here.

The solution is to be deployed on a single node docker swarm. It stores the keys as docker secrets.

1. Create a docker swarm

This is a one time step.

# Check your ip
$ ip=`hostname -I | awk '{print $1}'`
$ echo "The ip of machine is $ip"
$ docker swarm init --listen-addr $ip

2. Create a directory to hold unix sockets.

This is a one time step. Assume the path you chose is ~/ipc_sockets. Follow these steps to create the directory and set its permissions.

$ mkdir -p ~/ipc_sockets
$ cd ~/ipc_sockets && export SOCKET_DIR=`pwd` && cd -
# Change the ownership of the path
$ sudo chown 800:1102 $SOCKET_DIR

3. Create Secrets

This step creates secrets and keys. This has to be run preferably at every run.

./create_secrets.sh

4. Run the compose file via make

Set the required env variables. TAG and SOCKET_DIR.

TAG=1.0 and SOCKET_DIR is the absolute path of the socket directory we created in the step 2.

cd ~/ipc_sockets && export SOCKET_DIR=`pwd` && cd -
export TAG=1.0

# choose asr
export ASR_IMAGE=kaldi_asr
# or
# export ASR_IMAGE=deepspeech_asr

# For wave audio file ingestion
# make -e run

# OR

# For recording via mic, we need to run this command
make -e run_respeaker

# to stop

make -e stop 

#OR
make -e stop_respeaker

All of the core components of Conversational AI Chat Bot are up and running, and you are ready to begin going through the following phases.

• Login: Login Using openbankproject credentials

• Phase 1: Record From Microphone

After completing the steps in the Getting Started section, it may be helpful to read through the remainder of this document for some further guidance on the Conversational AI Chat Bot reference implementation.

Please go through this link for an overview of the services used in this solution.

• overview of services
• security overview

# build deepspeech
make deepspeech_asr

# build kaldi asr
make kaldi_asr

# build huggingface asr
make huggingface_asr

# build quartznet_asr
make quartznet_asr

# build audio ingestion for wave files
make audio_ingestion

# build audio ingestion to record from mic
make audio_ingestion2

# build tts
make tts

# build authz
make authz

# build nlp_app
make nlp_app

# build rasa_action
make rasa_action_server

Use these steps to quickly start with the software. You need to create login credentials first as discussed here. Login

This method is recommended only for development or a quick demo. This requires the user to enter credentials via env variables.

There are two ways to run the application:

1. Wav File Ingestion: A quick test of the RI to illustrate how it responds to speech. Use this method to see the RI run with sample audio files. Use a speaker or headphones as the output device or monitor the log files.

2. Live Speech Ingestion: An interactive test of the RI that involves speaking words and phrases into a microphone or mic array. Use this method with Seeed ReSpeaker or another device as the input mic. Use a speaker or headphones as the output device or monitor the log files.

NOTE: The default ASR(speech recognition) set via setenvvars.sh script is quartznet_asr, in case the user want a different asr, user can edit the ASR_IMAGE variable in setenvvarsh.sh to any one of these {kaldi_asr, deepspeech_asr, hugginface_asr. Additionally, in case of multiple output devices, we can choose the specific output device by setting the ALSA_CARD value. The available card options can be checked via aplay -l.

# install alsa-utils, if not available
sudo apt-get install alsa-utils
aplay -l
# this lists the sound cards
export ALSA_CARD=<alsa sound device>
or
export ALSA_CARD=''
# for default device

Set env variables.

# set env variables
source <repo-root>/setenvvars.sh
# This script is interactive and will prompt the user for credentials and alsa_card value.

Run the software using pre-recorded queries.

./setup run wave_ingestion

The responses of the bot would be heard in the speaker in a short while.

Stop the software.

./setup stop wave_ingestion

Make sure you have connected a working microphone to the setup.

Run the live speech

./setup run speech_ingestion

Stop Live Speech

./setup stop speech_ingestion

The reference implementation you created is not a complete solution. It provides the base components for creating a framework to run an OpenVINO powered Conversational AI Chat Bot. This section provides information about components you might want to include or replace or change.

Find the release notes here.