DEV Community: bardonolado

How to create a NodeJS FAQ Chatbot

bardonolado — Tue, 16 Aug 2022 04:20:07 +0000

Creating a FAQ Chatbot

Introduction

A FAQ Chatbot have the purpose of answering the most common questions asked by users. We will build one using Bard and some of its funtionalities, that will help us to build a smarter chatbot.

Bard is a chatbot builder framework written in NodeJS/Typescript, but you can use it on your NodeJS/Javascript project too.

Conversation Flow

We want to develop an intuitive chatbot, that does not depends on its default dialog flow. The conversation must be intuitive. The user must have the option to ask any question at any conversation point, and the chatbot must respond to it. We can achieve that writing a dialog that expects questions and send the respective answers, using the incoming layer.

The main part of the conversation will be written using the trailing layer, where we can manipulate and redirect the interaction between the dialogs.

Above we have a basic flow. The chatbot asks and waits for the user's question. On user interaction, he will try to get the answer based on his input, then shows the answer if got it, otherwise retry it (maximum of 3 retries). Then the chatbot say bye and ends the conversation.

Building it

Declaring our Chatbot

First of all, we need to setup our project:

npm init
npm i --save bard-builder@1.6.4 express

Now we must import Bard and declare our chatbot.

Let's create a file named main.js:

const {Bot} = require("bard-builder");

const main = function() {
    /* declare the chatbot instance with the default state */
    const bot = new Bot({state: {answer_max_tries: 0}});

    /* here we declare the dialogs */
    /* here we start the chatbot */
    /* here we setup and start the message gateway */
}

main();

Organizing our dialogs

To start writing our dialogs, we need to put every dialog into a separated file inside a folder named dialogs. That will help us to build and visualize the conversation.

└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── faq-incoming.js

Now we have to link all these dialogs in our declared Bot instance. To do that we will need to create another file named flow.js. The folder structure will look like this:

└── main.js    // where we declare and setup our chatbot
└── flow.js    // link and setup the dialogs
└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── intent-incoming.js

const root_trailing = require("./dialogs/root-trailing");
const faq_trailing = require("./dialogs/faq-trailing");
const bye_trailing = require("./dialogs/bye-trailing");
const intent_incoming = require("./dialogs/intent-incoming");

/* 
    export a function that receives the chatbot as a parameter, then link the dialogs to it
*/
module.exports = function(bot) {
    /* this can be used to pass dependencies to dialogs */
    const deps = {};

    /* link dialogs into our chatbot */
    bot.trailing("root", root_trailing(deps));
    bot.trailing("faq", faq_trailing(deps));
    bot.trailing("bye", bye_trailing(deps));
    bot.incoming("intent", intent_incoming(deps));
}

And we need to modify our main function inside the main.js file to setup the flow:

const {Bot} = require("bard-builder");

const main = function() {
    /* declare and setup the chatbot instance */
    const bot = new Bot({state: {answer_max_tries: 0}});
    setup_flow(bot);

    /* here we start the chatbot */
    /* here we setup and start the message gateway */
}

main();

Writing the dialogs

Root dialog (`/dialogs/root-trailing.js`):

Now we can start writing those empty dialogs. The root trailing dialog will be responsible for greeting the user and redirecting to the faq trailing dialog:

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* get known data */
            const is_known = session.state.known_greeting;

            /* if user already interacted, then send a different message to him */
            let greeting_message = "Hello! I am FAQ Chatbot!";
            if (is_known) greeting_message = "Hello again!";

            session.send(greeting_message);

            /* set known to true */
            session.state.known_greeting = true;

            /* redirect interation to the faq trailing dialog */
            return course.replace("faq");
        }
    ];
}

Intent dialog (`/dialogs/intent-incoming.js`):

Now we must write our intent incoming dialog, that will be responsible for understanding the user input and checking if it is a valid question.

We will need to create a answer-question table to make the user input validation. You can use a JSON configuration file, but we just write it inside the .dialogs/intent-incoming.js file.

If the user input is a valid question, then it will save the answer to session.state.answer.

And since this is an incoming layer dialog, the interation won't stop after reach the end. It will continues through until reach the trailing layer, unless you stop it (manually, omitting course.next() at the last step).

