How to use OpenAI’s GPT-4o & GPT-4o Mini APIs with Python

Artificial Intelligence, CMS & Web development

With the introduction of the GPT-4o and GPT-4o Mini models, OpenAI offers developers a new level of flexibility and intelligence for both complex and lightweight AI tasks. These latest models build on the strengths of previous versions, providing faster responses and cost efficiency for a wide array of applications. In this guide, we’ll explore how to consume OpenAI’s API with Python, dive into the latest model features, and cover practical implementations for the GPT-4o and GPT-4o Mini models.

Introduction to OpenAI’s New GPT-4o Models

OpenAI’s latest lineup of models, including GPT-4o and GPT-4o Mini, brings a versatile toolkit for AI developers. These models cater to both highly demanding AI tasks and fast, lightweight applications, broadening the range of potential use cases. Whether you’re working on complex language comprehension or need quick processing for chat-based applications, these models offer optimized solutions with varying performance and cost-efficiency levels. GPT-4o is a flagship model designed for deep reasoning, while GPT-4o Mini offers a more affordable, faster alternative for simpler tasks.

This guide will help you set up, configure, and maximize the use of these models with Python, equipping you to harness their capabilities effectively.

OpenAI’s models now span various functionalities:

GPT-4o: Designed for advanced language tasks requiring complex reasoning and multi-step operations.
GPT-4o Mini: A smaller, cost-effective model suitable for quick, straightforward tasks.
o1-preview and o1-mini: Reinforcement-learned models, optimized for tasks needing nuanced reasoning.
GPT-4 Turbo and GPT-4: High-performance models from the previous generation, capable of handling intricate text-based tasks.
GPT-3.5 Turbo: An economical choice for less demanding text processing tasks.
DALL·E: Generates images from textual prompts.
TTS: Converts text to realistic-sounding spoken audio.
Whisper: Transforms audio into text.
Embeddings: Translates text into numerical vectors for search, categorization, and similarity analysis.
Moderation: Detects potentially sensitive or unsafe content.

Our focus here will be on using GPT-4o and GPT-4o Mini for text and language processing tasks.

Setting Up Your OpenAI API Account and API Key

To get started with the OpenAI API, you’ll need to create an account and obtain an API key:

Sign Up: Go to OpenAI’s website and register for an account if you haven’t already.
Generate an API Key: Once logged in, navigate to your API settings and create a new API key. Keep this key secure as it grants access to your API usage.
Set Usage Limits: In your account, you can set limits on spending and API usage to manage costs effectively.

Installing the OpenAI Python Library

To start using OpenAI’s API with Python, install the OpenAI Python package, which simplifies API requests and responses.

$ pip install openai

Once installed, you can import the library and set up your API key:

import openai
# Set your API key
openai.api_key = "your-api-key"

This setup allows you to start making API requests with minimal code.

Basic Authentication and Authorization for OpenAI API

OpenAI’s API uses API key-based authentication. Your API key authenticates your requests, ensuring that only authorized users can access your account’s resources. In Python, this is managed by setting openai.api_key.

Ensure your key is secure and avoid hardcoding it directly in public code repositories. Consider using environment variables to store your key securely in production environments.

Making Your First API Call with GPT-4o and GPT-4o Mini

With your setup ready, you can make your first API call to GPT-4o or GPT-4o Mini. Here’s an example using GPT-4o for a more complex prompt:

response = openai.Completion.create(
  model="gpt-4o",
  prompt="What are the implications of AI in environmental science?",
  max_tokens=150
)
print(response.choices[0].text.strip())

If you’re looking for a quick, lightweight response, try using GPT-4o Mini:

response = openai.Completion.create(
  model="gpt-4o-mini",
  prompt="Summarize the benefits of AI in healthcare.",
  max_tokens=50
)
print(response.choices[0].text.strip())

These models can be selected based on your specific task requirements and response speed preferences.

Understanding Pricing and Token Limits for GPT-4o Models

OpenAI’s pricing is based on tokens processed in requests and responses. Tokens represent portions of words, so a response with 1000 tokens typically represents around 750 words. Models like GPT-4o are optimized for in-depth responses, while GPT-4o Mini is more economical for shorter, less complex outputs.

Pricing and rate limits vary by model, so check OpenAI’s official documentation and your account dashboard to manage costs effectively.

Exploring Core Use Cases for GPT-4o

The new GPT-4o models cover a wide range of applications, including:

Complex analysis: Using GPT-4o for scientific, technical, and in-depth text processing.
Quick text responses: Relying on GPT-4o Mini for chatbots, customer service, and real-time applications.
Content creation: Automating social media posts, blog writing, and creative story generation.
Text summarization and classification: Using OpenAI for document analysis and tagging.

Let’s dive into examples for specific use cases.

Text Generation and Language Comprehension with GPT-4o

GPT-4o excels at generating coherent, nuanced text based on a provided prompt. Here’s how to use it for detailed content creation:

response = openai.Completion.create(
  model="gpt-4o",
  prompt="Write a persuasive article on the importance of renewable energy.",
  max_tokens=200
)
print(response.choices[0].text.strip())

