How to Make a Chatbot Using JS

Imagine yourself in a world where all you have to do to interact with a company is drop a line to an intelligent humanoid who can resolve all your problems, have a chat with you, and crack a couple of jokes while handling any of your requests. Sounds cool, right?

Well, we're not in that world. But we are in a similar one thanks to chatbots (who aren't so great at cracking jokes, alas). They are actually useful in various tasks from making an appointment with a doctor to persuading your robot vacuum not to chase your cat.

Why don't we take a look at the pros and cons of a rule-based chatbot:

An AI-powered chatbot functions in a completely opposite way. As the name suggests, they use AI, Machine Learning and Natural Language Processing to perform their tasks. With them, you can write any text and they, ideally, will be able to recognize your “intent”, or rather what kind of response you want to hear from them. The output (answer) of AI-powered chatbots may be generated from scratch, or be created from a template — just as with the rule-based bots.

The pros and cons of an AI-powered chatbot:

Here, you can see how the embeddings are input in the first layer and then are forward-propagated, or fed in, through the many connections that are between the layers of the network. When the embeddings reach the final, or output layer, they choose the most likely intent. This intent is passed on to generate the response of the model.

They are also a great option if you don't want to run your bot on your server. You can use their APIs to get answers to users' requests. For example, connecting to Wit.ai in Node.js to get a response is as easy as this:

However, there might be reasons for deciding against any of the platforms:

• Security. If you use a platform, you can't make sure that no one else has access to the data your users pass to the chatbot.
• Prices. Most of the platforms utilize a subscription-based model. It means that in a long-term run it may not be the most cost-efficient solution.
• Lack of flexibility. If you build a chatbot from scratch, you can use literally any tool the programming world has, while platforms usually limit the choice.

If any of these reasons resonate with you, or you just feel like building a chatbot from scratch (which is certainly fun), check out the next section.

The harder way: Node + NLP.js

In order to implement a chatbot from scratch, we first have to choose an NLP/ML framework to process the text and create a neural network. Since this article focuses on Node implementation of chatbots, NLP.js is a good choice for this task.

Moreover, gaining experience with tools like NLP.js can enhance your portfolio and open up opportunities in Node.js jobs, where chatbot development skills are often in demand.

It has the following features:

• Custom entities in addition to the built-in ones like dates, names, etc.
• Built-in fully connected neural networks for classification.
• Language recognition.
• Tokenization, stemming, and other basic NLP tasks.

Our chatbot will have the following features:

• Saying hello, goodbye, giving info about the pricing according to corresponding intents.
• Booking a meeting with a doctor by means of extracting the date & time, and the name of the doctor.
• Recognizing custom entities, such as doctors’ names.
• Parsing dates in natural language format, i.e. not only in a standardized way like 20.05.2021, but also with queries like “the day after tomorrow” or “next Monday”.

Here are versions of the packages we're going to use:

First of all, we have to create a corpus, i.e. a dataset of question-answer entries, as well as of all the entities required. We decided not to add too many intents to keep it simple:

Here you can see the intents with their corresponding expressions that the bot will use to train itself. Once the bot recognizes an intent, it will randomly choose one of the given answers. Some of the intents don't have their corresponding answers because those cases are more complex and we have to use a callback function to process them.

Also, you can see our custom entity type — “doctor”. There are three doctors available and their alternative names (so that the bot understands that “Christine” and “Christie” refer to the same person).

Next, we have to set up our index.js file where we'll run trainings and establish the connection with Telegram's API. For the second task, we will use TeleBot, which is a very lightweight package, just what we need.

First, we import the required packages, set up the environment variables with the token of the bot in .env and create two instances of two major classes: NlpManager and TeleBot. The first will be used to create neural networks, train them based on our defined corpus, extract named entities and give answers. The second one will connect the chatbot to Telegram's API to exchange messages between the user and the bot.

The rest of the code defines the unnamed function, which is our main loop where all the training and message exchange is happening.

If you run this code, you'll first see a training log of our NN, and then the message of the bot being started. By this time, you should be able to text the bot whose token you've provided in .env, and it will respond to you.

But there's one feature that we haven't implemented yet: the actual booking itself. You can remember that we haven't provided any answers for “user.book” intent, so even if the bot does recognize it, there will be no answer. To fix this, we will create a whole custom class called User. Its main task will be to enable the booking functionality, i.e. asking for and recognizing the name of the doctor, as well as date & time of the reservation.

So that the chatbot understands natural language dates such as “the day after tomorrow” or “on the last day of May”, we will use Sugar, which extends the native Date object of Javascript, giving it additional functionality such as parsing strings.

Also, we will define an object “availableDoctors”, which is meant to imitate a system with dynamic time slots. As this article doesn't focus on creating such a system, a demo JS object with doctors will do just fine.

The main structure of our User class looks like this:

The most important method here is onIntent, which will give additional behavior to some intents. For example, the intent “user.book” will not only respond to the user, but also send a request to the API. onIntent will also be used to create a logical flow in a conversation. The instance variable nextIntent will be responsible for that. For instance, if our user inputs something like “I want to see a doctor”, the bot should ask the user to specify the doctor and time, and expect the next message to be interpreted only as the same “user.book” intent. That's why we'll explicitly save and later use this info about the next intent in the variable.

Here're the inner workings of our booking process:

Let's go through it step-by-step:

• Lines 6-30 are extracting the doctor's name, the date & the time of the reservation (if they are present) and saving them in the class instance.

• Lines 33-61 explain what to do in case all the necessary data (i.e. doctor's name, date, and time) are present. If the date and time the user wants are past, the user will be asked to make another choice. In case everything’s fine, the user gets a success message.

• The lines 66-90 define what to do in case not all information is available. Firstly, the user will be given a list of doctors to choose from. Then they will be asked to provide the date, and lastly — the time of the reservation.

The last thing we haven't spoken about is the processDate method, which will just parse a natural language string and extract either the date or the time offset from the beginning of the day:

Also, don't forget to export the object with doctors and the class itself at the end of the file:

Now, let's rewrite our index.js using our freshly-made class:

Here, you can see that we set up an object called userDatabase. While in a real-world application you might want to store the data about your users, in this demo project that's overkill, so we just use a JS object instead.

Also, since we've already trained and saved our NN, we just load it from our automatically created “model.nlp” file.

Lastly, after our NlpManager has processed the user input, we pass the result to our User's onIntent, which further modifies the answer and sends it to the chat.

Phew, seems like this is it. Let's try it out now.

If you need to look at the code for building a chatbot once again, feel free to take a couple of steps back.

You can create chatbots with the help of various services, including working with chatbot development companies, using chatbot platforms to build it yourself, employing pre-written codes for chatbot development, or learning how to make your own LLM.

To sum up, we'd like to say that building & integrating a chatbot is hard but definitely worth it — it can help you optimize customer support, communicate with your clients, and target your audience better.

You can access all of the source code along with detailed documentation in our GitHub repo.

If you need any help with the development or have any questions left, we'd be happy to help you!