How to Use The ChatGPT API in Python: Ultimate Guide

ByAbdelhadi Dyouri Updated on

Introduction

Do you know what time it is?

It’s time for you to learn how to use the ChatGPT API in Python.

In this article, I will guide you through how to call the ChatGPT API in your Python code, and once you merge these two super powers: AI and Python, you’ll be unstoppable.

ChatGPT API Python

Calling The ChatGPT API using Python

To call the ChatGPT API in your Python code, you can use the following basic syntax:

from openai import OpenAI

client = OpenAI(
    api_key='<YOUR API KEY>',
)

def ask(question):
    completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": question}
    ]
    )

    return completion.choices[0].message.content

You can get your custom API key from your OpenAI account page.

Once you set up your API keys, you can call your ask() function like so:

ask("Tell me a joke")
ask("Recommend me a dish using Mediterranean ingredients")

That’s it! If you are looking for a more detailed Python ChatGPT API explanation, then read on! I will explain things bit by bit.

Using the ChatGPT API in Python code

Setting Up Your Python Environment

To use the ChatGPT API, set up a Python environment:

python -m venv env

Activate it:

source env/bin/activate

Then install the OpenAI library using the following command:

pip install openai

Generate Your OpenAI API Key

Log into your OpenAI account, then visit this page to generate your own OpenAI API keys.

Once you generate your API key, remember to save it somewhere secure!

ChatGPT API Key in Python

Using the ChatGPT API in Your Python Environment

Next inside your Python environment, set up your Open API key inside an environment variable.

For Linux & MacOS:

export OPENAI_API_KEY='your Open API key'

For Windows:

set OPENAI_API_KEY='your Open API key'

Saving the API key inside a virtual environment variable ensures that it is securely stored and isolated from other projects.

Now, let’s use the virtual environment variable to interact with the ChatGPT API using Python code. Open a new file called mygpt.py and write the following code inside it:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
)

def ask(question):
    completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": question}
    ]
    )

    return completion.choices[0].message.content

Let’s break down the preceding code:

Importing Modules

  • os: This module provides a way to interact with the operating system, and it’s used here to access environment variables.
  • OpenAI: This is the Python module provided by OpenAI, offering functionality to interact with the OpenAI API.

Initializing OpenAI Client

  • OpenAI(): This is used to create an instance of the OpenAI client. It requires an API key for authentication.
  • api_key=os.environ.get("OPENAI_API_KEY"): Here, you retrieve the API key from the environment variables using os.environ.get("OPENAI_API_KEY"). The os.environ.get() method is a safe way to access environment variables in Python. It returns None if the variable is not found, preventing potential errors.

Defining the ask() Function

Here is the full ask() function:

def ask(question):
    completion = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "user", "content": question}
        ]
    )

    return completion.choices[0].message.content
  • ask(question): This function takes a user’s question as input.
  • client.chat.completions.create(...): This line makes a request to the ChatGPT API to generate a completion for the given question. It uses the gpt-3.5-turbo model. OpenAI offers a vast array of AI models. You can choose one based on your needs and budget.
  • messages: An array containing a single message object. The object has two properties:
    • "role": "user": Indicates that the message is from the user.
    • "content": question: Contains the actual content of the user’s message (the input question).
  • completion.choices[0].message.content: Once the API response is received, this extracts the content of the first choice from the response. In the context of ChatGPT, the model generates multiple completions, and this line picks the content of the first (and usually the most relevant) completion.

In summary, this code sets up an OpenAI client, defines a function ask() to interact with the ChatGPT API by sending a user’s question, and retrieves the generated response.

The code utilizes environment variables for API key storage and follows best practices for secure key handling.

This script is a simple yet effective way to leverage the ChatGPT API in Python for conversational AI applications.

Finally, you can call the ask() function with different user questions:

ask("Tell me a joke")
ask("Recommend me a dish using Mediterranean ingredients")