In this example, GPT-4o produces a well-structured response suitable for persuasive writing or in-depth analysis.

Quick, Lightweight Tasks with GPT-4o Mini

For applications that require quick responses, such as chatbots or virtual assistants, GPT-4o Mini offers efficient processing:

response = openai.Completion.create(
  model="gpt-4o-mini",
  prompt="List three benefits of using renewable energy.",
  max_tokens=30
)
print(response.choices[0].text.strip())

This model provides concise responses at a reduced cost, ideal for scenarios where brief information suffices.

Sentiment Analysis and Text Classification

OpenAI’s models support text classification tasks like sentiment analysis. Here’s an example with GPT-4o Mini:

response = openai.Completion.create(
  model="gpt-4o-mini",
  prompt="Classify the sentiment as positive, neutral, or negative: 'This new update is amazing!'",
  max_tokens=10
)
print(response.choices[0].text.strip())

This can quickly classify sentiments in social media comments, reviews, or customer feedback.

Using Reinforcement-Learned Models: o1-preview and o1-mini

The o1-preview and o1-mini models are trained with reinforcement learning, making them adept at tasks requiring reasoning and decision-making. This is particularly valuable for applications in legal analysis, financial projections, and other data-intensive domains.

response = openai.Completion.create(
  model="o1-preview",
  prompt="Analyze the following financial report and highlight key insights...",
  max_tokens=200
)
print(response.choices[0].text.strip())

These models are ideal for complex analytical tasks requiring a higher degree of reasoning.

Creating Chatbots and Virtual Assistants

GPT-4o Mini is an excellent choice for creating responsive chatbots:

def chat_with_bot(prompt):
    response = openai.Completion.create(
        model="gpt-4o-mini",
        prompt=prompt,
        max_tokens=100
    )
    return response.choices[0].text.strip()
# Test the chatbot
print(chat_with_bot("Hello! What can I assist you with today?"))

This function returns concise responses, enabling chatbots to engage with users naturally and efficiently.

Advanced Text Summarization and Analysis

GPT-4o is well-suited for summarizing and analyzing longer texts:

text = "AI has transformed multiple industries, from healthcare to finance, with advancements in machine learning and data analytics."
response = openai.Completion.create(
  model="gpt-4o",
  prompt=f"Summarize the following text: {text}",
  max_tokens=50
)
print(response.choices[0].text.strip())

This approach aids in generating summaries, essential for information retrieval and content management systems.

Efficiently Managing API Costs

To manage costs:

Choose models based on task complexity.
Control max_tokens to limit response length.
Use batching for repetitive tasks.
Monitor usage through OpenAI’s dashboard.

Error Handling and Debugging in OpenAI API

OpenAI provides helpful error messages for debugging. Here’s how to handle common errors:

try:
    response = openai.Completion.create(
        model="gpt-4o",
        prompt="Provide a detailed explanation of quantum mechanics.",
        max_tokens=100
    )
except openai.error.OpenAIError as e:
    print(f"API error: {e}")

This ensures your application continues running smoothly despite temporary issues.

Leveraging GPT-4o for Multi-Step Reasoning and Complex Tasks

GPT-4o’s capabilities shine in complex, multi-step tasks, such as scientific analyses or financial forecasting. These tasks benefit from the model’s high reasoning abilities, making GPT-4o ideal for in-depth, contextually rich outputs.

Automating OpenAI Workflows with Python

By combining OpenAI with automation libraries like Airflow, you can automate workflows to run API calls periodically, such as for daily data analysis or scheduled content generation.

Integrating OpenAI with Other NLP Libraries

Combining OpenAI with libraries like spaCy enhances functionality, allowing for tokenization, named entity recognition, and more, before passing processed data to GPT-4o for further analysis.

Working with Embeddings and Data Analysis

OpenAI’s embeddings allow you to analyze, categorize, and compare text data:

response = openai.Embedding.create(
  model="text-embedding-ada-002",
  input="Understanding data science is essential for AI development."
)
print(response['data'][0]['embedding'])

Embeddings are vital for applications like search engines, recommendation systems, and text similarity.

Developing Custom Models with Fine-Tuning

Fine-tuning lets you adapt models like GPT-4o to your unique dataset, refining responses for your specific use case. This can improve accuracy and relevance in customer service, personalized content, and technical support applications.

FAQs on Using GPT-4o and GPT-4o Mini

How do I choose between GPT-4o and GPT-4o Mini?

What are the use cases for o1-preview and o1-mini?

How can I manage costs while using OpenAI models?

Is it possible to create a custom-trained model with OpenAI’s API?

How do I set API rate limits for OpenAI?

What is the difference between GPT-4o and GPT-4o Mini in terms of response quality?

Conclusion :

With GPT-4o and GPT-4o Mini, OpenAI offers an unprecedented level of flexibility for integrating AI into applications. From deep analysis to real-time chat responses, these models allow developers to choose the right model for each task. This guide provides you with a foundation for using OpenAI’s API with Python, empowering you to build sophisticated, AI-powered applications tailored to your project needs.