Configuring the Development Environment

This guide walks through configuring a local Python development environment to experiment with the OpenAI API. The steps work whether you’re using a pre-configured environment (e.g., KodeKloud) or your own workstation. Quick overview of the setup flow:

Install Python (3.10+).
Create and activate a Python virtual environment.
Install required Python packages (openai and jupyter).
Create an OpenAI API key and export it as an environment variable.
Test the API from the command line (curl).
Test the API from a Python Jupyter notebook.

The image outlines six steps for setting up a Python environment to work with OpenAI and Jupyter, including installing Python and PIP, creating a virtual environment, installing necessary modules, obtaining an API key, setting an environment variable, and testing the setup.

For quick reference, here’s a condensed table of common commands used in this guide:

Task	Command / Notes
Verify Python	`python -V`
Create venv (Unix/macOS/Windows)	`python -m venv venv`
Activate venv (macOS/Linux)	`source venv/bin/activate`
Activate venv (PowerShell)	`.\venv\Scripts\Activate.ps1`
Install packages	`pip install openai jupyter`
Export API key (bash)	`export OPENAI_API_KEY="sk-REDACTED-YOUR-KEY-HERE"`
Temp set API key (PowerShell)	`$env:OPENAI_API_KEY = "sk-REDACTED-YOUR-KEY-HERE"`
Start Jupyter	`jupyter notebook`

1) Install Python

Download and install Python 3.10 or later from the official site: https://www.python.org/downloads/. Choose the installer that matches your OS (Windows, macOS, Linux). Example usage (can be run in the Python REPL or a script):

# Simple output (with Unicode)
print("Hello, I'm Python!")

# Input and assignment
name = input('What is your name?\n')
print(f'Hi, {name}.')

Verify the Python installation:

python -V
# Example output:
# Python 3.11.4

The image shows a webpage from python.org offering the download of Python 3.11.4 for macOS. It includes a section listing active Python releases and their maintenance statuses.

2) pip and creating a virtual environment

Modern Python installers include pip, which you’ll use to install libraries. Always use a virtual environment to isolate dependencies per project. Create and activate a virtual environment (Unix/macOS):

python -m venv venv
ls
# venv
source venv/bin/activate
# Your shell prompt will indicate the active venv, e.g. (venv) user@host:~$

On Windows (PowerShell):

python -m venv venv
.\venv\Scripts\Activate.ps1

Using a venv prevents global package conflicts and makes dependency management reproducible.

3) Install the OpenAI Python package and Jupyter

With the virtual environment activated, install the required packages:

pip install openai jupyter

If the wheels are cached, pip will reuse them and the install will be fast. Tip: consider pinning package versions in a requirements.txt for reproducible installs:

openai==0.xx.x
jupyter

Then install via:

pip install -r requirements.txt

4) Create an OpenAI API key

Sign in to the OpenAI platform: https://platform.openai.com/account/api-keys
Create a new API key and give it a descriptive name (e.g., KodeKloud-dev).
Copy the secret value immediately — you will not be able to view the full secret after you close the dialog.

The image shows the OpenAI platform interface, featuring links to a quickstart tutorial, examples, and sections on building applications and ChatGPT plugins.

The image shows a webpage where a user is creating a new secret API key, with a dialog box for naming the key.

Keep your API key secret. Copy it now because you will not be able to see it again after closing the creation dialog.

Example: export the key for the current shell session (do not paste a real key here — use the key you copied):

# Bash / macOS / Linux
export OPENAI_API_KEY="sk-REDACTED-YOUR-KEY-HERE"

For PowerShell (temporary for the session):

$env:OPENAI_API_KEY = "sk-REDACTED-YOUR-KEY-HERE"

To persist the key across sessions:

Add the export line to your shell startup file (e.g., ~/.bashrc, ~/.zshrc) on macOS/Linux.
Or add the PowerShell line to your PowerShell profile for Windows.

The image shows a webpage displaying API key management on the OpenAI platform, with options to create a new secret key and set the default organization.

Do not commit your API key to version control or paste it into public forums. Use environment variables or a secrets manager for production applications.

5) Test the API from the command line (curl)

Use curl to verify the environment and the OPENAI_API_KEY variable. This example calls the Chat Completions endpoint (gpt-3.5-turbo) and asks a simple timezone question.

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful AI assistant that answers questions related to timezones."
      },
      {
        "role": "user",
        "content": "If it is 9AM in London, what time is it in Hyderabad? Be concise."
      }
    ]
  }'

A typical (abridged) JSON response:

{
  "id": "chatcmpl-7hDVmftC9Jqr7aLxW01vXdxJq5D1i",
  "object": "chat.completion",
  "created": 1690534398,
  "model": "gpt-3.5-turbo-0613",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "2:30 PM in Hyderabad"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 43,
    "completion_tokens": 6,
    "total_tokens": 49
  }
}

Understanding the usage block (prompt_tokens, completion_tokens, total_tokens) helps you optimize prompts and control costs.

6) Test from a Jupyter notebook (Python)

Start Jupyter:

jupyter notebook

Open a new notebook (e.g., “Test”) and run this code in a cell. The code reads the API key from the environment and uses the OpenAI Python client to create a chat completion.

The image shows a Jupyter Notebook interface, with a toolbar and an empty code cell ready for input. The notebook is open in a web browser window titled "Test."

import os
import openai

openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[
        {
            "role": "system",
            "content": "You are a helpful AI assistant that answers questions related to timezones."
        },
        {
            "role": "user",
            "content": "If it is 9AM in London, what time is it in Hyderabad? Be concise."
        }
    ]
)

print(response)

Example returned JSON (abridged):

{
  "id": "chatcmpl-7hDXEkgRe0PrrmFlawWjKjxAraTNE",
  "object": "chat.completion",
  "model": "gpt-3.5-turbo-0613",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "It is 2:30 PM in Hyderabad."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 43,
    "completion_tokens": 10,
    "total_tokens": 53
  }
}

This confirms:

Command-line access with curl is functional.
Python access via the OpenAI client works inside Jupyter.
The OPENAI_API_KEY environment variable is being used correctly.

Next steps: we will dive deeper into tokenization, prompt design, and cost optimization for production-ready applications.

Configuring the Development Environment

1) Install Python

2) pip and creating a virtual environment

3) Install the OpenAI Python package and Jupyter

4) Create an OpenAI API key

5) Test the API from the command line (curl)

6) Test from a Jupyter notebook (Python)

Links and references

Watch Video

​1) Install Python

​2) pip and creating a virtual environment

​3) Install the OpenAI Python package and Jupyter

​4) Create an OpenAI API key

​5) Test the API from the command line (curl)

​6) Test from a Jupyter notebook (Python)

​Links and references

Watch Video

1) Install Python

2) pip and creating a virtual environment

3) Install the OpenAI Python package and Jupyter

4) Create an OpenAI API key

5) Test the API from the command line (curl)

6) Test from a Jupyter notebook (Python)

Links and references