In this article, you will learn how to build a Fitness and diet chatbot using Python, FaunaDB, OpenAI, and Twilio. The chatbot will be able to communicate with you via WhatsApp and provide responses based on your conversation history. You'll be walked through the code and understand the key components and libraries involved in the process.
Prerequisites
Before you begin, make sure you have the following:
- Python 3.x installed on your machine
- FaunaDB account and API key
-
OpenAI API key to access the
gpt-3.5-turbo
model - Twilio account SID, auth token, and a phone number
- Ngrok: It allows us to expose our local Flask server to the internet.
Setting Up the Fauna database
To begin using Fauna, your initial step is to establish an account on the official website. This can be accomplished by providing your email address or utilizing your GitHub or Netlify account through the following link: Fauna. For efficient communication with the chatbot, it is necessary to utilize the Fauna database for storing and retrieving user messages.
Creating the database
After creating your account with fauna, you will be creating a database to store the Users
and Messages
. Here you'd be asked for the database name and you are going to name it MyChatBot
and the region is going to be set to Classic
and like that you've created your database. Then, you should be presented with a screen like this one below:
Creating your collection
Next, you will be creating 2 collections, which is basically Tables
in the SQL world but with a twist in our context.
To create your Collection, click on the Create Collection
button on the home page and give it a name, but since you'd be creating the two collections will be naming them Users
and Messages
. The "Users" collection is for storing the user's username from WhatsApp, while the Messages
collection is for storing the user's chat history with the bot. You will be asked for History Days
and TTL
. The History Days is used to define the number of days Fauna should retain a historical record of any data in that particular collection while the TTL serves as an expiry date for data in the collection. For example, if the TTL is set to 7, any data stored in that collection will be automatically deleted 7 days after its last modified date, but for this tutorial you'll not be needing it so it will be left untouched. After creating the two collections, you should be seeing this:
Creating the Index
Wondering what an Index is?, Well an Index is simply a way to browse data in a collection more efficiently by organizing it based on specific fields or criteria, allowing for faster and targeted retrieval of information. To create your Index, you'll navigate to the Index tab and you should see something like this:
To create the Index, you first of all need to Select a Collection
, then specify the Terms
, which is the specific data the Index is only allowed to browse. But for this you will be creating two Indexes, users_by_username
which would be under the Users
collection for registering users and users_message_by_username
which would be filtering the user's messages by their username. The Terms
for users_by_username
and users_messages_by_username
would be set to data.username
will be set to data.username
, then click SAVE
to continue.
Getting our Database key
Before you proceed to building the ChatBot, you need to create an API key that would allow your application to easily communicate with your database. To create an API key, you need to navigate to the security tab on the Fauna sidebar (on the left side of the screen).
Next, you will click on the NEW KEY
button that will navigate you to the page below:
Here, your key role would be set to Server
instead of Admin
and set your Key name to our database name which is optional, then click on SAVE
and you'd be navigated to a page where your database key would be displayed and meant to be copied immediately. You should see something like this:
After getting the API KEY
, store it in the .env file in your coding environment.
Configuring Twilio
In order to demonstrate the procedure, you will set up your Twilio account to use WhatsApp by making use of the Twilio Sandbox for WhatsApp. To access the WhatsApp Sandbox in your Twilio Console, navigate to the Messaging section located on the left sidebar (if you can't see it, click on Explore Products to unveil the product list, where you can locate Messaging). Afterward, expand the "Try it out" dropdown and choose "Send a WhatsApp message" from the available choices. Subsequently, you will be presented with the following display:
After scanning the QR code, you will immediately receive a "join disease-see" message on your WhatsApp. Simply send the message, and just like that, you will be connected to your WhatsApp account.
Setting up the Environment
First, create an app.py file in your coding environment then you have to install the necessary libraries. You need to install faunadb
, openai, python-dotenv
, twilio
, and flask
libraries. You can use the following command to install them:
pip install telebot faunadb openai python-dotenv twilio flask
Once the libraries are installed, you can proceed to the code implementation.
Importing Libraries
Let's start by importing the required libraries in your Python script:
import telebot
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient
import openai
from dotenv import load_dotenv
from twilio.rest import Client
import os
from flask import Flask, request
from twilio.twiml.messaging_response import MessagingResponse
You need to import faunadb
for integrating FaunaDB, openai
for utilizing OpenAI's gpt-3.5-turbo
model, dotenv
for loading environment variables, twilio
for sending and receiving WhatsApp messages, os
for accessing environment variables, flask
for creating a web server, and twilio.twiml.messaging_response
for generating TwiML responses.
Initializing Flask App and FaunaDB Client
Let's initialize the Flask app and create a FaunaDB client:
app = Flask(__name__)
def prompt(username, question):
load_dotenv()
client = FaunaClient(secret=os.getenv('FAUNA_SECRET_KEY'))
# ...
You create a Flask app using the Flask(__name__)
constructor. Inside the prompt
function, you load the environment variables using load_dotenv()
and create a FaunaDB client using the provided secret key.
Storing User Messages in FaunaDB
Within the prompt
function, you store user messages in FaunaDB using the FaunaDB client:
data = {
"username": username,
"message": {
"role": "user",
"content": question
}
}
result = client.query(
q.create(
q.collection("Messages"),
{
"data": data
}
)
)
You create a dictionary data
containing the username
and the user's question
. Then you use the client.query
method to create a new document in the "Messages" collection, storing the data
dictionary.
Retrieving User Messages from FaunaDB
You retrieve the user messages from FaunaDB by querying the database based on the username
:
index_name = "users_message_by_username"
username = username
result = client.query(
q.map_(
lambda ref: q.get(ref),
q.paginate(q.match(q.index(index_name), username))
)
)
messages = []
for document in result['data']:
message = document['data']['message']
messages.append(message)
You specify the index_name
for the index to query from FaunaDB. Then you use q.paginate
and q.match
to retrieve all the documents associated with the given username
. You loop through the result and extract the message
content, storing it in the messages
list.
Setting up OpenAI API
Let's set up the OpenAI API and define the assistant's persona:
openai.api_key = os.getenv('OPENAI_API_KEY')
system_message = {"role":"system", "content" : "You are a dietitian, food nutritionist, and fitness consultant, you provide expert guidance and advice to individuals facing dietary challenges or seeking direction on their food choices and exercise routines. You offer personalized recommendations and solutions to those who are unsure about the right foods to eat or the appropriate exercises to engage in. If user says hello or any greeting introduce yourself."}
prompt_with_persona = [system_message] + [
{"role": "user", "content": message["content"]} if message["role"] == "user"
else {"role": "assistant", "content": message["content"]} for message in messages
]
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=prompt_with_persona
)
generated_reply = response["choices"][0]["message"]["content"]
You set the OpenAI API key using os.getenv('OPENAI_API_KEY')
from the .env file as created earlier. Then you define a system_message
dict representing the assistant's persona. You construct the conversation prompt by combining the system_message
with the user and assistant messages from the messages
list.
Afterward, you make an API call to the OpenAI ChatCompletion API using openai.ChatCompletion.create()
, passing the conversation prompt as the messages
parameter. The API response contains the generated reply from the model, which you extract and store in the generated_reply
variable.
Storing Assistant's Reply in FaunaDB
You store the assistant's reply in FaunaDB using the FaunaDB client:
newdata = {
"username": username,
"message": {
"role": "assistant",
"content": generated_reply
}
}
result = client.query(
q.create(
q.collection("Messages"),
{
"data": newdata
}
)
)
You create a new dictionary newdata
containing the username
and the assistant's generated_reply
. Then you use the client.query
method to create a new document in the "Messages" collection, storing the newdata
dictionary.
Handling WhatsApp Messages
Now, let's implement the route for handling WhatsApp messages:
@app.route('/whatsapp', methods=["POST", "GET"])
def chat():
load_dotenv()
twilio_phone_number = os.getenv('TWILIO_PHONE_NUMBER')
sender_phone_number = request.values.get('From', '')
username = request.values.get('ProfileName')
question = request.values.get('Body')
account_sid = os.getenv('TWILIO_ACCOUNT_SID')
auth_token = os.getenv('TWILIO_AUTH_TOKEN')
Twilioclient = Client(account_sid, auth_token)
client = FaunaClient(
secret=os.getenv('FAUNA_SECRET_KEY')
)
reply = None
user_exists = client.query(
q.exists(q.match(q.index("users_by_username"), username)))
if user_exists:
reply = prompt(username, question)
answer = Twilioclient.messages.create(
body=reply,
from_=twilio_phone_number,
to=sender_phone_number
)
else:
client.query(
q.create(
q.collection("Users"),
{
"data": {
"username": username
}
}
)
)
reply = prompt(username, question)
answer = Twilioclient.messages.create(
body=reply,
from_=twilio_phone_number,
to=sender_phone_number
)
return str(answer.sid)
Inside the /whatsapp
route, we load the environment variables, retrieve the necessary data from the incoming request, and create the Twilio and FaunaDB clients. We check if the user exists in FaunaDB using q.exists
and q.match
. If the user exists, we call the prompt
function to generate a reply and send the reply back to the user using Twilio's messages.create()
method. If the user doesn't exist, we create a new document in the "Users" collection and follow the same process as above.
Running the Flask App
Finally, let's run the Flask app:
if __name__ == '__main__':
app.run(debug=True)
We use the if __name__ == '__main__':
conditional statement to ensure that the app only runs if the script is executed directly, not imported as a module. The debug=True
is set to in order to enable debug mode for better error messages during development. Now run python app.py
in your terminal, it will run on localhost:5000
. You can now go ahead to ngrok and run ngrok http 5000
.
Copy the circled link and paste it in your WhatsApp sandbox
There you have it, you now have your own personal WhatsApp fitness and diet bot
Conclusion
In this article, you learned how to build a chatbot using Python, FaunaDB, OpenAI, and Twilio. We covered the code step by step, from initializing the Flask app to handling WhatsApp messages and generating responses using OpenAI's ChatCompletion API. You can use this code as a starting point to develop your own chatbot with additional features and integrations.
Happy Building!!
Top comments (1)
Good job Feranmi