Build a WhatsApp AI-Powered Chatbot with GPT-3, using Mantium & Twilio API
In this tutorial, we will build a WhatsApp AI-powered bot capable of conversational question and answering (QA). This type of bot is a generative chatbot, in contrast to the more common retrieval-based chatbot.
To create the bot, we will use Mantium’s Python library, Twilio WhatsApp API, and the Flask framework. The Mantium App/API enables us to get a generative response, as it supports and provides access to the OpenAI’s GPT-3 model.
Any questions? Join the Mantium’s Discord Channel
Below is what we are going to build at the end of this tutorial.
Chatbots are applications that replicate 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 and non-confrontational 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, sales channels, etc., and they are becoming a lot smarter. They are capable of handling almost human-level interactions.
With recent advancements in the Natural language processing(NLP) field, which is developing the GPT-3 model by OpenAI in 2020, 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 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;
- A Mantium Account
- An OpenAI API Key
- Twilio Account
- Flask Framework
- Local Tunnel
- A smartphone with an active WhatsApp Account
Prompt Design with the Mantium App
The first and essential step is to design the prompt (conversational text generation task) with the Mantium App. 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 deep learning experience, and almost anyone can do this in a No-Code approach to build a simple text application using the Mantium interactive UI.
I will break this into more straightforward steps that you can follow.
Step 1 — Register for a Mantium Account
Visit the app.mantium.com website to create a free account.
Step 2 — Connect your OpenAI API key.
To access the GPT-3 model through the OpenAI API, you must connect your OpenAI API key on the Mantium App.
AI Providers, paste your OpenAI and click
Add API Key. Notice that Mantium supports other
AI providers such as Cohere, AI21, you can connect with their respective
API keys, but for this tutorial, we build with the OpenAI's model.
If you don’t have your API key for any of the
AI Providers , here is documentation on how you can get one.
Step 3 — Add New Prompt
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.
Step 4 — Prompt Design
Here, we will provide the information to build our training prompt.
A. Basic Info
Let’s fill in the basic information to identify our prompt. Note that you can provide any name and description.
Name of Prompt — Chatbot
Description — This is a chatbot
In this tutorial, we are using the OpenAI API, select
OpenAI from the drop-down.
C. OpenAI Info
- Choose an Endpoint — Select the
Completionendpoint. This endpoint provides the model with some text and generates a text completion that tries to fit the context of the provided text.
- Prompt Line — Here we are going to provide the model with examples, and it will figure out the patterns to perform the given task. See below a Prompt that I designed for our conversational QA generative task.
- 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.
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?
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.
Copy and Paste the above in the
Prompt Line input field.
D. Basic Settings
Here you will provide the basic settings for the OpenAI model, see the image below.
- Response Length — 150
- Temperature — 0.8
- Top P — 1
- Frequency Penalty — 0.5
- Presence penalty — 0.6
- Stop Sequence — ###
Basic Settings Explanations.
- Response Length — The response length sets a limit on how much text the OpenAI API includes in its completion. Take note of your response length, as OpenAI charges by the token, where one token is roughly 4 words. The max tokens controls the length of your completion and your prompt plus completion can’t add up to more than 2,049 tokens. For this example, on the Mantium App, input
150as your response length.
- Temperature & Top P — The temperature controls the randomness of the response; it is one of the most important settings as it significantly impacts the output. Increase the temperature if you want more creative completions or if you want to let the model go off on a tangent. Decrease the temperature if you want the model to follow instructions or remain factual. Note that, If you alter the temperature, it’s recommended to not alter top_p as it defaults to 1. Set the value to
- Frequency Penalty — This prevents word repetition. If you notice the output of a model is repeating the same word, and you want it to stop repeating the same word, increase the
- Presence Penalty — The presence penalty prevents topic repetition. If you notice the output of a model is stuck on a particular topic, and you want it to talk about something else, try increasing the presence_penalty
- Stop Sequence — A stop sequence is a set of characters that signal the API to stop generating tokens.
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.
Step 5 — Testing Prompt Results
On the Mantium App, we will use the Input field to test our prompt. See the image below, I asked the question
How can I learn Machine Learing? and I got an interesting response. (See below)
Fill the input field, and hit the
Test run button.
Congratulations on completing the first step and an 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 one-page application you can share with your friends to test your chatbot, but we intend to create a WhatsApp application. So, in subsequent steps, we will grab this prompt using Mantium’s Client Library and integrate it with the Twilio WhatsApp API in Python.
Configure the Twilio WhatsApp Sandbox
For this tutorial, we will use the Twilio WhatsApp Sandbox, where will develop and test our chatbot application.
Step 1 — Create an Account
Create an account with Twilio, and visit the Twilio Console, where you will click on
Explore Products and select
Step 2 — Setup Sandbox
Navigate to the sidebar, 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” on your WhatsApp.
Note that, 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.
Let’s Build the Chatbot!
Here we are going to write Python code to build the WhatsApp chatbot. The process is easy. We will develop and test our application with a few lines of code. We will 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. Twilio processes this response, and it is returned as a reply on your WhatsApp.
If you are still unclear on what we are trying to achieve, see the illustration below.
Let’s write some code!
Step 1 — Setup a Python Virtual Environment.
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
Step 2 — Setup Mantium’s Client Library
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 login credentials in an environment variable.
With the command below, install
pip install python-dotenv
After this, create a
.env file to store your credentials. Input your login credentials as shown below.
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.
Here is the link to the Mantium GitHub repository for more. If you are interested you can contribute to the development of the library.
Step 3 — Setup Webhook with Flask Framework
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 set up a 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
Step 4 — Send Input to Mantium, and Return a Response.
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.
from_id method, retrieve the prompt from Mantium.
qa_prompt = prompt.Prompt.from_id('<your-prompt-id>')
Execute the Input and Get Result
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)
prompt_result = str(result.output)
Step 5 - Twilio Messages and Response
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. Below explains how we can do that.
from twilio.twiml.messaging_response import MessagingResponse
resp = MessagingResponse()
msg = resp.message()
msg.body('this is the response text')
Putting everything together
This is the full code
Testing the Chatbot.
Step 1 — Run the
Run the command below to start the chatbot, and it will run at port 5000 on your local machine. See the image below.
Step 2 — Local Tunnel
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, and ensure that NPM is installed.
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
lt --port 5000 --subdomain shan --local-host "127.0.0.1" -o --print-requests
Step 3 — Configure Twilio Sandbox
On Twilio Console, paste the URL below in the
WHEN A MESSAGE COMES IN field, since our chatbot is exposed under the
/bot URL. After this, click on the
URL — https://shan.loca.lt/bot
Step 4 — Send and Receive Messages
Now that the configuration is all done and the server is running, it’s time to test the chatbot.
Here, I decided to ask some random questions, since I didn’t design the prompt for a specific use case. See images below.
You can see that we got responses that weren’t in the Prompt.
Logging with Mantium
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
While I didn’t design the prompt for any particular use case, I aimed to show the possibilities of a large language model(LLM) and how to use the Mantium API integrated with Twilio’s API to build something interesting. There are many ways that you can spin this tutorial to build custom use cases; examples include but are not limited to Intelligent Customer Service bots, Virtual AI assistants etc.
I hope this tutorial was helpful, and you learnt about what you can do with Mantium & Large Language Model. If you have something to build in mind, you can reach out to me via LinkedIn
Any questions? Join the Mantium’s Discord Channel