Python OpenAI API

ChatGPT, GPT-4, and other OpenAI API integrations with Python examples.

Setup & Installation

Installation & Basic Setup

# Install OpenAI library
pip install openai

# Basic setup
import openai
import os

# Set your API key
openai.api_key = "your-api-key-here"
# Or set as environment variable
# os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# Initialize client (for newer versions)
from openai import OpenAI
client = OpenAI(api_key="your-api-key-here")

ChatGPT Examples

Simple Chat

import openai

def simple_chat(message):
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": message}
        ],
        max_tokens=150,
        temperature=0.7
    )
    return response.choices[0].message.content

# Usage
message = "Explain quantum computing in simple terms"
response = simple_chat(message)
print(response)

# With newer API
from openai import OpenAI
client = OpenAI()

def chat_with_gpt(message):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "user", "content": message}
        ]
    )
    return response.choices[0].message.content

Conversation History

from openai import OpenAI
client = OpenAI()

class ChatBot:
    def __init__(self):
        self.conversation_history = []
    
    def add_message(self, role, content):
        self.conversation_history.append({"role": role, "content": content})
    
    def chat(self, user_message):
        self.add_message("user", user_message)
        
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=self.conversation_history,
            max_tokens=200
        )
        
        assistant_message = response.choices[0].message.content
        self.add_message("assistant", assistant_message)
        
        return assistant_message
    
    def get_history(self):
        return self.conversation_history

# Usage
bot = ChatBot()
response1 = bot.chat("Hello, how are you?")
response2 = bot.chat("What's the weather like?")
print("History:", bot.get_history())

GPT-4 Examples

Code Generation

from openai import OpenAI
client = OpenAI()

def generate_code(description, language="python"):
    prompt = f"""Generate {language} code for the following task:
{description}

Please provide:
1. Clean, well-commented code
2. Brief explanation of the approach
3. Example usage if applicable"""

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are an expert programmer. Generate clean, efficient code with proper comments."},
            {"role": "user", "content": prompt}
        ],
        max_tokens=1000,
        temperature=0.3
    )
    
    return response.choices[0].message.content

# Usage
description = "Create a function to find the longest common subsequence between two strings"
code = generate_code(description, "python")
print(code)

Text Analysis

from openai import OpenAI
client = OpenAI()

def analyze_text(text, analysis_type="sentiment"):
    analysis_prompts = {
        "sentiment": "Analyze the sentiment of this text (positive, negative, neutral) and provide a confidence score.",
        "summary": "Provide a concise summary of this text in 2-3 sentences.",
        "keywords": "Extract the main keywords and key phrases from this text.",
        "tone": "Analyze the tone and writing style of this text."
    }
    
    prompt = f"{analysis_prompts.get(analysis_type, 'Analyze this text')}\n\nText: {text}"
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a text analysis expert. Provide clear, structured analysis."},
            {"role": "user", "content": prompt}
        ],
        max_tokens=300,
        temperature=0.2
    )
    
    return response.choices[0].message.content

# Usage
text = "I'm really excited about this new project! It's going to be amazing."
sentiment = analyze_text(text, "sentiment")
summary = analyze_text(text, "summary")
print(f"Sentiment: {sentiment}")
print(f"Summary: {summary}")

Advanced Features

Function Calling

from openai import OpenAI
import json

client = OpenAI()

# Define functions that the model can call
functions = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name"
                }
            },
            "required": ["location"]
        }
    }
]

def get_weather(location):
    # Mock weather function
    return f"Weather in {location}: Sunny, 25°C"

def chat_with_functions(message):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        functions=functions,
        function_call="auto"
    )
    
    message = response.choices[0].message
    
    if message.function_call:
        function_name = message.function_call.name
        function_args = json.loads(message.function_call.arguments)
        
        if function_name == "get_weather":
            result = get_weather(function_args["location"])
            
            # Send function result back to the model
            response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "user", "content": message},
                    {"role": "function", "name": function_name, "content": result}
                ]
            )
            return response.choices[0].message.content
    
    return message.content

# Usage
result = chat_with_functions("What's the weather like in Tokyo?")
print(result)

Streaming Responses

from openai import OpenAI
import sys

client = OpenAI()

def stream_chat(message):
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        stream=True
    )
    
    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            print(content, end='', flush=True)
            full_response += content
    
    return full_response

def stream_with_callback(message, callback=None):
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": message}],
        stream=True
    )
    
    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            full_response += content
            if callback:
                callback(content)
    
    return full_response

# Usage
def print_chunk(chunk):
    print(chunk, end='', flush=True)

message = "Write a short story about a robot learning to paint"
response = stream_with_callback(message, print_chunk)

Quick Reference

Popular Models:

• gpt-3.5-turbo - Fast, cost-effective
• gpt-4 - Most capable, higher cost
• gpt-4-turbo - Latest GPT-4 variant
• text-embedding-ada-002 - Embeddings

Key Parameters:

• max_tokens - Response length limit
• temperature - Creativity (0-2)
• top_p - Nucleus sampling
• stream - Real-time responses