See More

How To Build Your Personal AI Chatbot Using the ChatGPT API

9 mins
Updated by Artyom Gladkov
Join our Trading Community on Telegram

Building your own AI chatbot may sound intimidating if your coding game isn’t quite on point. But fear not; OpenAI’s ChatGPT API offers a handy shortcut.

OpenAI’s API gives you access to its language model. So, you can create a chatbot that doesn’t just spit out robotic answers but gives the vibe of a real conversation. In this guide, we will explore one of the easiest ways to build your own ChatGPT chatbot using OpenAI API.

Before you build your AI chatbot with ChatGPT

Before you build your AI chatbot, here are a few things to take note of. Whether you’re on Windows, macOS, Linux, or ChromeOS, the procedure of building an AI chatbot is more or less the same. 

We will demonstrate the process on a Windows machine, breaking down each step with clear instructions and illustrative examples. So, even if your computer knowledge is just above the “turn it off and on again” level, you’ll find it relatively straightforward to develop your own AI chatbot. 

And finally, don’t sweat about hardware requirements; there’s no need for a high-end CPU or GPU. OpenAI’s cloud-based API handles all the intensive computations.

How to build your own chatbot with ChatGPT API

Before diving into creating a ChatGPT-powered AI chatbot, there are some essential tools you’ll need to get your environment up and running. At a glance, the list includes Python, Pip, the OpenAI and Gradio libraries, an OpenAI API key, and a code editor, perhaps something like Notepad++. Let’s get started.

Install Python

To start, you’ll want to set up Python on your computer, ideally opting for one of its recent versions. Head to the official Python website’s download section to grab the 32- or 64-bit Windows installer, depending on the Windows version installed on your computer.

Once you’ve downloaded the installer, launch it to initiate the setup. A quick tip: during the installation, select the option “Add Python XX to PATH,” where “XX” stands for the version you’re setting up. This will help your system locate Python effortlessly. With that done, click on “Install Now.”

download on windows

To verify that Python is up and running in your system, do the following:

  • Open the Start menu and look for “Command Prompt” or “CMD”.
  • When the terminal pops up, input “python –version” and press Enter.

If Python was installed correctly, the terminal will display the Python version you’ve installed, as illustrated in the screenshot below.

python installed

Upgrade Pip

Pip is Python’s package manager, essential for installing and managing Python libraries and dependencies. Keeping it updated ensures you benefit from the latest features and fixes, which is crucial when setting up libraries for your AI chatbot.

To check your current Pip version:

  • Launch a command prompt (for Windows) or terminal (for macOS/Linux).
  • Input the command: pip –version to see the current version.

To get the latest Pip version, execute the command: python -m pip install –upgrade pip

We already have the latest pip version installed on the computer we are using, which is why we got the following notification: “Requirement already satisfied.”

However, if an update is available, pip will automatically handle the download and installation. Once the process is over, double-check the Pip version with the pip –version command to ensure the update was successful.

command prompt

Set Up a Virtual Environment

Setting up a virtual environment is a smart move before diving into library installations. It ensures your project’s dependencies don’t clash with your main Python setup. It is an optional step, but highly recommended.

To get started with virtualenv:

  • Install it using the command: pip install virtualenv
  • Next, head over to your project directory and initiate a virtual environment with: virtualenv venv
  •  Activate the virtual environment using the following command: .\venv\Scripts\activate

After activating the virtual environment, you’ll notice a small change. Your command prompt or terminal will now display the name of the virtual environment (in this case, “venv”) as a prefix. This indicates that you’re now operating in the special “venv” zone.

With these steps, you’ve successfully isolated your project, ensuring a smoother development experience.

Install Gradio and OpenAI libraries

Getting the OpenAI and Gradio libraries onboard is your next move. OpenAI is your gateway to the large language model you will be using to power your chatbot. Meanwhile, Gradio is a nifty open-source Python library that’s perfect for creating machine-learning interfaces. Here’s how you can get them using pip:

  • Install the Gradio library with the following command: pip install gradio
pip install gradio
  • Install the OpenAI library using the following command: pip install openai
pip install gradio 2 openai

Once you run these commands, Pip will fetch the required libraries from the Python Package Index (PyPI) and neatly set them up in your Python environment. You’re now just a couple of steps away from creating your own AI chatbot.

