In this tutorial, we will build a WhatsApp chatbot powered by AI, capable of conversational question and answering (QA). This type of chatbot is a generative chatbot, in contrast to the more common retrieval based chatbot. To create the WhatsApp bot, we will use Mantium’s Python library, Twilio WhatsApp API, and the Flask framework. The Mantium API enables us to get a generative response, as it supports and provides access to OpenAI’s GPT-3 model.
Chatbots are applications that generate and process written or spoken human conversations in a way that allows interactions with digital devices as if they were conversing with actual people. You may have interacted with a chatbot recently while browsing websites on the internet. You probably noticed that the chatbot automatically engages you in a pleasant manner while trying to help achieve the objective of your visit to the site.
Chatbots have seen great applications in businesses, such as automating customer interactions, improving sales channels, etc., and they are becoming a lot smarter. They are capable of handling near-human-level interactions.
With recent advancements in the field of natural language processing (NLP), it is easier to solve language-based tasks such as generating and classifying text. It becomes even easier to use with Mantium, as they provide the development support needed to build effectively with large language models. If you are wondering what OpenAI’s GPT-3 model is, it is the third generation prediction model that OpenAI created, and it has a capacity of 175 billion machine learning parameters.
With Mantium, we will use this to build a conversational QA WhatsApp bot in just a few lines of code. You don’t need to have a solid knowledge of machine/deep learning to build a use case with Mantium.
To follow this tutorial you need the following;
The first and essential step is to design the prompt (task) with the Mantium Platform. Prompt design is our way of guiding the GPT-3 model to give a favorable and contextual response as it enables us to provide a text input and get a generative response from the model. Think of this like you are playing the game of charades where you give the players information to figure out the secret word. Similarly, with GPT-3, we provide just enough information for the model to recognize patterns in the training prompt.
To do this, you don’t need to have prior machine learning experience, and almost anyone can do this in a No-Code approach to build a simple text application using the Mantium Platform.
I will break this into more straightforward steps that you can follow.
Visit app.mantium.com to create an account.
To access the GPT-3 model through the OpenAI API, you must connect your OpenAI API key on the Mantium Platform. Click on AI Providers, click Add API Key on the left sidebar, and paste your OpenAI key. Notice that Mantium supports other AI providers such as Cohere, AI21 that you can connect with their respective API keys, but for this tutorial, we build with OpenAI.
If you don’t have your API key for any of the AI Providers, view this documentation to learn how you can get one.
The next step is to add a new prompt. Navigate to the AI Manager drop down tab on the left sidebar, click on Prompts, and click on the Add new prompt button, as shown below.
Here, we will provide the information to build our training prompt.
Let’s fill in the basic information to identify our prompt. Note that you can provide any name and description.
Name of Prompt – WhatsApp Chatbot
Description – This is a WhatsApp bot
In this tutorial, we are using the OpenAI API, select OpenAI from the drop-down.
Human: Hello, who are you? AI: I am an AI created by Blessing. How can I help you today? ### Human: What is a language model? AI: A language model is a statistical model that describes the probability of a word given the previous words. ### Human: What is Cryptocurrency? AI: A cryptocurrency (or “crypto”) is a digital currency that can be used to buy goods and services, but uses an online ledger with strong cryptography to secure online transactions. ### Human: What country won the 2010 world cup? AI: Spain ### Human: How many pounds are in a kilogram? AI: There are 2.2 pounds in a kilogram. ### Human: When did the first airplane fly? AI: On December 17, 1903, Wilbur and Orville Wright made the first flights. ### Human: How can I learn swimming? AI: There are many ways you can learn to swim. The first thing you can do is talk to your parents and ask if they know any instructors. You can also look online to find a class that you can take in your area. ### Human:
Copy and Paste this in the Prompt Line input field.
3. Choose an Engine – The OpenAI engine determines the language model used to execute tasks. OpenAI supports various models with varying capabilities. These models are described and accessed using engines. For this tutorial, select the “Davinci” Engine.
Here you will provide the basic settings for the OpenAI model. See image below.
Response Length - 150 Temperature - 0.9 Top P - 1 Frequency Penalty - 0.5 Presence penalty - 0.6 Stop Sequence - ###
We can leave the Advanced settings to the default value for this tutorial.
For more information about these settings, you can read this tutorial by Mantium.
On the Mantium Platform, we will use the Input field to test our prompt. See the image below. I asked the question, “How can I learn Machine Learning”, and I got an interesting response.
Fill in the input field, and hit the Test run button.
Congratulations on completing the first essential step! Note that you can do the above step in code by using the Mantium API/Client Library, but I chose to explain the no-code approach to give you that first understanding and easy debugging.
With Mantium’s Deploy feature, you can quickly generate a single-page application that you can share with your friends or colleagues to test your chatbot. Our end goal, however, is to create a WhatsApp chatbot. So, in subsequent steps, we will grab this prompt using Mantium’s Client Library and integrate it with the Twilio WhatsApp API in Python.
For this tutorial we will use the Twilio WhatsApp Sandbox, where will develop and test our WhatsApp bot application.
Create an account with Twilio, and visit the Twilio Console, where you will click on Explore Products and select Messaging.
Navigate to the side bar, under Messaging and Settings, select the WhatsApp sandbox settings.
Connect your sandbox by sending a WhatsApp message with the given code to the number assigned to your account. Twilio will send a reply stating that your sandbox is set, and you can complete the Two-way setup by sending “Hello”.
You can share the number assigned to your account for others to connect, and test your application in the Sandbox.
The last step is to configure the sandbox, which we will come back to.
Here we are going to write Python code to build the WhatsApp chatbot. The process is easy. We will build and test our application with a few lines of code. We are going to take the user input (Your WhatsApp incoming message), pass the message as an input through the Mantium execute prompt method, which sends this request to the model and returns a response. This response is processed by Twilio, and it is returned as a reply on your WhatsApp application.
To better understand what we are trying to achieve, see the illustration below.
Let’s write some code!
Create a Python virtual environment by using the command below:
$ mkdir whatsapp-bot $ cd whatsapp-bot $ python -m venv whatsapp-bot-venv $ source whatsapp-bot-venv/bin/activate
After this, create a file named app.py in the root directory of the whatsapp-bot folder.
Mantium has provided a Python client library to improve the developer’s experience, and we will use that in this tutorial.
Using the command below, install the Python client library.
pip install mantiumapi
Here you will authenticate by providing your log in credentials in an environment variable.
With the command below, install python-dotenv.
pip install python-dotenv
After this, create a .env file to store your credentials. Input your login credentials as shown below.
In app.py , you will use the code below to authenticate your Mantium account and create a prompt. Notice that I imported the Mantium prompt method, more on that later.
from mantiumapi import prompt from mantiumapi import client from dotenv import load_dotenv # load Mantium credentials load_dotenv() mantium_user = os.getenv("MANTIUM_USER") mantium_password = os.getenv("MANTIUM_PASSWORD") #Mantium Token mantium_token = client.BearerAuth().get_token()
Here is the link to the Mantium GitHub repository for more.
Here we need to install the Flask framework, to create the web application, and Twilio Python Helper Library to work with Twilio APIs.
pip install twilio flask
Now let’s setup webhook with the Flask framework. We will create an endpoint that listens to POST requests, and when Twilio receives the incoming message they will invoke this endpoint. The body of the function is what processes the input message, and provides a response after Mantium executes the input.
Here is a starter template, in this we will input the body of the bot function.
from flask import Flask, request # Init Flask App app = Flask(__name__) @app.route('/') def hello(): return "Welcome to Mantium WhatsApp Bot" @app.route('/bot', methods=['POST']) def bot(): # send input to Mantium and return a response if __name__ == '__main__': app.run()
from flask import Flask, request # Init Flask App app = Flask(__name__) @app.route('/') def hello(): return "Welcome to Mantium WhatsApp Bot" @app.route('/bot', methods=['POST']) def bot(): incoming_msg = str(request.values.get('Body', '').lower()) print(incoming_msg) responded = False if type(incoming_msg) == str: qa_prompt = prompt.Prompt.from_id('98b58a5d-12ff-4e64-868e-4dabf986eac7') result = qa_prompt.execute(incoming_msg) result.refresh() prompt_result = str(result.output) else: prompt_result = 'Check your Input and try again' resp = MessagingResponse() msg = resp.message() msg.body(prompt_result) responded = True return str(resp) if __name__ == '__main__': app.run(debug=True)
Let me explain the code above.
Input message – This gets the user WhatsApp input message
incoming_msg = str(request.values.get('Body', '').lower())
You need your Prompt ID. Remember the prompt that we created above. Let’s grab the ID. The easiest way to get this is to use the URL of the prompt editing page . See the link below, the last string is your prompt ID.
Using the from_id method, retrieve the prompt from Mantium.
qa_prompt = prompt.Prompt.from_id('98b58a5d-12ff-4e64-868e-4dabf986eac7')
Here we will send the Prompt to the OpenAI API endpoint, and we will get the response from the GPT-3 model. You need to refresh because this is asynchronously done to get a result.
result = qaPrompt.execute(incoming_msg) result.refresh() prompt_result = str(result.output)
Twilio expects a response from the webhook in TwiML or Twilio Markup Language, which is an XML-based language format. With the Twilio helper library, we can easily create this response without having to create XML directly.
from twilio.twiml.messaging_response import MessagingResponse resp = MessagingResponse() msg = resp.message() msg.body('this is the response text')
This is the full code.
import os from flask import Flask, request from twilio.twiml.messaging_response import MessagingResponse from dotenv import load_dotenv # load Mantium credentials load_dotenv() mantium_user = os.getenv("MANTIUM_USER") mantium_password = os.getenv("MANTIUM_PASSWORD") from mantiumapi import prompt from mantiumapi import client # Mantium Token mantium_token = client.BearerAuth().get_token() # Init Flask App app = Flask(__name__) @app.route("/") def hello(): return "Welcome to Mantium WhatsApp Bot" @app.route("/bot", methods=["POST"]) def bot(): incoming_msg = str(request.values.get("Body", "").lower()) print(incoming_msg) responded = False if type(incoming_msg) == str: qaPrompt = prompt.Prompt.from_id("98b58a5d-12ff-4e64-868e-4dabf986eac7") result = qaPrompt.execute(incoming_msg) result.refresh() prompt_result = str(result.output) else: prompt_result = "Check you input and try again" resp = MessagingResponse() msg = resp.message() msg.body(prompt_result) responded = True return str(resp) if __name__ == "__main__": app.run(debug=True)
Run the command below to start the chatbot, and it will run at port 5000 on your local machine. See the image below.
Localtunnel is a simple tool that provides a publicly-accessible URL that reroutes every request to the locally-running service. It exposes our localhost to the world for easy testing and sharing, which we need to connect the URL to Twilio (Remember the step that we skipped when configuring the Twilio sandbox)
You can create another terminal beside the initial terminal, and install the Localtunnel tool. Use the command below.
npm i localtunnel
After this, run the command below and the browser window below automatically pops up. I can see that the app is working.
Take note that my app is running on port 5000.
lt --port 5000 --subdomain shan --local-host "127.0.0.1" -o --print-requests
On the Twilio Console, paste the URL below in the WHEN A MESSAGE COMES IN field, since our WhatsApp chatbot is exposed under the /bot URL. After this, click on the Save button.
URL – https://shan.loca.lt/bot
Now that the configuration is all done and the server is running, it’s time to test the WhatsApp bot.
You can use the Mantium’s Log feature to check the output and status of your prompt. This can come in handy when you are not getting any reply to your WhatsApp message.
Navigate to the Monitoring tab on the left-side, click on Logs.
The goal of the prompt for for this chatbot was to show the possibilities of large language models(LLM), and how you can use the Mantium API integrated with Twilio’s API to build something interesting. There are lot of ways that you can spin this tutorial to build custom use cases. Examples include Intelligent Customer Service bot and Virtual AI assistant etc.
This article was originally published on Analytics Vidhya.
To learn how to build an SMS Chatbot with Twilio, click here!
Most recent posts