These lines demonstrate how to interact with the ChatGPT API by asking questions and receiving responses.

You can see an example response in the following image:

ChatGPT API Response

Using a Role for Your ChatGPT API Model to Establish Context

In the context of the ChatGPT API, using roles helps establish a conversational context by assigning specific roles (e.g., “user” or “assistant”) to different messages within a conversation. Each message in the conversation has a role and content, and the model generates responses based on the entire conversation history.

Here’s how you can use roles to establish context when interacting with the ChatGPT API:

  1. Initialize the Conversation: When starting a conversation, typically, you send a message with the role “system” to set up the initial context. For example:
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What's the weather like today?"}
]

This sets the stage by telling the model its role and providing the user’s first message.

  1. Add User Messages: As the conversation progresses, you continue to add user messages with the role “user” to provide input and context:
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What's the weather like today?"},
    {"role": "user", "content": "Can you also tell me a joke?"}
]

Each user message contributes to the context the model uses to generate responses.

  1. Retrieve Model Responses: When calling the ChatGPT API, pass the conversation history as the messages parameter. The model considers the entire conversation when generating responses:
completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=messages
)
response = completion.choices[0].message.content

The response will be the generated output based on the conversation context.

  1. Continuing the Conversation: To continue the conversation, you add more user messages to the messages list and make subsequent API calls:
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What's the weather like today?"},
    {"role": "user", "content": "Can you also tell me a joke?"}
    # Add more user messages as the conversation progresses
]

Each time you add a new user message, you maintain and build upon the conversational context.

By using roles and maintaining a history of messages, you can guide the model’s behavior and receive responses that are coherent and contextually relevant within the ongoing conversation. This approach is particularly useful for creating dynamic and interactive conversational experiences.

Conclusion

Congrats! You’ve learned how to use the ChatGPT API in Python! With this, you can now create your own personal AI assistant. Here are a few ideas for how you can leverage the ChatGPT API in your Python projects:

  1. Conversational Interfaces: Implement chatbots or virtual assistants that engage in natural and dynamic conversations with users. This can be applied to customer support, information retrieval, or even creating interactive storytelling experiences.
  2. Code Generation and Assistance: Integrate ChatGPT into coding environments to assist programmers in generating code snippets, debugging, or providing explanations for coding concepts. It can be a valuable tool for enhancing developer productivity. This is similar to GitHub Copilot
  3. Content Creation and Copywriting: Use the API to generate creative and engaging content for articles, marketing materials, or social media posts. Similar to Surfer SEO, ChatGPT can assist in brainstorming ideas, refining language, and generating diverse content for different purposes.
  4. Learning and Education: Develop educational tools that provide personalized learning experiences. ChatGPT can answer questions, explain concepts, and engage in interactive lessons, making it a useful resource for online learning platforms or educational apps.

You can also use a Python library to scrape web data and send it to ChatGPT’s API in your Python code. If you’re looking for fun web scraping project ideas, check out my post on that.

FAQ: Frequently Asked Questions about Using the ChatGPT API in Python

1. How does the ChatGPT API work with Python?

Answer: The ChatGPT API can be used with Python by making HTTP requests to the OpenAI servers. Python scripts can send messages to the API and receive model-generated responses. The OpenAI Python library simplifies this process by providing a convenient interface for interacting with the API.

2. What is the purpose of using roles in the messages when calling the ChatGPT API?

Answer: Roles in the messages help establish context within a conversation. By assigning roles like “user” or “assistant” to messages, you guide the model’s behavior and enable it to generate responses based on the conversation’s history. This facilitates more coherent and contextually relevant interactions.

3. Can I use the ChatGPT API for free, or is it a paid service?

Answer: The ChatGPT API is a paid service. OpenAI offers various pricing plans that include different levels of access and usage. You can refer to the OpenAI pricing page on the official website to understand the details of the pricing structure and choose a plan that suits your needs.

Similar Posts