You should substitute that question validation for some cognitive engine. There are many out there, include some free ones.

const questions_list = {
    "who are you?": "I am a just a chatbot, that's sad because I even have a name :/",
    "what is a chatbot?": "Chatbot is a applicati0n th47 coNDuc7 4 c0nv3rS47i0 i7h   um4n",
    "what is your purpose?": "Not to pass butter, sadly."
};

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* get the user input */
            const user_input = session.getMessage().data;
            if (!(user_input && user_input.length)) {
                return course.next();
            }

            /* check if user input is a valid question, if so save it in session and redirect it to the faq dialog */
            const answer = questions_list[user_input.toLowerCase()];
            if (answer) {
                session.state.answer = answer;
                return course.replace("faq");
            }

            /* ensure interation to keep going through and reach the trailing layer */
            return course.next();
        }
    ];
}

FAQ dialog (`/dialogs/faq-trailing.js`):

Here we can check for the previous set value on session answer. If it exists, send the answer. Otherwise send to back to the begin of faq trailing dialog, if retries reaches more than 2 times, say bye and end the session.

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* if have an answer, jump to the next step */
            const have_answer = session.state.answer;
            if (have_answer) return course.next();

            session.send("Can I help you?");
            return course.wait();
        },
        (session, course) => {
            const have_answer = session.state.answer;
            if (!have_answer) {
                /* if retries reaches more than 2 times, say bye and end the session */
                let max_tries = session.state.answer_max_tries || 0;
                if (max_tries >= 2) {
                    session.send("I can't help you if I can't understand you.");
                    /* reset tries counter */
                   session.state.answer_max_tries = 0;
                    return course.replace("bye");
                }
                session.send("Sorry, I don't have an answer to that.");
                session.state.answer_max_tries = ++max_tries;
                return course.replace("faq");
            }

            /* reset tries counter */
            session.state.answer_max_tries = 0;

            /* send answer and set its session value to null */
            session.send(have_answer);
            session.state.answer = null;

            return course.next();
        },
        (session, course) => {
            /* ask if want to ask another question */
            session.send("Want to ask it again?");
            return course.wait();
        },
        (session, course) => {
            /* if response is yes, redirect to the faq dialog again, if not say bye */
            const response = session.getMessage().data;
            if (response != "yes" && response != "y") {
                session.send("Alright!");
                return course.replace("bye");
            }
            return course.replace("faq");
        }
    ];
}

Bye dialog (`/dialogs/bye-trailing.js`):

Here we say bye to our user.

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            session.send("Goodbye! I hope I've been helpful!");
            return session.end()
        }
    ];
}

Message Gateway

Now that we have all of dialogs written, we can start writing our message gateway. You can use bot.push(message) to insert a outgoing message or bot.pull() to retrieve a incoming message.

To do that, create a file named gateway.js inside our project folder:

└── main.js    // where we declare and setup our chatbot
└── flow.js    // link and setup the dialogs
└── gateway.js    // create the message gateway (receiving and sending messages)
└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── intent-incoming.js

Receiving messages

You probably are receiving from message broker by a webhook, so we will need to create one (you can use other frameworks, but to simplify we will just use "express", that is a excellent a reliable framework).

Sending messages

To send a reply for the messages sent by the conversation flow, in response to the ones received, we can use bot.pull() function. It will pull a outgoing message from the conversation flow. We can do it by creating a pulling system and sending all outgoing messages to our message broker.

Gateway:

So, we are creating a webhook for receiving the messages and a pulling system to send the messages out to the message broker (your broker) - you can substitute that. We need put the code above inside the previous created gateway.js file:

const {Message, MessageTypes} = require("bard-builder");
const express = require("express");

module.exports = class Gateway {
    constructor(port, bot) {
        this.port = port;
        this.bot = bot;

        /* declare message broker (mock) */
        this.message_broker = {
            sendMessage: (message) => console.log("Simulating sending message:", message.data)
        };

        /* declare webhook server */
        this.server = express();

        /* to parse JSON body */
        this.server.use(express.json());

        /* declare endpoit for receiving messages */
        this.server.post("/receive/message", (request, response) => {
            const body = request.body;
            const message = new Message(
                body.contact, body.session, body.origin, body.data
            );

            /* use bot.push(message_object) to send a message to the conversation flow */
            this.bot.push(message);
            return response.status(200).send("OK - Message received!");
        });
        this.server.listen(this.port);
    }

    pullProcess() {
        /* get message from chatbot */
        const message = this.bot.pull();
        /* if it is an Error instance, re-run this with delay (probably empty) */
        if (message instanceof Error) {
            return setTimeout(() => this.pullProcess(), 500);
        }

        /* send message to message broker */
        this.message_broker.sendMessage(message);

        /* re-run this */
        return setImmediate(() => this.pullProcess());
    }
}