Install a code editor

Now that you have set up the backstage with the required software environment, it is time to get yourself a code editor. There are tons of options, but it’s essential to pick one that aligns with your needs and the languages you’re coding in.

Visual Studio Code (VS Code) is a good option that meets all your requirements here. It is a free, feature-packed code editor, and you can download it from the official Visual Studio portal.

Once it’s downloaded, launch the installer and let it guide you through the setup process. And just in case you do not like VS Code, other options worth considering include Notepad++, Sublime Text, PyCharm, and Atom, among others.

Grab your OpenAI API key

Now, you’re going to need an API key from OpenAI. For those out of the loop, consider this key as your backstage pass, unlocking ChatGPT’s prowess directly in your chatbot interface. 

  • Kick things off by heading to the OpenAI website: https://www.OpenAI.com/. Got an OpenAI account? Great, sign in. If not, no worries! Just sign up by filling in the necessary details.
  • Once you’re in, glance at the top-right corner and spot your profile icon. Give it a click. From the drop-down, select “View API keys”.
  • Here, tap on “Create new secret key”. When it’s generated, be quick to copy that API key. A heads-up: this is a one-time viewing opportunity. It’s a smart move to save it immediately.

Your OpenAI API Key is now ready and waiting. Guard it like it’s top-tier intel. It’s your private key, meant solely for you, and it’s not for public eyes. If you ever feel the need, you can ditch old keys and roll out fresh ones (you’re allowed up to a quintet of these).

Build your ChatGPT chatbot with this code

The moment of truth has arrived! We’re going to use OpenAI’s crème de la crème, the GPT 3.5 turbo model, which is the engine behind ChatGPT-3.5. 

GPT-3.5 turbo is a step up from Davinci and boasts training data up until September 2021. Not only does it give more bang for your buck, but it’s also snappier than its predecessors and has a wider context window. 

To keep things simple, we’re using Gradio to generate a sleek web interface that you can access both from your local machine as well as over the internet. Here’s what to do:

Launch VS Code (or your go-to code editor) and copy-paste the code below. 

The code:

import openai

import gradio as gr

import os

from datetime import datetime

from collections import defaultdict

# Use environment variable for API key

openai.api_key = os.getenv(“OPENAI_API_KEY”)

# Basic rate limiter

class RateLimiter:

    def __init__(self, max_requests, time_window):

        self.max_requests = max_requests

        self.time_window = time_window

        self.timestamps = defaultdict(list)

    def is_allowed(self, session_id):

        now = datetime.now()

        if session_id not in self.timestamps:

            self.timestamps[session_id].append(now)

            return True

        timestamps = self.timestamps[session_id]

        # Remove old timestamps

        self.timestamps[session_id] = [t for t in timestamps if (now – t).seconds <= self.time_window]

        if len(self.timestamps[session_id]) < self.max_requests:

            self.timestamps[session_id].append(now)

            return True

        return False

rate_limiter = RateLimiter(max_requests=5, time_window=60)  # Allow 5 requests per minute

# Store separate conversations for different user sessions

chat_sessions = {}

def chatbot(input, session_id):

    if not input:

        return “Please enter a message.”

    if not rate_limiter.is_allowed(session_id):

        return “Rate limit exceeded. Please wait for a while.”

    # Initialize session if not present

    if session_id not in chat_sessions:

        chat_sessions[session_id] = [

            {“role”: “system”, “content”: “You are a helpful and kind AI Assistant.”}

        ]

    session_messages = chat_sessions[session_id]

    session_messages.append({“role”: “user”, “content”: input})

    try:

        chat = openai.ChatCompletion.create(

            model=”gpt-3.5-turbo”, messages=session_messages

        )

        reply = chat.choices[0].message.content

        session_messages.append({“role”: “assistant”, “content”: reply})

    except Exception as e:

        reply = f”Error: {e}”

        print(f”Error for session {session_id}: {e}”)  # Basic logging

    return reply

inputs = gr.inputs.Textbox(lines=7, label=”Chat with AI”)

outputs = gr.outputs.Textbox(label=”Reply”)

gr.Interface(fn=chatbot, inputs=inputs, outputs=outputs, title=”AI Chatbot”,

             description=”Ask anything you want”,

             theme=”compact”, live=False, session=True).launch(share=True)

