How to Make a Chatbot Using JS

const { Wit } = require('node-wit');

const client = new Wit({
  accessToken: MY_TOKEN,
});

console.log(client.message('Make a reservation at 6am tomorrow'));

"@nlpjs/basic": "^4.22.0",
"dotenv": "^9.0.2",
"node-nlp": "^4.22.1",
"sugar": "^2.0.6",
"telebot": "^1.4.1"

{
  "name": "Corpus",
  "locale": "en-US",
  "data": [
    {
      "intent": "greetings.bye",
      "utterances": [
        "goodbye for now",
        "bye bye take care",
        "okay see you later",
        "bye for now",
        "i must go"
      ],
      "answers": [
        { "answer": "Till next time" },
        { "answer": "see you soon!"}
      ]
    },
    {
      "intent": "user.redirect",
      "utterances": [
        "Can I talk to a real human?",
        "Please connect me to a living person",
        "Please redirect me to an employee",
        "Can I talk to someone human?",
        "I want to enter the live chat",
        "I hate chatbots actually so please could you get out of my screen and connect me to someone made from flesh thanks"
      ]
    },
    {
      "intent": "user.thanking",
      "utterances": [
        "thanks",
        "thank you",
        "thanks a billion",
        "thx",
        "grateful"
      ],
      "answers": [
        { "answer": "No problem!"},
        { "answer": "Sure!"}
      ]
    },
    {
      "intent": "user.pricing",
      "utterances": [
        "Can I see the prices?",
        "What's the pricing?",
        "How much is it?",
        "How much do I have to pay?"
      ],
      "answers": [
        { "answer": "Check out our pricing by the link:\nhttps://stormotion.io/"}
      ]
    },
    {
      "intent": "greetings.hello",
      "utterances": [
        "hello",
        "hi",
        "howdy",
        "hey",
        "greetings",
        "hey there",
        "hola",
        "What's up?"
      ],
      "answers": [
        { "answer": "Hey there!" },
        { "answer": "Greetings!"}
      ]
    },
    {
      "intent": "user.book",
      "utterances": [
        "I'd like to book an appointment",
        "I wanna see the doc",
        "Can I see the doctor?",
        "When is the doctor available?",
        "I want some help with my knee",
        "I want to see @doctor",
        "I'd like to visit @doctor",
        "Is @doctor available?",
        "another reservation pls"
      ]
    }
  ],
  "entities": {
    "doctor": {
      "options": {
        "christine": ["Christine", "Christie", "Christine Collins", "The woman with black hair", "the female doctor"],
        "josh": ["Josh", "Joshua", "Josh Stammer", "The main with glasses"],
        "abraham": ["Abraham", "Abraham Brown", "Abe", "The man with brown curly hair"]
      }
    }
  }
}

"use strict"
import { NlpManager } from "node-nlp";
import TeleBot from "telebot";
import dotenv from "dotenv";
dotenv.config()

const manager = new NlpManager({ languages: ['en'], forceNER: true });
const bot = new TeleBot(process.env.BOT_TOKEN);

// Load the model. Then connect to the Telegram bot
(async() => {
  manager.addCorpus("corpus.json");
  await manager.train();
  manager.save()

  bot.on('text', async function(msg) {
    let response;
    let chatid = msg.chat.id;

    if (msg.text === "/start") {
      await msg.reply.text("Hello! My name's Booker. How can I help you?");

    } else {
      response = await manager.process('en', msg.text);
 
      await msg.reply.text(response.answer);
    }
  });

  bot.start();

})();

import Sugar from "sugar";

Sugar.Date.extend()

// Imitate a system with a dynamic time slots for doctors
const availableDoctors = { 
  "josh": "Josh Stammer, M.D.", 
  "christine":"Christine Collins, M.D.", 
  "abraham": "Abraham Brown, M.D."
};


/**
 * A class representing a user in a chat with a bot
 */
class User {
  constructor(manager, postOutput = console.log, chatid = undefined) {
    this.manager = manager;
    this.nextIntent;
    this.date;
    this.time;
    this.datetime;
    this.chatid = chatid;
    if (postOutput === "tg") {
      this.postOutput = async function(text) {
        await this.constructor.bot.sendMessage(this.chatid, text);
      }
    } else {
      this.postOutput = console.log;
    } 
  }