Above we are receiving a incoming message from a webhook and creating/inserting the Message instance into the conversation flow using bot.push(message).

Every time it happens a new interaction is executed in the conversation flow.

You can create a switch to handle all incoming message types and set the respective one into the Message instance.

We are declaring our message broker and creating a function that calls itself repeatedly to pull messages from the conversation flow. The pulling function try to get a message, and if fail will wait some time to run again (probably the queue is empty). If succeed, will send the message to our message broker and re-call the function immediately again. Using this mechanism we can ensure that we not lock the thread only by pulling messages. We are re-scheduling these calls to fit wherever it can (using setImmediate() and let the other parts of the code breath and run smoothly.

And to add this to the chatbot system we must modify our main.js file again:

const {Bot} = require("bard-builder");
const setup_flow = require("./flow.js");
const Gateway = require("./gateway.js");

const main = function() {
    /* declare and setup the chatbot instance */
    const bot = new Bot({name: "my-faq-bot"});
    setup_flow(bot);

    /* here we start the chatbot */
    bot.start();

    /*
        declare gateway (webhook and pulling system) and
        start pulling messages from bot and sending it to the message broker
    */
    const gateway = new Gateway(8888, bot);
    gateway.pullProcess();
}

main();

There you have a simple, but smart, FAQ chatbot.

Testing it

You can make a HTTP request to our created webhook with the message body:

POST > http://localhost:8888/receive/message
{
    "contact": "11445917045",
    "session": "dkioas32902",
    "origin": "insomnia",
    "data": "hello!"
}

Then you can send messages to your chatbot and the chatbot output will probably be at your console. These are the questions to ask with a answer:

"who are you?"
"what is a chatbot?"
"what is your purpose?"

You can add more chaging the questions-list variable in the intent incoming dialog.

Conclusion

Now we finished our FAQ chatbot. I recommend you to change the question-table in the intent incoming dialog for any preferred cognition engine you have. And for the message broker too. There are some good cognition engines and message brokers out there, some of them are free.

You can evolve this chatbot to something bigger too. No bounds to what you can do here.

You can find and example of this tutorial here: FAQ chatbot

NodeJS Non-Blocking Processing

bardonolado — Thu, 26 Nov 2020 05:20:10 +0000

NodeJS Non-Blocking Processing

The problem

Let's say we have a queue and we need to constantly pull items from that. Which is the best approach to that?

In many cases, we can create a piece of code that contains a while call, and for each iteration we pull one or more items from the queue.

function pullFromQueue(queue) {
    while (true) {
        const item = queue.pull();
        doSomething(item);
    }
}

But what if we have something else in our application? Or if we want to do another task too? That piece of code will block everything not relate to the doSomething() call. Every single task will be frozen, just waiting that while loop end. ~~It will end, right?~~

Unless we get rid of that eternal loop, there is no way to accomplish such pulling process without blocking everything.

We can change doSomething() to be an async function, it will certainly unblock the event loop, but we just created a potential stackoverflow error. Every iteration will fire a doSomething() call without waiting it to ends. Thus, it will continue to accumulate until it reaches the process limit calls, leading it to a real stackoverflow error.

Or we can change that to a recursive function, but it will still block the event loop, as it is almost the same as the the while loop.

function pullFromQueue(queue) {
    const item = queue.pull();
    doSomething(item);

    /* call itself */
    pullFromQueue(queue);
}

The problem is: after we called pullFromQueue(), every single event loop's tick will be in charge of managing it. Leading to a function flood where nothing but that function or something related to it will be executed. If we called something before, it will be frozen. And if we called something after, it won't even start.

The Solution

We aren't letting the event loop breath, and to remedy that we can use the setImmediate(our_call) function. It will schedule our call to some more available position in the event loop. So, every frozen operation will have the opportunity to be executed in the between.

function pullFromQueue(queue) {
    const item = queue.pull();
    doSomething(item);

    /* call itself */
    setImmediate(() => pullFromQueue(queue));
}

Even taking some space in the event loop, the others calls will be executed. Let's try to visualize what is happening:

1. pullFromQueue() called;
2. queue.pull() called;
3. doSomething() called;
4. setImmediate scheduled pullFromQueue();

5. other random call();
6. another random call();

7. pullFromQueue() called;
8. ...

Now we see that there are some other operations being executed between the pullFromQueue() calls, different of what was happening.

We can try to optimize it, said that this can still be event loop consuming. So, when a item is pulled from the queue, we can check if it exists. If not exist (meaning the queue is empty, busy, etc) we can re-schedule the function with a little delay.

function pullFromQueue(queue) {
    const item = queue.pull();
    /* if can't get item, re-schedule this function without calling doSomething() */
    if (!item) {
        return setInterval(() => pullFromQueue(queue), 250);
    }

    doSomething(item);

    /* call itself */
    setImmediate(() => pullFromQueue(queue));
}

This can reduce drastically the event loop consumption when it is not needed (queue empty, timeout, busy, etc).

Now that we have a non-blocking processing function, we can use it to whatever pulling processing we want, without worrying about with our other functionalities in the same NodeJS process.

We can apply that to anything that needs recursive fetching, like: HTTP Requests, Redis Job Queue Pulling, MongoDB Pagination Queries, etc.

How to create a NodeJS FAQ Chatbot

bardonolado — Thu, 19 Nov 2020 22:25:09 +0000

Creating a FAQ Chatbot

Introduction

A FAQ Chatbot have the purpose of answering the most common questions asked by users. We will build one using Bard and some of its funtionalities, that will help us to build a smarter chatbot.

Bard is a chatbot builder framework written in NodeJS/Typescript, but you can use it on your NodeJS/Javascript project too.

Conversation Flow

The main part of the conversation will be written using the trailing layer, where we can manipulate and redirect the interaction between the dialogs.

Building it

Declaring our Chatbot

First of all, we need to setup our project:

npm init
npm i --save bard-builder express

Now we must import Bard and declare our chatbot.

Let's create a file named main.js:

const {Bot} = require("bard-builder");

const main = function() {
    /* declare the chatbot instance */
    const bot = new Bot({name: "my-faq-bot"});

    /* here we declare the dialogs */
    /* here we start the chatbot */
    /* here we setup and start the message gateway */
}

main();

Organizing our dialogs

To start writing our dialogs, we need to put every dialog into a separated file inside a folder named dialogs. That will help us to build and visualize the conversation.

└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── faq-incoming.js

Now we have to link all these dialogs in our declared Bot instance. To do that we will need to create another file named flow.js. The folder structure will look like this:

└── main.js    // where we declare and setup our chatbot
└── flow.js    // link and setup the dialogs
└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── intent-incoming.js

const root_trailing = require("./dialogs/root-trailing");
const faq_trailing = require("./dialogs/faq-trailing");
const bye_trailing = require("./dialogs/bye-trailing");
const intent_incoming = require("./dialogs/intent-incoming");

/* 
    export a function that receives the chatbot as a parameter, then link the dialogs to it
*/
module.exports = function(bot) {
    /* this can be used to pass dependencies to dialogs */
    const deps = {};

    /* link dialogs into our chatbot */
    bot.trailing("root", root_trailing(deps));
    bot.trailing("faq", faq_trailing(deps));
    bot.trailing("bye", bye_trailing(deps));
    bot.incoming("intent", intent_incoming(deps));
}

And we need to modify our main function inside the main.js file to setup the flow:

const {Bot} = require("bard-builder");

const main = function() {
    /* declare and setup the chatbot instance */
    const bot = new Bot({name: "my-faq-bot"});
    setup_flow(bot);

    /* here we start the chatbot */
    /* here we setup and start the message gateway */
}

main();

Writing the dialogs

Root dialog (`/dialogs/root-trailing.js`):

Now we can start writing those empty dialogs. The root trailing dialog will be responsible for greeting the user and redirecting to the faq trailing dialog:

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* get known data */
            const is_known = session.storage.get("known_greeting");

            /* if user already interacted, then send a different message to him */
            let greeting_message = "Hello! I am FAQ Chatbot!";
            if (is_known) greeting_message = "Hello again!";

            session.send(greeting_message);

            /* set known to true */
            session.storage.set("known_greeting", true);

            /* redirect interation to the faq trailing dialog */
            return course.replace("faq");
        }
    ];
}

