OpenAI Models Guide

Model Overview

OpenAI is one of the world’s leading AI research institutions, offering multiple high-performance large language models. From GPT-5.5 to GPT-5, GPT-4.1, and the reasoning-focused o3/o4 series, OpenAI provides solutions for various scenarios.

Full Compatibility: Laozhang API is 100% compatible with OpenAI’s official API format. Simply replace https://api.openai.com/v1 with https://api2.laozhang.ai/v1 to use it.

Model Classification

GPT-5.5 Series

GPT-5.5

Latest flagship model for complex professional work

Core Features:
- Supports text and image input
- 1M context window
- Strong coding and agentic reasoning
- Excellent multilingual capabilities
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- Complex task handling
- Image understanding and analysis
- Long document processing
- Professional content generation

GPT-4.1 Mini

Fast economical model for everyday workloads

Core Features:
- Fast response speed
- Good general-purpose quality
- Fast response speed
- Suitable for cost-sensitive use
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- Daily conversations
- Batch processing
- Development and testing
- Cost-sensitive applications

GPT-5 / GPT-4.1 Series

GPT-5.5

Current high-performance model with powerful reasoning capabilities

Core Features:
- 1M context window
- Strong logical reasoning
- Excellent code understanding
- Multi-domain knowledge
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- Complex reasoning tasks
- Code generation and review
- Academic research
- Professional consulting

GPT-4.1

Classic stable model for production workloads

Core Features:
- 128K context window
- Outstanding text understanding
- Creative writing capabilities
- Accurate information extraction
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- High-quality content creation
- Important decision support
- Detailed analysis reports

o3 / o4 Reasoning Models

o3-pro

Reasoning-specialized model with PhD-level thinking ability

Core Features:
- Strongest reasoning capabilities
- Multi-step thinking process
- Excellent math problem solving
- Complex logic analysis
Pricing:
- Check the console for real-time pricing
Special Limitations:
- Does not support streaming output
- Does not support system role
- Does not support temperature parameter
Suitable Scenarios:
- Mathematical olympiad problems
- Scientific research
- Code algorithm optimization
- Complex decision analysis

o4-mini

Lightweight reasoning model, extreme cost-performance

Core Features:
- Fast reasoning speed
- current price shown in console than o3-pro
- Good code and math capabilities
- Suitable for daily reasoning tasks
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- Daily math problems
- Code logic optimization
- Reasoning practice
- Education and tutoring

GPT-4o Series (Classic Multimodal)

GPT-4o Mini

Classic lightweight multimodal model for legacy compatibility

Core Features:
- Fast response speed
- Fast response speed
- Stable performance
- Suitable for high-frequency calls
Pricing:
- Check the console for real-time pricing
Suitable Scenarios:
- Simple conversations
- Content summarization
- Text translation
- Customer service bots

Code Examples

Basic Text Dialogue

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api2.laozhang.ai/v1"
)

# Use GPT-5.5
response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Introduce quantum computing"}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: 'YOUR_API_KEY',
  baseURL: 'https://api2.laozhang.ai/v1'
});

// Use GPT-5.5
const response = await openai.chat.completions.create({
  model: 'gpt-5.5',
  messages: [
    { role: 'system', content: 'You are a helpful assistant' },
    { role: 'user', content: 'Introduce quantum computing' }
  ],
  temperature: 0.7,
  max_tokens: 1000
});

console.log(response.choices[0].message.content);

Image Understanding

# Analyze image content
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

// Analyze image content
const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: "What's in this image?" },
        {
          type: 'image_url',
          image_url: {
            url: 'https://example.com/image.jpg'
          }
        }
      ]
    }
  ]
});

console.log(response.choices[0].message.content);

Long Document Analysis

# Read and analyze long documents
with open('document.txt', 'r', encoding='utf-8') as f:
    document = f.read()

response = client.chat.completions.create(
    model="gpt-4o",  # 128K context
    messages=[
        {
            "role": "user",
            "content": f"Please summarize the following document:\n\n{document}"
        }
    ],
    max_tokens=2000
)

print(response.choices[0].message.content)

Creative Writing

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {
            "role": "system",
            "content": "You are a professional novelist"
        },
        {
            "role": "user",
            "content": "Write a 500-word sci-fi short story about time travel"
        }
    ],
    temperature=1.2,  # Higher temperature, more creative
    max_tokens=1500
)

print(response.choices[0].message.content)

Complex Code Review