Alright, now let’s save the code for later use. Head to the “File” option in the top menu and give “Save As…” a click. Now, christen your file “chatbot.py” and for the “Save as type,” pick “All types.” Choose a convenient location in your hard drive to save the file (e.g., the Desktop). 

Securely connecting the code to your API key

Notice that “OPENAI_API_KEY” in the code above? That’s where your OpenAI key needs to be. 

For security reasons, it’s crucial not to hardcode sensitive information like API keys directly into your code. Hardcoding them makes your applications vulnerable and can lead to unintentional exposure if the code ever gets shared or published.

A safer approach is to use environment variables. These are external variables that your code can access but remain outside of the codebase. Here’s how you can implement this:

Set the environment variable:

Before diving into the script, you must first set the environment variable containing your API key. 

This typically happens outside of your Python script. For Windows users, go to Command Prompt and execute the following command. Note that if you close the previous Command Prompt window, make sure first to create and activate the virtual environment again using the steps described above.

setx OPENAI_API_KEY “YOUR_ACTUAL_API_KEY_HERE”

Replace YOUR_ACTUAL_API_KEY_HERE with your actual OpenAI API key.

By using the os.getenv() function, you can access the value of the environment variable you set earlier. Ensure the environment variable is correctly set before running your Python script.

Your AI chatbot is now ready to roll

In the final step, type in ‘python’ in Command Prompt, slap a space after it, then drop in your file path before hitting enter. In my case, the path is C:\Users\user\chatbot_x.py. Yours might be different depending on the directory you saved the code in.

python c:\Users\user\chatbot_x.py

A couple of warnings might pop up but don’t worry. Just scroll down, and there it is —  you’ll spot both a local and public URL. Grab that local URL, toss it into your browser, and prepare to be amazed. If you want to show off your achievement with your friends, do it by sharing the public URL. Note that these URLs are valid for only a limited period. Besides, you may have to keep your computer (and the command prompt window) up and running for the URLs to remain valid.

Copy-paste either of the URLs on your favorite browser, and voilà! Your AI chatbot is now up and running. It is admittedly not a fancy interface, but it gets the job done. Go on, fire away your questions to your very own homemade AI chatbot.

build AI CHATBOT API

AI is not just for the technically advanced

The world of AI is no longer reserved for just the tech-savvy. Just being able to demonstrate how to build a chatbot with ChatGPT’s API is a testament to how accessible the AI space has become. With platforms like OpenAI and user-friendly tools at our fingertips, the boundaries of innovation are expanding for everyone. As you continue to explore and experiment, remember that this still-nascent but thriving industry is evolving every day, offering new opportunities and challenges alike.

Frequently asked questions

Can I use ChatGPT API for free?

How to build an OpenAI chatbot?

How to make an AI chatbot using ChatGPT?

Top crypto projects in the US | July 2024
Harambe AI Harambe AI Explore
Uphold Uphold Explore
Exodus Exodus Explore
Coinbase Coinbase Explore
Chain GPT Chain GPT Explore
Top crypto projects in the US | July 2024
Harambe AI Harambe AI Explore
Uphold Uphold Explore
Exodus Exodus Explore
Coinbase Coinbase Explore
Chain GPT Chain GPT Explore
Top crypto projects in the US | July 2024

Trusted

Disclaimer

In line with the Trust Project guidelines, the educational content on this website is offered in good faith and for general information purposes only. BeInCrypto prioritizes providing high-quality information, taking the time to research and create informative content for readers. While partners may reward the company with commissions for placements in articles, these commissions do not influence the unbiased, honest, and helpful content creation process. Any action taken by the reader based on this information is strictly at their own risk. Please note that our Terms and Conditions, Privacy Policy, and Disclaimers have been updated.

Shilpa-Lama.jpg
Shilpa Lama
Shilpa is a Highly experienced freelance Crypto and tech journalist who is deeply passionate about artificial intelligence and pro-freedom technologies such as distributed ledgers and cryptocurrencies. She has been covering the blockchain industry since 2017. Before her ongoing stint in tech media, Shilpa was lending her skills to government-backed fintech endeavors in Bahrain and a leading US-based non-profit dedicated to supporting open-source software projects. In her current...
READ FULL BIO
Sponsored
Sponsored