Intent dialog (`/dialogs/intent-incoming.js`):

Now we must write our intent incoming dialog, that will be responsible for understanding the user input and checking if it is a valid question.

We will need to create a answer-question table to make the user input validation. You can use a JSON configuration file, but we just write it inside the .dialogs/intent-incoming.js file.

If the user input is a valid question, then it will save the answer in the session using session.storage.set(key, value).

You should substitute that question validation for some cognitive engine. There are many out there, include some free ones.

const questions_list = {
    "who are you?": "I am a just a chatbot, that's sad because I even have a name :/",
    "what is a chatbot?": "Chatbot is a applicati0n th47 coNDuc7 4 c0nv3rS47i0 i7h   um4n",
    "what is your purpose?": "Not to pass butter, sadly."
};

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* get the user input */
            const user_input = session.getMessage().data;
            if (!(user_input && user_input.length)) {
                return course.next();
            }

            /* check if user input is a valid question, if so save it in session and redirect it to the faq dialog */
            const answer = questions_list[user_input.toLowerCase()];
            if (answer) {
                session.storage.set("answer", answer);
                return course.replace("faq");
            }

            /* ensure interation to keep going through and reach the trailing layer */
            return course.next();
        }
    ];
}

FAQ dialog (`/dialogs/faq-trailing.js`):

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            /* if have an answer, jump to the next step */
            const have_answer = session.storage.get("answer");
            if (have_answer) return course.next();

            session.send("Can I help you?");
            return course.wait();
        },
        (session, course) => {
            const have_answer = session.storage.get("answer");
            if (!have_answer) {
                /* if retries reaches more than 2 times, say bye and end the session */
                let max_tries = session.storage.get("answer_max_tries") || 0;
                if (max_tries >= 2) {
                    session.send("I can't help you if I can't understand you.");
                    /* reset tries counter */
                    session.storage.set("answer_max_tries", 0);
                    return course.replace("bye");
                }
                session.send("Sorry, I don't have an answer to that.");
                session.storage.set("answer_max_tries", ++max_tries);
                return course.replace("faq");
            }

            /* reset tries counter */
            session.storage.set("answer_max_tries", 0);

            /* send answer and set its session value to null */
            session.send(have_answer);
            session.storage.set("answer", null);

            return course.next();
        },
        (session, course) => {
            /* ask if want to ask another question */
            session.send("Want to ask it again?");
            return course.wait();
        },
        (session, course) => {
            /* if response is yes, redirect to the faq dialog again, if not say bye */
            const response = session.getMessage().data;
            if (response != "yes" && response != "y") {
                session.send("Alright!");
                return course.replace("bye");
            }
            return course.replace("faq");
        }
    ];
}

