OpenAI Client Setup for Code Review

Welcome to the first lesson of this course! In this lesson, you will learn how to set up an OpenAI client in Python. This is the foundation for building an AI-powered code review assistant. By the end of this lesson, you will know how to connect your Python code to OpenAI's API, which will allow you to send code snippets and receive helpful feedback from a powerful language model.

Setting up the OpenAI client is the first step in enabling your application to communicate with OpenAI's servers. This connection is what makes it possible to use AI to analyze and review code automatically.

Before we dive in, let's briefly recall two important concepts:

• API Key: An API key is like a password that allows your program to access a service, in this case, OpenAI's API. You should keep your API key secret and never share it publicly.
• Python Classes: A class in Python is a way to group related functions and data together. You can create an object from a class to use its features.

If you are already comfortable with these ideas, feel free to move on. If not, don't worry—we will see them in action in the next steps.

To use OpenAI's API in Python, you need the openai library. On CodeSignal, this library is already installed for you. However, if you want to run this on your own computer, you would install it using pip:

pip install openai

Once installed, you can import the library in your Python code:

import openai

This line allows you to use all the features provided by the OpenAI library.

To connect to OpenAI, you need to provide your API key. This can be done in two main ways: by setting an environment variable or by passing the key directly in your code.

Let's start by setting up the API key as an environment variable. This is the recommended way because it keeps your key hidden from your code.

import os

api_key = os.getenv("OPENAI_API_KEY")

Here, os.getenv("OPENAI_API_KEY") tries to get the API key from your environment variables. If you are running this on CodeSignal, the key may already be set for you.

Now, let's see how to use this key to set up the OpenAI client and choose a model:

import openai

openai.api_key = api_key
model = "gpt-6-luna"

• openai.api_key = api_key tells the OpenAI library which key to use.
• model = "gpt-6-luna" selects the language model you want to use for code review.

Before we make our first API call, it's important to understand the key parameters that control how the AI model behaves. These parameters help you fine-tune the responses to get the best results for code review:

Older chat models let you tune how creative or random their answers are with the temperature parameter. The model we use, gpt-6-luna, is a reasoning model: it thinks briefly before it answers, and it manages its own sampling. It only accepts the default temperature and rejects other values, and it also rejects top_p and the penalty parameters.

For code review, this means there is nothing to tune here: you simply leave temperature out of your request.

The max_completion_tokens parameter limits how long the AI's response can be:

• Each "token" is roughly equivalent to a word or part of a word. As a rough guide, 1,000 tokens is about 750 words.
• For a reasoning model, this limit also covers the model's internal reasoning before it answers. If the limit is too small, the model can use it all up while thinking and return an empty answer.
• Setting max_completion_tokens=1000 is a generous cap that helps control costs and ensures responses don't become too lengthy.

The messages parameter expects a list of message objects, where each message has:

• role: Can be "user" (your input), "assistant" (AI's response), or "system" (instructions for the AI).
• content: The actual text of the message.

For simple code review, we'll primarily use the "user" role to send our prompts.

Now, let's build a simple example step by step. We want to send a prompt to the OpenAI API and get a response.

First, let's define a function that sends a prompt and returns the response:

def generate_review(prompt):
    response = openai.chat.completions.create(
        model="gpt-6-luna",
        messages=[{"role": "user", "content": prompt}],
        max_completion_tokens=1000
    )
    return response.choices[0].message.content

Let's break down what's happening here:

• openai.chat.completions.create(...) sends a request to the OpenAI API.
• model="gpt-6-luna" specifies which model to use.
• messages=[{"role": "user", "content": prompt}] sends your prompt as a message.
• max_completion_tokens=1000 caps the length of the response, including the model's reasoning.
• response.choices[0].message.content gets the actual text of the response.

Now, let's use this function to review a simple code change:

prompt = "Review this code change:\n+ print('Hello, world!')"
review = generate_review(prompt)
print(review)

Example Output:

Summary of changes:
- Added a print statement to output 'Hello, world!'.

Potential issues:
- None identified.

Suggestions for improvement:
- Consider adding comments for clarity if this is part of a larger script.

Overall quality assessment:
- The change is simple and correct.

Sometimes, the API call might fail due to network issues or other problems. It's important to handle these errors and try again if needed.

Let's add error handling and retry logic to our function:

import time

def generate_review_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = openai.chat.completions.create(
                model="gpt-6-luna",
                messages=[{"role": "user", "content": prompt}],
                max_completion_tokens=1000
            )
            return response.choices[0].message.content
        except Exception as e:
            print(f"API call failed (attempt {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Wait before retrying
            else:
                print("Max retries exceeded")
                return None

Here's what's happening:

• The function tries to call the API up to max_retries times.
• If an error occurs, it prints a message and waits a bit before trying again.
• If all attempts fail, it prints "Max retries exceeded" and returns None.

This makes your code more reliable when working with external services.

In this lesson, you learned how to:

• Install and import the OpenAI library (with a reminder that it's pre-installed on CodeSignal).
• Set up your API key securely.
• Configure the OpenAI client and select a model.
• Understand key API parameters like max_completion_tokens, and how reasoning models handle sampling.
• Make a simple API call to review code.
• Handle errors and retry failed requests.

You are now ready to practice these steps on your own. In the next exercises, you will get hands-on experience setting up the OpenAI client and making your first code review requests. Good luck!