What Is the ChatGPT API? | How to Use It

The ChatGPT API is a powerful and accessible tool that enables developers to integrate the power of ChatGPT into their own applications. This can be transformative for such diverse scenarios as customer support where it can aid in building chatbots to deliver accurate and instant responses to customer inquiries, or in content generation, where it can assist in brainstorming ideas or drafting SEO-optimized articles. In this article, we will explore the basics of the ChatGPT API, how to use it, and examples of API usage with a Python library.

API Basics

The ChatGPT API provides a simple interface to interact with the ChatGPT model. It lets users send a series of messages to the model and receive model-generated messages in response. The model-generated message is based on the conversation history provided, allowing for interactive and dynamic conversations with the model.

To use the API, you need to make HTTP requests to the API endpoint using a client library of your choice. OpenAI provides an official Python library that simplifies the process of interacting with the API. In the next sections, we will cover how to install the library and obtain an API key.

Installing the Library

To get started with the ChatGPT API, you need to install the OpenAI Python library. You can do this by running the following command using pip:

pip install openai

Once the library is installed, you are ready to obtain an API key.

Obtaining an API Key

To use the ChatGPT API, you need to sign up for an API key on the OpenAI website. Visit the OpenAI API platform and create an account if you don’t have one already. Once you are signed in, navigate to the API section to generate an API key. Keep in mind that the ChatGPT API may have associated costs, so ensure that you are aware of the pricing details before proceeding.

Once you have your API key, you are ready to start using the ChatGPT API. Make sure to keep your API key secure and avoid sharing it publicly or committing it to version control systems.

Choosing the Engine

The ChatGPT API offers different engines to choose from, each with its own characteristics. The engine you select determines the behavior and capability of the model. At the time of writing this article, the available engines are:

• text-davinci-003: This engine is the most capable but also the most expensive. It provides high-quality responses and supports a wide range of use cases. It performs well in creative writing and answering questions.
• text-davinci-002: This engine is like text-davinci-003 but may have slightly lower performance. It is a more cost-effective option if you don’t require the highest level of performance.
• text-davinci-001: This engine is the baseline and provides a balance between capability and cost. It is suitable for general purpose use and offers a good starting point.

When selecting an engine, consider the specific requirements of your application and the trade-off between cost and capability. It’s worth experimenting with different engines to find the one that best suits your needs.

Building the Conversation

To use the ChatGPT API, you need to construct a conversation by sending a series of messages as input. Each message consists of a role (either "system", "user", or "assistant") and the content of the message.

The conversation typically starts with a system message, which helps set the behavior of the assistant. For example:

conversation = [
	{"role": "system", "content": "You are a helpful assistant."},
	{"role": "user", "content": "Please, explain Fermat's theorem in about 100 words."}
]

In this example, the conversation starts with a system message that sets the behavior of the assistant. The user then asks a question (Please, explain Fermat's theorem in about 100, and the assistant will provide a response.

Note that the conversation can be of any length and can include multiple messages between the user and the assistant. The assistant refers to previous messages to maintain context and provide relevant responses.

Getting the Response

Once you have constructed the conversation (i.e., decided what you want to ask or tell the ChatGPT model,) you can send it to the ChatGPT API to get a model-generated response. In other words, the API sends your conversation to the model, and in return, the model gives you an appropriate response.

The Python library provided by OpenAI simplifies this process. Here’s an example:

import openai
openai.api_key = 'YOUR_API_KEY'
response = openai.Completion.create(
	engine='text-davinci-003',
	messages=conversation
)
reply = response.choices[0].message['content']
print(reply)

In this example, we set the openai.api_key to the API key we obtained earlier. We then call openai.Completion.create() with the chosen engine and the constructed conversation. The API will return a response object, from which we extract the reply.

Updating the Conversation

In many cases, you may want to extend the conversation with additional user or assistant messages asking more questions or giving more instructions. To do so, simply append the new message to the existing conversation and send it again to the API.

Here’s an example of extending the conversation:

new_message = {"role": "user", "content": "How to proof that theorem?"}
updated_conversation = conversation + [new_message]
response = openai.Completion.create(
	engine='text-davinci-003',
	messages=updated_conversation
)
reply = response.choices[0].message['content']
print(reply)

In this example, we append a new user message to the existing conversation ("role": "user", "content": "How to proof that theorem?". The updated conversation is then sent to the API, and we extract the response as before. By updating the conversation with a new prompt, you can have interactive and dynamic exchanges with the model, allowing for a more engaging and flexible user experience.

Conclusion

The ChatGPT API provides a powerful way to integrate OpenAI’s language models into your own applications. With the Python library, you can take advantage of this opportunity no matter your industry or purpose. Remember to experiment with different engines and conversation setups to achieve the desired behavior and performance.

You can build your own models and train them with our AI Cloud solution.