Bye dialog (`/dialogs/bye-trailing.js`):

Here we say bye to our user.

/* export a function that returns the dialog (array of functions) */
module.exports = function(deps) {
    return [
        (session, course) => {
            session.send("Goodbye! I hope I've been helpful!");
            return session.end()
        }
    ];
}

Message Gateway

Now that we have all of dialogs written, we can start writing our message gateway. You can use bot.push(message) to insert a outgoing message or bot.pull() to retrieve a incoming message.

To do that, create a file named gateway.js inside our project folder:

└── main.js    // where we declare and setup our chatbot
└── flow.js    // link and setup the dialogs
└── gateway.js    // create the message gateway (receiving and sending messages)
└── dialogs
    ├── root-trailing.js
    ├── faq-trailing.js
    ├── bye-trailing.js
    └── intent-incoming.js

Receiving messages

Sending messages

Gateway:

const {Message, MessageTypes} = require("bard-builder");
const express = require("express");

module.exports = class Gateway {
    constructor(port, bot) {
        this.port = port;
        this.bot = bot;

        /* declare message broker (mock) */
        this.message_broker = {
            sendMessage: (message) => console.log("Simulating sending message:", message.data)
        };

        /* declare webhook server */
        this.server = express();

        /* to parse JSON body */
        this.server.use(express.json());

        /* declare endpoit for receiving messages */
        this.server.post("/receive/message", (request, response) => {
            const body = request.body;
            const message = new Message(
                body.contact, body.session, body.origin,
                body.data, MessageTypes.TEXT
            );

            /* use bot.push(message_object) to send a message to the conversation flow */
            this.bot.push(message);
            return response.status(200).send("OK - Message received!");
        });
        this.server.listen(this.port);
    }

    pullProcess() {
        /* get message from chatbot */
        const message = this.bot.pull();
        /* if it is an Error instance, re-run this with delay (probably empty) */
        if (message instanceof Error) {
            return setTimeout(() => this.pullProcess(), 500);
        }

        /* send message to message broker */
        this.message_broker.sendMessage(message);

        /* re-run this */
        return setImmediate(() => this.pullProcess());
    }
}

