A Developer's Guide to GPT-5 API: What's New and How to Use It

// Before: Complex prompt engineering to control reasoning
const gpt4Response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [
    {
      role: "system", 
      content: "For simple questions, give brief answers. For complex technical issues, think step by step through the problem, consider multiple approaches, analyze each option..."  // 200+ words of prompt hacks
    },
    { role: "user", content: userQuestion }
  ]
});

// After: Just set reasoning_effort
const gpt5Response = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [
    { role: "user", content: userQuestion }
  ],
  reasoning_effort: "minimal"  // minimal, low, medium, high
});

# Three different response styles with the same prompt
import openai

client = openai.OpenAI()

prompt = "How do I deploy a React app to AWS?"

# Concise answer
short_response = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": prompt}],
    verbosity="low"
)

# Balanced explanation  
medium_response = client.chat.completions.create(
    model="gpt-5", 
    messages=[{"role": "user", "content": prompt}],
    verbosity="medium"
)

# Comprehensive guide
detailed_response = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": prompt}],
    verbosity="high"
)

// Old way: JSON tool calling (breaks on complex inputs)
const oldTools = [{
  type: "function",
  function: {
    name: "execute_sql",
    description: "Execute SQL query",
    parameters: {
      type: "object",
      properties: {
        query: { type: "string" }
      }
    }
  }
}];

// New way: Custom tools with raw text
const customTools = [{
  type: "custom",
  name: "execute_sql", 
  description: "Execute SQL query. Send the SQL directly as plain text.",
  format: {
    type: "grammar",
    grammar: `
      query ::= "SELECT" .* "FROM" .* ("WHERE" .*)?
    `
  }
}];

// GPT-5 can now send SQL directly without JSON wrapping
const response = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [
    { role: "user", content: "Get all users who signed up this month" }
  ],
  tools: customTools
});

# Python
pip install --upgrade openai

# Node.js  
npm install openai@latest

# Check you have the right version
python -c "import openai; print(openai.__version__)"  # Should be 1.40.0+

# gpt-5: Full power, best for complex tasks
# $1.25/1M input tokens, $10/1M output tokens

# gpt-5-mini: Faster and cheaper, good for most apps  
# $0.25/1M input tokens, $2/1M output tokens

# gpt-5-nano: Lightning fast, simple tasks only
# $0.10/1M input tokens, $0.80/1M output tokens

# My recommendation for most developers
model_choice = "gpt-5-mini"  # Sweet spot of performance and cost

import openai
import os
from dotenv import load_dotenv

load_dotenv()

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

def smart_assistant(question, complexity="auto"):
    # Auto-adjust reasoning based on question complexity
    if "code" in question.lower() or "debug" in question.lower():
        reasoning = "high"
        verbosity = "medium"
    elif "?" in question and len(question) > 100:
        reasoning = "medium" 
        verbosity = "high"
    else:
        reasoning = "minimal"
        verbosity = "low"
        
    response = client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "user", "content": question}
        ],
        reasoning_effort=reasoning,
        verbosity=verbosity,
        temperature=0.7
    )
    
    return response.choices[0].message.content

# Test it
print(smart_assistant("What's 2+2?"))  # Fast, brief
print(smart_assistant("Debug this React component that won't render"))  # Deep, detailed

import openai
import os

class CodeReviewBot:
    def __init__(self):
        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        
    def review_code(self, code, language="python"):
        # Custom tool for code analysis
        code_analysis_tool = {
            "type": "custom",
            "name": "analyze_code",
            "description": "Analyze code for bugs, performance, and best practices",
            "format": {
                "type": "grammar", 
                "grammar": """
                    analysis ::= issue*
                    issue ::= severity ":" location ":" description
                    severity ::= "critical" | "warning" | "suggestion"
                    location ::= "line " [0-9]+
                    description ::= .*
                """
            }
        }
        
        response = self.client.chat.completions.create(
            model="gpt-5",
            messages=[
                {
                    "role": "system",
                    "content": f"You're a senior {language} developer. Review this code and use the analyze_code tool to report any issues."
                },
                {
                    "role": "user", 
                    "content": f"Review this {language} code:\n\n```{language}\n{code}\n```"
                }
            ],
            tools=[code_analysis_tool],
            reasoning_effort="high",  # Deep analysis for code review
            verbosity="medium",  # Balanced explanations
            temperature=0.1  # Consistent, focused output
        )
        
        return response.choices[0].message

# Example usage
bot = CodeReviewBot()

code_to_review = '''
def process_users(users):
    results = []
    for user in users:
        if user.age > 18:
            results.append(user.name)
    return results
'''

review = bot.review_code(code_to_review)
print(review.content)

# Old GPT-4 pattern
old_response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system", 
            "content": "You are a helpful assistant. Be concise but thorough. Think through problems step by step when they're complex..."
        },
        {"role": "user", "content": user_input}
    ],
    temperature=0.7
)

# New GPT-5 pattern (cleaner, more control)
new_response = client.chat.completions.create(
    model="gpt-5-mini",  # Choose your model size
    messages=[
        {"role": "user", "content": user_input}  # Simpler prompts
    ],
    reasoning_effort="medium",  # Replace "think step by step"
    verbosity="medium",  # Replace length instructions
    temperature=0.7
)

def adaptive_query(prompt, max_budget_tokens=1000):
    # Start with minimal reasoning, escalate if needed
    reasoning_levels = ["minimal", "low", "medium", "high"]
    
    for level in reasoning_levels:
        response = client.chat.completions.create(
            model="gpt-5-mini",
            messages=[{"role": "user", "content": prompt}],
            reasoning_effort=level,
            max_tokens=max_budget_tokens
        )
        
        # Simple confidence check
        content = response.choices[0].message.content
        if "I'm not sure" not in content and "unclear" not in content:
            return response, level
            
        # If model seems uncertain, try deeper reasoning
        max_budget_tokens *= 1.5  # Allow more tokens for complex reasoning
    
    return response, "high"  # Final attempt

def complex_analysis(data):
    # Stage 1: Quick triage
    triage = client.chat.completions.create(
        model="gpt-5-nano",  # Fast classification
        messages=[{"role": "user", "content": f"Classify complexity of: {data}"}],
        reasoning_effort="minimal",
        verbosity="low"
    )
    
    # Stage 2: Detailed processing based on complexity
    complexity = triage.choices[0].message.content.lower()
    
    if "simple" in complexity:
        model = "gpt-5-mini"
        reasoning = "low"
    else:
        model = "gpt-5" 
        reasoning = "high"
        
    final_response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": f"Analyze: {data}"}],
        reasoning_effort=reasoning,
        verbosity="high"
    )
    
    return final_response