Python Installation:

# Install OpenAI Python library
pip install openai

# Import and configure
import openai
openai.api_key = "your-api-key-here"

JavaScript/Node.js Installation:

// Install OpenAI npm package
npm install openai

// Import and configure
const { Configuration, OpenAIApi } = require("openai");
const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

Secure Key Management (Python):

# Using environment variables
import os
from dotenv import load_dotenv

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

# Using config file (not recommended for production)
import json
with open('config.json') as f:
    config = json.load(f)
    api_key = config['api_key']

import openai

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

# Basic chat completion
response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain quantum computing in simple terms"}
    ],
    temperature=0.7,
    max_tokens=500
)

# Extract response
answer = response.choices[0].message.content
print(answer)

const { Configuration, OpenAIApi } = require("openai");

// Configure OpenAI
const configuration = new Configuration({
    apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

// Chat completion function
async function chatCompletion() {
    try {
        const response = await openai.createChatCompletion({
            model: "gpt-3.5-turbo",
            messages: [
                {role: "system", content: "You are a helpful assistant."},
                {role: "user", content: "Explain machine learning"}
            ],
            temperature: 0.7,
            max_tokens: 500
        });
        
        console.log(response.data.choices[0].message.content);
    } catch (error) {
        console.error("Error:", error);
    }
}

chatCompletion();

Python Streaming Example:

import openai

openai.api_key = "your-api-key-here"

# Stream responses
for chunk in openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Write a story"}],
    stream=True
):
    content = chunk.choices[0].delta.get("content", "")
    print(content, end="", flush=True)

functions = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"]
                }
            },
            "required": ["location"]
        }
    }
]

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "What's the weather in Mumbai?"}],
    functions=functions,
    function_call="auto"
)

import openai
import time

def call_openai_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=messages,
                timeout=30
            )
            return response
        except openai.error.RateLimitError:
            wait_time = 2 ** attempt
            print(f"Rate limit hit. Waiting {wait_time} seconds...")
            time.sleep(wait_time)
        except openai.error.APIError as e:
            print(f"API Error: {e}")
            if attempt == max_retries - 1:
                raise
        except Exception as e:
            print(f"Unexpected error: {e}")
            raise
    
    raise Exception("Max retries exceeded")

def customer_support_bot(user_message, conversation_history):
    system_prompt = """You are a helpful customer support agent for an 
    e-commerce company. Be polite, professional, and solve issues efficiently.
    If you cannot help, escalate to human support."""
    
    messages = [{"role": "system", "content": system_prompt}]
    messages.extend(conversation_history)
    messages.append({"role": "user", "content": user_message})
    
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=messages,
        temperature=0.5
    )
    
    return response.choices[0].message.content

def generate_blog_post(topic, keywords, word_count):
    prompt = f"""Write a {word_count}-word blog post about {topic}.
    Include these keywords: {', '.join(keywords)}
    Make it engaging, informative, and SEO-friendly.
    Include an introduction, main body with subheadings, and conclusion."""
    
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a professional content writer."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=word_count * 2
    )
    
    return response.choices[0].message.content

def review_code(code, language):
    prompt = f"""Review this {language} code and provide:
    1. Potential bugs or issues
    2. Performance improvements
    3. Best practice suggestions
    4. Security concerns
    
    Code:
    ```{language}
    {code}
    ```"""
    
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are an expert code reviewer."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.3
    )
    
    return response.choices[0].message.content