Above we are receiving a incoming message from a webhook and creating/inserting the Message instance into the conversation flow using bot.push(message).

Every time it happens a new interaction is executed in the conversation flow.

You can create a switch to handle all incoming message types and set the respective one into the Message instance.

And to add this to the chatbot system we must modify our main.js file again:

const {Bot} = require("bard-builder");
const setup_flow = require("./flow.js");
const Gateway = require("./gateway.js");

const main = function() {
    /* declare and setup the chatbot instance */
    const bot = new Bot({name: "my-faq-bot"});
    setup_flow(bot);

    /* here we start the chatbot */
    bot.start();

    /*
        declare gateway (webhook and pulling system) and
        start pulling messages from bot and sending it to the message broker
    */
    const gateway = new Gateway(8888, bot);
    gateway.pullProcess();
}

main();

There you have a simple, but smart, FAQ chatbot.

Testing it

You can make a HTTP request to our created webhook with the message body:

POST > http://localhost:8888/receive/message
{
    "contact": "11445917045",
    "session": "dkioas32902",
    "origin": "insomnia",
    "data": "hello!",
    "type": "text"
}

Then you can send messages to your chatbot and the chatbot output will probably be at your console. These are the questions to ask with a answer:

"who are you?"
"what is a chatbot?"
"what is your purpose?"

You can add more chaging the questions-list variable in the intent incoming dialog.

Conclusion

You can evolve this chatbot to something bigger too. No bounds to what you can do here.

You can find and example of this tutorial here: FAQ chatbot

DEV Community: bardonolado

How to create a NodeJS FAQ Chatbot

Creating a FAQ Chatbot

Introduction

Conversation Flow

Building it

Declaring our Chatbot

Organizing our dialogs

Writing the dialogs

Root dialog (/dialogs/root-trailing.js):

Intent dialog (/dialogs/intent-incoming.js):

FAQ dialog (/dialogs/faq-trailing.js):

Bye dialog (/dialogs/bye-trailing.js):

Message Gateway

Receiving messages

Sending messages

Gateway:

Testing it

Conclusion

NodeJS Non-Blocking Processing

NodeJS Non-Blocking Processing

The problem

The Solution

How to create a NodeJS FAQ Chatbot

Creating a FAQ Chatbot

Introduction

Conversation Flow

Building it

Declaring our Chatbot

Organizing our dialogs

Writing the dialogs

Root dialog (/dialogs/root-trailing.js):

Intent dialog (/dialogs/intent-incoming.js):

FAQ dialog (/dialogs/faq-trailing.js):

Bye dialog (/dialogs/bye-trailing.js):

Message Gateway

Receiving messages

Sending messages

Gateway:

Testing it

Conclusion

Root dialog (`/dialogs/root-trailing.js`):

Intent dialog (`/dialogs/intent-incoming.js`):

FAQ dialog (`/dialogs/faq-trailing.js`):

Bye dialog (`/dialogs/bye-trailing.js`):

Root dialog (`/dialogs/root-trailing.js`):

Intent dialog (`/dialogs/intent-incoming.js`):

FAQ dialog (`/dialogs/faq-trailing.js`):

Bye dialog (`/dialogs/bye-trailing.js`):