code = """
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": f"Review this code and suggest optimizations:\n\n{code}"
        }
    ]
)

print(response.choices[0].message.content)

Mathematical Problem Solving

# Use O1 series to solve complex math problems
response = client.chat.completions.create(
    model="o3-pro",
    messages=[
        {
            "role": "user",
            "content": """
            Solve: Find all positive integer solutions (x, y, z) satisfying:
            x² + y² = z²
            x + y + z = 1000
            """
        }
    ]
)

print(response.choices[0].message.content)

O1 Series Special Notes:

Do not support system role messages
Do not support streaming output
Do not support temperature, top_p and other creativity parameters
max_tokens defaults to model’s maximum value

Usage Tips

1. Choose the Right Model

Scenario	Recommended Model	Reason
Daily conversations	GPT-5.5 or GPT-4o Mini	Quality-first or cost-effective choice
Image understanding	GPT-5.5 or GPT-4o	Powerful multimodal capabilities
Complex reasoning	o3-pro	PhD-level thinking
Code generation	GPT-5.5, Claude Sonnet 4.6	Strong code understanding
Long documents	GPT-5.5, Gemini 3.1 Pro Preview	Large context window
Creative writing	GPT-5.5	Creative expression
Math problems	o4-mini or o3-pro	Strong reasoning capabilities

2. Optimize Prompts

Clear Instructions

✅ Good Example:

Write a 500-word blog post about healthy eating.
Requirements:
1. Include 3 scientific studies
2. Provide 5 practical recommendations
3. Casual and easy-to-understand language

❌ Bad Example:

Write something about healthy eating

Step-by-Step

For complex tasks, break down into multiple steps:

# Step 1: Generate outline
outline_response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{
        "role": "user",
        "content": "Create an outline for a blog post on healthy eating"
    }]
)

# Step 2: Expand each section based on outline
detail_response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "user", "content": "Create an outline for a blog post on healthy eating"},
        {"role": "assistant", "content": outline_response.choices[0].message.content},
        {"role": "user", "content": "Expand the first section in detail"}
    ]
)

Use Examples

Provide examples to help the model understand your needs better:

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{
        "role": "user",
        "content": """
        Extract project fields from text. Example:
        
        Input: "Project Atlas uses API key group prod and monthly budget 500 USD"
        Output: {"project":"Atlas","key_group":"prod","monthly_budget_usd":500}
        
        Now extract fields from: "Project Orion uses API key group staging and monthly budget 200 USD"
        """
    }]
)

3. Parameter Tuning

number

default:"1"

Control randomness of output:

0: Most deterministic (translation, summarization)
0.7: Balanced (general dialogue)
1.0-1.5: More creative (creative writing)

integer

Maximum number of tokens to generate:

Short responses: 500-1000
Medium responses: 2000-4000
Long responses: 8000+

number

default:"1"

Nucleus sampling, alternative to temperature:

0.1: Conservative
0.9: More diverse
Generally use either temperature or top_p, not both

number

default:"0"

Reduce repetition:

0: No penalty
0.5-1.0: Moderate penalty
2.0: Maximum penalty

Cost Optimization

1. Choose Cost-Effective Models

Daily Tasks

Use GPT-4.1 Mini or GPT-4o Mini for simple daily tasks

Lower cost than flagship models
Good quality
Faster speed

Reasoning Tasks

Use o4-mini instead of o3-pro

80% price reduction
Good reasoning capability
Suitable for most scenarios

2. Control Context Length

# ❌ Inefficient: Passing too much context
messages = get_all_history()  # May contain hundreds of messages

# ✅ Efficient: Only keep necessary context
messages = [
    {"role": "system", "content": system_prompt},
    *get_recent_messages(5),  # Only recent 5 messages
    {"role": "user", "content": user_input}
]

3. Set Reasonable max_tokens

# ❌ Wasteful: No token limit set
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...]
)

# ✅ Economical: Set reasonable limit
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    max_tokens=500  # Limit output length
)

Error Handling

Common Errors

401: Unauthorized

Cause: Invalid or missing API KeySolution:

# Check if API Key is correct
client = OpenAI(
    api_key="YOUR_API_KEY",  # Ensure this is correct
    base_url="https://api2.laozhang.ai/v1"
)

429: Rate Limit

Cause: Request rate limit exceededSolution:

import time
from openai import RateLimitError

for i in range(3):  # Retry up to 3 times
    try:
        response = client.chat.completions.create(...)
        break
    except RateLimitError:
        wait_time = 2 ** i  # Exponential backoff
        print(f"Rate limited, waiting {wait_time} seconds...")
        time.sleep(wait_time)

400: Invalid Request

Cause: Parameter format errorSolution:

Check if model name is correct
Verify message format is correct
Ensure parameters meet requirements

# Correct format
response = client.chat.completions.create(
    model="gpt-4o",  # Use correct model name
    messages=[
        {"role": "user", "content": "Hello"}  # Correct message format
    ]
)

Retry Mechanism

import time
from openai import OpenAI, APIError, RateLimitError, APIConnectionError

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api2.laozhang.ai/v1"
)

def chat_with_retry(messages, max_retries=3):
    for i in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
            return response
        except RateLimitError as e:
            if i < max_retries - 1:
                wait_time = 2 ** i
                print(f"Rate limited, retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                raise
        except (APIError, APIConnectionError) as e:
            if i < max_retries - 1:
                print(f"Request failed, retrying...")
                time.sleep(1)
            else:
                raise

# Usage
response = chat_with_retry([
    {"role": "user", "content": "Hello"}
])

Streaming Response

For long responses, use streaming output for better user experience:

# Streaming output
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Write an article about AI"}
    ],
    stream=True
)

print("Generating...", end="")
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

// Streaming output
const stream = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'user', content: 'Write an article about AI' }
  ],
  stream: true
});

process.stdout.write('Generating...');
for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) {
    process.stdout.write(content);
  }
}
console.log();

Best Practices

Choose the Right Model
- Simple tasks → GPT-4o Mini
- Complex tasks → GPT-4o
- Reasoning tasks → O1 series
Optimize Prompts
- Clear and specific instructions
- Provide examples
- Break down complex tasks
Control Costs
- Only pass necessary context
- Set reasonable max_tokens
- Use cost-effective models
Error Handling
- Implement retry mechanism
- Catch and handle different error types
- Set reasonable timeout
User Experience
- Use streaming output
- Show loading status
- Provide feedback

Chat Completions API - Complete API documentation
Claude Models - Anthropic Claude models guide
Gemini Models - Google Gemini models guide
Pricing - Detailed model pricing information

Core APIs

Model Guides

OpenAI Models Guide

Model Overview

Model Classification

GPT-5.5 Series

GPT-5 / GPT-4.1 Series

o3 / o4 Reasoning Models

GPT-4o Series (Classic Multimodal)

Code Examples

Basic Text Dialogue

Image Understanding

Long Document Analysis

Creative Writing

Complex Code Review

Mathematical Problem Solving

Usage Tips

1. Choose the Right Model

2. Optimize Prompts

3. Parameter Tuning

Cost Optimization

1. Choose Cost-Effective Models

Daily Tasks

Reasoning Tasks

2. Control Context Length

3. Set Reasonable max_tokens

Error Handling

Common Errors

Retry Mechanism

Streaming Response

Best Practices

​Model Overview

​Model Classification

​GPT-5.5 Series

​GPT-5 / GPT-4.1 Series

​o3 / o4 Reasoning Models

​GPT-4o Series (Classic Multimodal)

​Code Examples

​Basic Text Dialogue

​Image Understanding

​Long Document Analysis

​Creative Writing

​Complex Code Review

​Mathematical Problem Solving

​Usage Tips

​1. Choose the Right Model

​2. Optimize Prompts

​3. Parameter Tuning

​Cost Optimization

​1. Choose Cost-Effective Models

Daily Tasks

Reasoning Tasks

​2. Control Context Length

​3. Set Reasonable max_tokens

​Error Handling

​Common Errors

​Retry Mechanism

​Streaming Response

​Best Practices

​Related Resources

Model Overview

Model Classification

GPT-5.5 Series

GPT-5 / GPT-4.1 Series

o3 / o4 Reasoning Models

GPT-4o Series (Classic Multimodal)

Code Examples

Basic Text Dialogue

Image Understanding

Long Document Analysis

Creative Writing

Complex Code Review

Mathematical Problem Solving

Usage Tips

1. Choose the Right Model

2. Optimize Prompts

3. Parameter Tuning

Cost Optimization

1. Choose Cost-Effective Models

2. Control Context Length

3. Set Reasonable max_tokens

Error Handling

Common Errors

Retry Mechanism

Streaming Response

Best Practices

Related Resources