Building an OpenAI-Powered Chatbot using Python and Jupyter Notebooks

Welcome to a step-by-step guide on creating an intelligent chatbot powered by OpenAI using Python and Jupyter Notebooks. In this tutorial, we’ll cover the fundamental concepts and guide you through the process of building a simple yet effective chatbot that leverages the power of OpenAI’s language model.

Prerequisites

Before we begin, make sure you have the following installed:

Python (version 3.6 or higher)
Jupyter Notebooks
OpenAI API key (sign up at https://beta.openai.com/signup/ to get one)

Step 1: Set Up Your Environment

Install OpenAI with pip:

pip install openai

1	pip install openai

Install JupyterLab with pip:

pip install jupyterlab

1	pip install jupyterlab

Now launch JupyterKab with:

jupyter notebook

1	jupyter notebook

Step 2: Set Up OpenAI API

Start by importing the OpenAI library and setting up your API key:

Step 3: Set the initial context for the chatbot

Our chatbot will inspire us for the work week, so we need to inform it about its purpose. That sets the stage for it to respond appropriately with our purpose in mind.

Step 4: Generate Responses

To interact with OpenAI’s language model, use the openai.chat.completios.create method. First we need to simulate a user asking a question. That is where the code sets up the user role and related content. In the real world imagine this is the text coming from the user.

Run the code now, and you should see some text such as what i got

Step 5: Ask the next question

Have the user ask the next question

This should be enough to illustrate the chatbot code. Next lets refactor the code to run in a loop so you have your interactive chatbot

Step 6: Build the Chatbot loop

Change the code to this to build the loop. Type exit to get out of the loop

import os
import openai
from openai import OpenAI

# pull in your API key
os.environ['OPENAI_API_KEY'] = 'your api key gere'

# setup the openapi client interface
client = OpenAI()
OpenAI.api_key = os.getenv('OPENAI_API_KEY')

# tell the chatbot what its purpose is about
messages = [
    {"role": "system", "content" : """You are my weekly mental health doctor and will help me maintain a positive mindset. 
            You will fill me with realistic and optimistic advice to get me through the work week. 
            Remember that I work from 9am to 6pm and rest of the day is with my family."""}
]

def generate_response(user_message):
    try:
        response = client.chat.completions.create(
            model = "gpt-3.5-turbo",
            messages = messages,
            max_tokens = 150,
            temperature = 0.6
        )

        # append previous response to chatbot so it remembers the conversation when answering the next message
        messages.append( {
            "role" : "assistant",
            "content": response.choices[0].message.content
        })
        return response.choices[0].message.content
    except Exception as ex:
        print (f"Got an error from the OpenAPI API call {ex}")

print("Chatbot: Hello! Type 'exit' to end the conversation.")

while True:
    user_input = input("You: ")
    if user_input.lower() == 'exit':
        break
    response = generate_response(user_input)
    print(f"Chatbot: {response}")

import os

import openai

from openai import OpenAI

# pull in your API key

os.environ['OPENAI_API_KEY'] = 'your api key gere'

# setup the openapi client interface

client = OpenAI()

OpenAI.api_key = os.getenv('OPENAI_API_KEY')

# tell the chatbot what its purpose is about

messages = [

{"role": "system", "content" : """You are my weekly mental health doctor and will help me maintain a positive mindset.

You will fill me with realistic and optimistic advice to get me through the work week.

Remember that I work from 9am to 6pm and rest of the day is with my family."""}

]

def generate_response(user_message):

try:

response = client.chat.completions.create(

model = "gpt-3.5-turbo",

messages = messages,

max_tokens = 150,

temperature = 0.6

)

# append previous response to chatbot so it remembers the conversation when answering the next message

messages.append( {

"role" : "assistant",

"content": response.choices[0].message.content

})

return response.choices[0].message.content

except Exception as ex:

print (f"Got an error from the OpenAPI API call {ex}")

print("Chatbot: Hello! Type 'exit' to end the conversation.")

while True:

user_input = input("You: ")

if user_input.lower() == 'exit':

break

response = generate_response(user_input)

print(f"Chatbot: {response}")

Step 7: A few terms explained

Took the liberty of using chatgpt to generate some explanation of basic terms that are good to know.

Tokens and Token Limit – The model processes text in chunks called tokens. Both input and output tokens count towards usage. The total number of tokens affects the cost, response time, and whether a request fits within the model’s maximum limit.
max_tokens – ‘Max tokens’ can be used to limit the response length
temperature – The ‘temperature’ parameter controls the randomness of the model’s output. Higher values (e.g., 0.8) make the output more creative, while lower values (e.g., 0.2) make it more focused and deterministic.
model versions – OpenAI may release different versions of language models. The API allows you to specify the model version you want to use. Keep an eye on updates and choose the appropriate version based on your requirements.
Context and Memory – The model has a limited context window, so very long conversations may lead to important context being cut off. Be mindful of the token limit and adjust your conversation accordingly.
System Messages – System level instructions can be provided to guide the model’s behavior throughout the conversation.

Step 8: References

Text generation Models – https://platform.openai.com/docs/guides/text-generation/chat-completions-api
Models – https://platform.openai.com/docs/models

{"Mat's Random Thoughts"}

Mathew's Tech Notes..