  /**
   * Give additional behavior to intents:
   * @param {Object} input - an object, which is the output of NlpManager's process method
   * @returns {Object} - the same object as in the input but with possibly changed attributes such as "answer"
   */
  async onIntent(input) {
    const output = input;

    // Check if output has to be a logical continuation of the prior conversation's flow.
    // If it is, change the classified intent to the predefined one.
    if (this.nextIntent) {
      output.intent = this.nextIntent;
      this.nextIntent = undefined;
    }
    
       // Check if the user want to book something
    if (output.intent === 'user.book') {
      
      //...
      
      // If the user's intent is to talk to a human operator, redirect the chat
    } else if (output.intent === "user.redirect") {
      output.answer = "Redirecting to a human manager";

      // Imitate passing the chat to a human operator
      this.postOutput("## Passing the chat over to a human manager");

    } else if (output.intent === "None") {
      output.answer = "Sorry, I didn't quite get you. Could your paraphrase it?"
    }
    return output;
  }
}

  // ...      

  // Check if the user want to book something
  if (output.intent === 'user.book') {

    if (output.entities) {
      // Go throught all found entities and add the important ones to instance variables
      for (let i = 0; i < output.entities.length; i++) {
        switch(output.entities[i].entity) {
          case "doctor":
            this.doctor = output.entities[i].option;
            break;
          case "date":
            let reservationDate = output.entities[i].sourceText;
            reservationDate = this.constructor.processDate(reservationDate);
            this.date = reservationDate;
            break;
          case "datetime":
            let reservationDatetime = output.entities[i].sourceText;
            reservationDatetime = this.constructor.processDate(reservationDatetime);
            this.datetime = reservationDatetime;
            break;
          case "time":
            let reservationTime = output.entities[i].sourceText;
            reservationTime = this.constructor.processDate(reservationTime, true);
            this.time = reservationTime;
            break;
        }
      }
    }

    // All the required data to book is present => process the reservation
    if (this.doctor && (this.datetime || (this.date && this.time))) {

      // If the user gave date & time separately, join them. If not, use the datetime
      let finalDatetime;
      if (this.datetime) {
        finalDatetime = this.datetime;
      } else {
        finalDatetime = this.date.advance(this.time);
      }

      // If the passed date or time are past
      if (finalDatetime < Date.now()) {

        output.answer = "Sorry, you've provided an unavailable time or date. Please repeat again";
        this.date = this.time = this.datetime = undefined;
        this.nextIntent = "user.book";

      } else {

        // Imitate sending the booking info to an API
        this.postOutput("## The request is sent to API");
        output.answer = `Your reservation with ${availableDoctors[this.doctor]} was made. `
                        + `Time: ${finalDatetime.toString()}. Thanks for working with us!`;

        // Rewriting the variables to give the user the ability to book more than once
        this.doctor = undefined;
        this.date = this.datetime = this.time = undefined;

      }

    // Not all data required to make a reservation is present => Iterate until it is
    // The iteration is done by means of the variable "nextIntent", which will
    // explicitly tell that the next message's intent also refers to booking (or other intents)
    } else {
      this.nextIntent = "user.book";
      output.answer = "Sorry, you have to specify";

      // The user hasn't provided the name of the doctor => Ask them to choose
      // out of the available ones
      if (!(this.doctor)) {
        var outputString = "Please choose the doctor out of the available:\n";
        for (let i = 0; i < Object.keys(availableDoctors).length; i++) {
          outputString += availableDoctors[Object.keys(availableDoctors)[i]] + "\n";
        }
        output.answer = outputString;
        return output;
      }
      // The user hasn't given the date or time. Ask them about it, while 
      // staying on "user.book" intent.
      if (!(this.date)) {
        output.answer = "Please enter the date";
        this.nextIntent = "user.book";
        return output;
      }
      if (!(this.time)) {
        output.answer = "Please enter the time";
        this.nextIntent = "user.book";
        return output;
      }
    }

  // ...

  // ...

  static processDate(textDate, isTime = false) {
    
    // Do the actual parsing
    let date = Date.create(textDate);

    // Get the time offset in case required
    if (isTime) {
      let dayStartTime = date.clone();

      dayStartTime.beginningOfDay();
      return date - dayStartTime;
    }
    return date;
  }
  // ...

export {
  availableDoctors,
  User
}

import { NlpManager } from "node-nlp";
import { User } from "./user.js";
import TeleBot from "telebot";
import dotenv from "dotenv";
dotenv.config()

// Imitate a database with user info. Key: Telegram chat id. Value: User instance
const userDatabase = {};

const manager = new NlpManager({ languages: ['en'], forceNER: true });
const bot = new TeleBot(process.env.BOT_TOKEN);

// As the bot is the same for all User instances, set the bot as a class property
User.bot = bot;

// Load the model. Then connect to the Telegram bot
(async() => {
  // Change to these lines in case there are any changes in the corpus
  // manager.addCorpus("corpus.json");
  // await manager.train();
  // manager.save()
  manager.load();

  bot.on('text', async function(msg) {
    let response;
    let chatid = msg.chat.id;

    // If the user doesn't yet exist in out database, add them
    if (!(chatid in userDatabase)) {
      userDatabase[chatid] = new User(manager, "tg", chatid);
    }

    if (msg.text === "/start") {
      await msg.reply.text("Hello! My name's Booker. How can I help you?");

    } else {
      response = await manager.process('en', msg.text);
      response = await userDatabase[chatid].onIntent(response);
 
      await msg.reply.text(response.answer);
    }
  });

  bot.start();

})();