En Bref / Réponse Rapide
Pour utiliser l'API GPT-5.4 : Installez le SDK OpenAI (pip install openai), initialisez le client avec la clé API, appelez chat.completions.create() avec le modèle gpt-5.4. Fonctionnalités clés : utilisation de l'ordinateur (automatisation native du navigateur), recherche d'outils (réduction de 47% des jetons), fenêtre de contexte d'1M, capacités de vision. Tarification : 2,50 $/M jetons d'entrée, 15 $/M jetons de sortie. Ce guide couvre la configuration, des exemples de code, la configuration de l'utilisation de l'ordinateur, l'intégration d'outils et les meilleures pratiques de production.
Introduction
GPT-5.4 n'est pas seulement une autre mise à niveau de modèle. C'est le premier modèle à usage général d'OpenAI doté de capacités natives d'utilisation de l'ordinateur, d'une recherche d'outils efficace et de fenêtres de contexte d'1 million de jetons. L'utilisation efficace de GPT-5.4 nécessite de comprendre ces nouvelles capacités et comment les intégrer à vos flux de travail.
Ce guide fournit des exemples de code fonctionnels pour chaque fonctionnalité majeure de GPT-5.4. Vous apprendrez à implémenter l'automatisation de l'utilisation de l'ordinateur, à configurer la recherche d'outils pour les serveurs MCP, à traiter des images haute résolution, à gérer des bases de code à contexte long et à optimiser les coûts pour les déploiements en production.
Que vous construisiez des agents IA, automatisiez des flux de travail de navigateur ou intégriez GPT-5.4 dans des applications existantes, ce guide vous fournit les détails d'implémentation dont vous avez besoin.
Démarrage Rapide : Votre Première Requête GPT-5.4
Soyez opérationnel avec GPT-5.4 en moins de 5 minutes. Avant d'écrire du code, testez vos requêtes API GPT-5.4 dans Apidog :
- Créez une nouvelle requête HTTP avec POST vers
https://api.openai.com/v1/chat/completions - Ajoutez l'en-tête d'autorisation :
Bearer YOUR_API_KEY - Définissez le corps de la requête avec le modèle, les messages et les paramètres
- Envoyez et inspectez la réponse
- Enregistrez dans une collection pour des tests répétés
- Utilisez des variables d'environnement pour basculer entre les clés API
Cette approche visuelle accélère les tests initiaux et vous aide à comprendre la structure de l'API avant de l'implémenter dans le code.
Prérequis
- Compte OpenAI avec facturation activée
- Clé API de platform.openai.com/api-keys
- Python 3.7+ ou Node.js 14+
Démarrage Rapide Python
from openai import OpenAI
import os
# Initialize client
client = OpenAI(
api_key=os.getenv("OPENAI_API_KEY")
)
# Make request
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "system", "content": "You are a helpful coding assistant."},
{"role": "user", "content": "Write a Python function to sort a list of dictionaries by a key."}
]
)
print(response.choices[0].message.content)Démarrage Rapide Node.js
const OpenAI = require('openai');
const client = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});
async function main() {
const response = await client.chat.completions.create({
model: 'gpt-5.4',
messages: [
{ role: 'system', content: 'You are a helpful coding assistant.' },
{ role: 'user', content: 'Write a Python function to sort a list of dictionaries by a key.' }
]
});
console.log(response.choices[0].message.content);
}
main();Sortie Attendue
def sort_dicts_by_key(dict_list, key, reverse=False):
"""
Sort a list of dictionaries by a specified key.
Args:
dict_list: List of dictionaries to sort
key: The dictionary key to sort by
reverse: If True, sort in descending order
Returns:
Sorted list of dictionaries
"""
return sorted(dict_list, key=lambda x: x.get(key, ''), reverse=reverse)
# Example usage
data = [
{'name': 'Alice', 'age': 30},
{'name': 'Bob', 'age': 25},
{'name': 'Charlie', 'age': 35}
]
sorted_by_age = sort_dicts_by_key(data, 'age')
print(sorted_by_age)
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]Comprendre les Capacités de GPT-5.4
GPT-5.4 excelle dans quatre domaines clés. Comprendre cela vous aide à choisir la bonne approche pour chaque cas d'utilisation.
1. Travail Intellectuel (Taux de réussite GDPval de 83%)
Idéal pour :
- Création et analyse de feuilles de calcul
- Génération de présentations
- Rédaction et édition de documents
- Modélisation financière
- Analyse et rapport de données
2. Utilisation de l'ordinateur (75% Vérifié OSWorld)
Idéal pour :
- Automatisation de navigateur
- Saisie de données dans diverses applications
- Web scraping avec interaction
- Test de flux de travail
- Automatisation de tâches inter-applications
3. Codage (57.7% SWE-Bench Pro)
Idéal pour :
- Développement full-stack
- Génération d'interfaces utilisateur front-end
- Débogage de problèmes complexes
- Refactoring de code
- Génération de tests
4. Intégration d'Outils (54.6% Toolathlon)
Idéal pour :
- Intégrations de serveurs MCP
- Flux de travail API multi-étapes
- Orchestration d'outils externes
- Applications agentiques
API d'Utilisation de l'Ordinateur
Les capacités natives d'utilisation de l'ordinateur de GPT-5.4 représentent le plus grand bond en avant de cette version. Le modèle peut faire fonctionner des ordinateurs via des captures d'écran, des commandes de souris et des entrées clavier.
Lors de la création d'applications avec des capacités d'utilisation de l'ordinateur, testez chaque étape du flux de travail dans Apidog :
- Validez les points d'extrémité de téléchargement de captures d'écran
- Testez les API d'exécution de commandes (clic, saisie, défilement)
- Créez des réponses fictives pour chaque action informatique
- Automatisez les tests de flux de travail multi-tours
- Documentez le contrat d'API d'utilisation de l'ordinateur pour référence d'équipe
Comment fonctionne l'Utilisation de l'Ordinateur
Le flux de travail d'utilisation de l'ordinateur utilise l'outil computer dans les requêtes API. Le modèle :
- Reçoit des captures d'écran de l'état actuel de l'écran
- Analyse les éléments de l'interface utilisateur et détermine les actions
- Retourne des commandes informatiques (clic, saisie, défilement, etc.)
- Votre application exécute les commandes et capture de nouvelles captures d'écran
- La boucle continue jusqu'à l'achèvement de la tâche
Configuration de Base de l'Utilisation de l'Ordinateur
from openai import OpenAI
import base64
client = OpenAI()
def take_screenshot():
"""Capture current screen state - implement for your platform."""
# Use pyautogui, PIL, or platform-specific screenshot
import pyautogui
screenshot = pyautogui.screenshot()
import io
buffer = io.BytesIO()
screenshot.save(buffer, format='PNG')
return base64.b64encode(buffer.getvalue()).decode('utf-8')
def execute_computer_command(command):
"""Execute computer command - implement based on command type."""
import pyautogui
action = command.get('action')
if action == 'click':
x, y = command.get('coordinate', [0, 0])
pyautogui.click(x, y)
elif action == 'type':
text = command.get('text', '')
pyautogui.write(text, interval=0.05)
elif action == 'scroll':
amount = command.get('scroll_amount', 0)
pyautogui.scroll(amount)
elif action == 'keypress':
key = command.get('key', '')
pyautogui.press(key)
# Return new screenshot after action
return take_screenshot()
# Computer use conversation
messages = [{
"role": "user",
"content": [
{
"type": "text",
"text": "Navigate to gmail.com and log in with the credentials I provided."
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{take_screenshot()}"
}
}
]
}]
# Request with computer tool
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
tools=[{
"type": "computer",
"display_width": 1920,
"display_height": 1080,
"display_number": 1
}],
tool_choice="required"
)
# Parse and execute computer commands
for tool_call in response.choices[0].message.tool_calls:
if tool_call.type == "computer":
command = tool_call.function.arguments
new_screenshot = execute_computer_command(command)
# Continue conversation with new screenshot
messages.append({
"role": "assistant",
"content": response.choices[0].message.content
})
messages.append({
"role": "user",
"content": [{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{new_screenshot}"}
}]
})Politiques de Sécurité pour l'Utilisation de l'Ordinateur
Configurez le comportement de sécurité en fonction de votre tolérance au risque :
# Safe mode - requires confirmation for sensitive actions
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
tools=[{
"type": "computer",
"display_width": 1920,
"display_height": 1080,
"confirmation_policy": "always" # or "never" or "selective"
}],
# Custom system message for safety
system_message="""You are operating a computer. Follow these safety rules:
1. Never enter credentials without explicit user confirmation
2. Ask before deleting files or data
3. Confirm before sending emails or messages
4. Report any errors or unexpected states immediately
"""
)Exemple d'Automatisation de Navigateur
Automatisez les tâches du navigateur avec l'intégration Playwright :
from playwright.sync_api import sync_playwright
def browser_automation_workflow():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
# Navigate to page
page.goto("https://example.com")
# Get screenshot for GPT-5.4
screenshot = page.screenshot()
screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
messages = [{
"role": "user",
"content": [
{"type": "text", "text": "Find the login form and fill it out."},
{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
]
}]
# Get computer commands from GPT-5.4
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
tools=[{"type": "computer"}],
tool_choice="required"
)
# Parse and execute commands on browser
for tool_call in response.choices[0].message.tool_calls:
if tool_call.type == "computer":
command = json.loads(tool_call.function.arguments)
if command.get('action') == 'click':
x, y = command.get('coordinate', [0, 0])
page.mouse.click(x, y)
elif command.get('action') == 'type':
page.keyboard.type(command.get('text', ''))
# Get new screenshot and continue
new_screenshot = page.screenshot()
# ... continue loopAutomatisation des E-mails et du Calendrier
Exemple réel : Traiter les e-mails et planifier des événements :
def process_email_and_schedule_meeting():
"""
Workflow: Read unread emails, extract meeting requests,
check calendar availability, and send calendar invites.
"""
workflow_prompt = """
Complete this workflow:
1. Open Gmail and find unread emails from the last 24 hours
2. Identify any meeting requests or scheduling questions
3. For each meeting request:
- Extract proposed dates/times
- Note attendees and meeting purpose
4. Open Google Calendar and check availability
5. Send calendar invites for confirmed meetings
6. Reply to emails confirming the scheduled time
Report back with a summary of what was accomplished.
"""
# Start with inbox screenshot
screenshot = take_screenshot()
messages = [{
"role": "user",
"content": [
{"type": "text", "text": workflow_prompt},
{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot}"}}
]
}]
# Execute multi-turn computer use workflow
for turn in range(10): # Limit turns to prevent infinite loops
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
tools=[{"type": "computer"}],
tool_choice="required"
)
# Check if task is complete
if "complete" in response.choices[0].message.content.lower():
print(f"Workflow completed in {turn + 1} turns")
break
# Execute computer commands and get new screenshot
# ... (command execution logic from earlier example)Optimisation des Performances
Résultats de Mainstay traitant 30 000 portails de taxes foncières :
- Taux de réussite de 95% au premier essai
- 3x plus rapide que les modèles précédents
- 70% moins de jetons par session
Conseils d'optimisation :
- Utilisez des captures d'écran de haute qualité (minimum 1920x1080)
- Fournissez des descriptions de tâches claires et spécifiques
- Implémentez des limites de tours pour éviter les boucles infinies
- Mettez en cache les captures d'écran pour éviter les captures redondantes
- Utilisez des politiques de confirmation sélectives pour les flux de travail de confiance
Recherche et Intégration d'Outils
La recherche d'outils réduit l'utilisation de jetons de 47% tout en permettant de travailler avec de grands écosystèmes d'outils.
Comment fonctionne la Recherche d'Outils
Au lieu de charger toutes les définitions d'outils au préalable, le modèle reçoit une liste légère et recherche les définitions à la demande.
Configuration de Base de la Recherche d'Outils
# Define available tools (lightweight list)
available_tools = [
{
"name": "get_weather",
"description": "Get current weather for a location"
},
{
"name": "send_email",
"description": "Send an email to a recipient"
},
{
"name": "calendar_search",
"description": "Search calendar for events"
},
# ... hundreds more tools
]
# Initial request - model sees tool list, not full definitions
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "user", "content": "What's the weather in Tokyo and send it to my team?"}
],
tools=available_tools,
tool_choice="auto"
)
# If model wants to use a tool, it requests the definition
# Your application provides the full definition at that pointIntégration de Serveur MCP
Le benchmark MCP Atlas de Scale a montré une réduction de 47% des jetons avec la recherche d'outils.
# MCP Server with many tools
mcp_servers = [
{
"name": "filesystem",
"description": "File system operations",
"tool_count": 12
},
{
"name": "database",
"description": "Database query operations",
"tool_count": 8
},
{
"name": "web-search",
"description": "Web search and scraping",
"tool_count": 15
}
# ... 36 MCP servers in benchmark
]
# Tool search configuration
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "user", "content": "Find all Python files modified today and search for TODO comments."}
],
tools=mcp_servers,
# Tool search enabled automatically when using this pattern
parallel_tool_calls=True
)
# Model will request tool definitions as needed
# Token savings: 47% vs loading all definitions upfrontFlux de Travail Multi-Étapes de Type Toolathlon
Toolathlon teste des flux de travail d'outils multi-étapes complexes :
def grade_assignments_workflow():
"""
Complex workflow: Read emails with attachments,
upload to grading system, grade assignments,
record results in spreadsheet.
"""
workflow_steps = """
1. Read emails from students with assignment attachments
2. Download each attachment
3. Upload to grading portal
4. Grade each assignment using rubric
5. Record grades in spreadsheet
6. Send confirmation emails to students
"""
tools = [
{"name": "email_read", "description": "Read emails from inbox"},
{"name": "email_send", "description": "Send emails"},
{"name": "file_download", "description": "Download file attachments"},
{"name": "file_upload", "description": "Upload files to web portal"},
{"name": "web_form_fill", "description": "Fill and submit web forms"},
{"name": "spreadsheet_write", "description": "Write data to spreadsheet"},
{"name": "rubric_evaluate", "description": "Evaluate work against rubric"}
]
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "user", "content": workflow_steps}
],
tools=tools,
parallel_tool_calls=True # Enable parallel tool execution
)
# GPT-5.4 achieves 54.6% on Toolathlon vs 45.7% for GPT-5.2
# Key: Better tool selection and fewer turns requiredVision et Traitement d'Image
GPT-5.4 prend en charge une perception visuelle améliorée avec des détails d'image originaux jusqu'à 10,24 millions de pixels.
Niveaux de Détail de l'Image
# Original detail - highest fidelity (10.24M pixels, 6000px max dimension)
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": "https://example.com/high-res-image.jpg",
"detail": "original" # or "high" or "low"
}
},
{"type": "text", "text": "Analyze this technical diagram."}
]
}]
)
# High detail - 2.56M pixels, 2048px max dimension
# Low detail - Fastest processing, lower accuracyExemple d'Analyse de Document
OmniDocBench : taux d'erreur de 0,109 (contre 0,140 pour GPT-5.2)
def parse_complex_document(pdf_path):
"""Parse multi-page PDF with tables and figures."""
# Convert PDF pages to images
from pdf2image import convert_from_path
pages = convert_from_path(pdf_path, dpi=300)
messages = [{"role": "user", "content": []}]
for i, page in enumerate(pages[:5]): # First 5 pages
import io, base64
buffer = io.BytesIO()
page.save(buffer, format='PNG')
img_b64 = base64.b64encode(buffer.getvalue()).decode()
messages[0]["content"].append({
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{img_b64}",
"detail": "high"
}
})
messages[0]["content"].append({
"type": "text",
"text": """
Extract all data from this document:
1. Tables with row/column headers
2. Key figures and their captions
3. Summary statistics mentioned in text
Return as structured JSON.
"""
})
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages
)
return response.choices[0].message.contentAnalyse de Capture d'Écran d'Interface Utilisateur
def analyze_ui_screenshot(screenshot_path):
"""Analyze UI screenshot for accessibility issues."""
with open(screenshot_path, 'rb') as f:
img_b64 = base64.b64encode(f.read()).decode()
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{img_b64}",
"detail": "original"
}
},
{
"type": "text",
"text": """
Review this UI screenshot for accessibility issues:
1. Color contrast problems
2. Missing labels or alt text indicators
3. Keyboard navigation issues (visible focus states)
4. Text size and readability
5. Screen reader compatibility concerns
List issues with specific locations and severity.
"""
}
]
}]
)
return response.choices[0].message.contentFlux de Travail à Contexte Long
GPT-5.4 prend en charge des fenêtres de contexte allant jusqu'à 1 million de jetons (expérimental).
Contexte Standard (272K jetons)
# Load large codebase file
with open('large_codebase.py', 'r') as f:
code = f.read()
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "system", "content": "You are a code review assistant."},
{"role": "user", "content": f"""
Review this codebase for:
1. Security vulnerabilities
2. Performance issues
3. Code style inconsistencies
4. Missing error handling
Code:
{code}
"""}
],
max_tokens=4000
)Contexte Étendu (1M jetons)
Configurez via les paramètres de l'API :
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "user", "content": large_document}
],
# Extended context configuration
extra_body={
"model_context_window": 1048576, # 1M tokens
"model_auto_compact_token_limit": 272000 # Auto-compact after 272K
}
)
# Note: Requests exceeding 272K count at 2x usage rateAnalyse Multi-Documents
def analyze_multiple_documents(documents):
"""Analyze 10+ documents in single context."""
content_parts = []
for i, doc in enumerate(documents):
content_parts.append(f"=== Document {i+1}: {doc['title']} ===\n")
content_parts.append(doc['content'][:50000]) # Truncate if needed
content_parts.append("\n\n")
combined_content = "".join(content_parts)
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{
"role": "user",
"content": f"""
Analyze these documents and provide:
1. Summary of key themes across all documents
2. Contradictions or inconsistencies between documents
3. Action items mentioned in any document
4. Timeline of events if applicable
{combined_content}
"""
}],
max_tokens=8000
)
return response.choices[0].message.contentFlux de Travail de Codage et de Développement
GPT-5.4 égale GPT-5.3-Codex sur SWE-Bench Pro (57,7%) avec des capacités d'utilisation de l'ordinateur ajoutées.
Génération Frontend
def generate_frontend_component(spec):
"""Generate complete React component with styling."""
prompt = f"""
Create a complete React component based on this specification:
{spec}
Requirements:
1. Functional component with hooks
2. TypeScript types for all props and state
3. Tailwind CSS for styling
4. Responsive design (mobile, tablet, desktop)
5. Accessibility (ARIA labels, keyboard navigation)
6. Unit tests with Jest/React Testing Library
Return complete code for:
- Component file (.tsx)
- Styles (if not Tailwind)
- Test file (.test.tsx)
"""
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": prompt}],
max_tokens=6000
)
return response.choices[0].message.content
# Example: Theme park simulation (from OpenAI demo)
theme_park_spec = """
Create an interactive isometric theme park simulation game:
- Tile-based path placement
- Ride and scenery construction
- Guest pathfinding and queueing
- Park metrics (money, guests, happiness, cleanliness)
- Browser-playable with Playwright testing
- Generated isometric assets
"""
component_code = generate_frontend_component(theme_park_spec)Débogage de Problèmes Complexes
def debug_with_full_context(error_logs, codebase_files, stack_trace):
"""Debug using full context of logs, code, and stack trace."""
context = f"""
ERROR LOGS:
{error_logs}
STACK TRACE:
{stack_trace}
RELEVANT CODE FILES:
{codebase_files}
Task: Identify the root cause and provide a fix.
Consider:
1. Race conditions or timing issues
2. Memory leaks or resource exhaustion
3. Incorrect assumptions about data flow
4. Edge cases not handled
5. External dependency issues
Provide:
1. Root cause analysis
2. Specific code changes needed
3. Tests to prevent regression
"""
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": context}],
max_tokens=4000
)
return response.choices[0].message.contentTests Interactifs Playwright
Compétence expérimentale de Codex pour les tests de jeu de navigateur :
def playwright_interactive_debug():
"""
Use Playwright Interactive for browser playtesting.
GPT-5.4 can test apps while building them.
"""
prompt = """
Build a todo web application and test it as you build:
1. Create HTML structure
2. Add CSS styling
3. Implement JavaScript functionality
4. After each feature, use Playwright to:
- Verify element visibility
- Test user interactions
- Check state persistence
- Validate edge cases
Report any issues found during testing and fix them.
"""
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": prompt}],
tools=[{"type": "playwright_interactive"}],
max_tokens=8000
)
return response.choices[0].message.contentDiffusion des Réponses
La diffusion réduit la latence perçue pour les réponses longues.
Diffusion Python
from openai import OpenAI
client = OpenAI()
stream = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": "Write a detailed explanation of quantum computing."}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)Diffusion Node.js
const stream = await client.chat.completions.create({
model: 'gpt-5.4',
messages: [{ role: 'user', content: 'Write a detailed explanation of quantum computing.' }],
stream: true
});
for await (const chunk of stream) {
if (chunk.choices[0].delta.content) {
process.stdout.write(chunk.choices[0].delta.content);
}
}Diffusion avec Comptage de Jetons
def stream_with_usage(stream):
"""Track token usage while streaming."""
total_tokens = 0
for chunk in stream:
if chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end="", flush=True)
total_tokens += len(content) // 4 # Rough estimate
if chunk.usage:
print(f"\n\nUsage: {chunk.usage.total_tokens} tokens")
return total_tokensGestion des Erreurs et Logique de Réessai
Le code de production nécessite une gestion des erreurs robuste.
Gestion Complète des Erreurs
from openai import OpenAI, RateLimitError, APIError, AuthenticationError
import time
client = OpenAI()
def make_request_with_retry(messages, max_retries=3):
"""Make request with exponential backoff retry logic."""
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
max_tokens=2000,
temperature=0.7
)
return response
except RateLimitError as e:
if attempt == max_retries - 1:
raise
wait_time = 2 ** attempt # 1s, 2s, 4s
print(f"Rate limited. Waiting {wait_time}s...")
time.sleep(wait_time)
except APIError as e:
if e.status_code >= 500: # Server error, retry
if attempt == max_retries - 1:
raise
wait_time = 2 ** attempt
time.sleep(wait_time)
else:
raise # Client error, don't retry
except AuthenticationError:
print("Invalid API key. Check your credentials.")
raise
except Exception as e:
print(f"Unexpected error: {e}")
raise
raise Exception("Max retries exceeded")
# Usage
try:
response = make_request_with_retry([
{"role": "user", "content": "Hello, GPT-5.4!"}
])
print(response.choices[0].message.content)
except Exception as e:
print(f"Request failed: {e}")Gestion des Délais d'Attente
import httpx
# Configure timeout
client = OpenAI(
timeout=httpx.Timeout(60.0, connect=10.0) # 60s total, 10s connect
)
try:
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": "Long-running task..."}]
)
except httpx.TimeoutException:
print("Request timed out. Consider using streaming or reducing complexity.")Meilleures Pratiques de Production
Utilisation d'Apidog pour les Flux de Travail API en Production
Avant de déployer les intégrations GPT-5.4 en production, établissez des flux de travail de test et de surveillance robustes :
Pipeline de Test API :
- Utilisez Apidog pour créer des suites de tests complètes couvrant les cas de succès et d'erreur
- Automatisez les tests API dans les pipelines CI/CD pour détecter les modifications cassantes
- Simulez les réponses de GPT-5.4 pour les tests d'intégration afin d'éviter les coûts de jetons
- Générez automatiquement la documentation API à partir des requêtes testées
Collaboration d'Équipe :
- Partagez les collections API avec les membres de l'équipe pour des modèles d'intégration cohérents
- Utilisez des variables d'environnement pour gérer différentes clés API (dev/staging/production)
- Ajoutez une documentation de requête expliquant le comportement attendu et les cas limites
Modèle d'Intégration :
Stratégies d'Optimisation des Coûts
Optimisation de l'Invite
# Bad: Verbose prompt
bad_prompt = """
Hello! I hope you're doing well. I was wondering if you could possibly help me
with something. I have this code here and I'm not quite sure what it does.
Could you please explain it to me? Here's the code:
""" + code
# Good: Direct prompt
good_prompt = f"Explain what this code does:\n{code}"
# Token savings: ~50 tokens = $0.000125 per request
# At 1M requests/month: $125 savingsContrôle de la Longueur de la Réponse
# Set max_tokens appropriately
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": "Summarize this article."}],
max_tokens=200 # Don't let it ramble
)
# Use stop sequences
response = client.chat.completions.create(
model="gpt-5.4",
messages=[{"role": "user", "content": "List 5 items."}],
stop=["\n\n", "6."] # Stop after list
)Traitement par Lots
# Use Batch API for 50% discount
from openai import OpenAI
client = OpenAI()
# Create batch file
batch_requests = []
for article in articles:
batch_requests.append({
"custom_id": article["id"],
"method": "POST",
"url": "/v1/chat/completions",
"body": {
"model": "gpt-5.4",
"messages": [{"role": "user", "content": article["content"]}]
}
})
# Upload and process
batch_file = client.files.create(
file=json.dumps(batch_requests),
purpose="batch"
)
batch = client.batches.create(
input_file_id=batch_file.id,
endpoint="/v1/chat/completions",
completion_window="24h"
)
# 50% cost savings for non-real-time workloadsMise en Cache des Requêtes Répétées
import hashlib
import json
class ResponseCache:
"""Cache identical API responses."""
def __init__(self):
self.cache = {}
def _get_key(self, messages):
return hashlib.md5(json.dumps(messages).encode()).hexdigest()
def get_or_create(self, client, messages, **kwargs):
key = self._get_key(messages)
if key in self.cache:
return self.cache[key]
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
**kwargs
)
self.cache[key] = response
return response
# Usage
cache = ResponseCache()
response = cache.get_or_create(client, messages)Conclusion
GPT-5.4 ouvre de nouvelles possibilités pour les applications basées sur l'IA. L'utilisation native de l'ordinateur permet l'automatisation du navigateur et des flux de travail inter-applications. La recherche d'outils réduit les coûts de 47% tout en prenant en charge de plus grands écosystèmes d'outils. Une vision améliorée gère l'analyse complexe de documents. Et les fenêtres de contexte d'1 million de jetons traitent des bases de code entières.
Construire des applications de production avec GPT-5.4 nécessite des flux de travail robustes de test, de débogage et de documentation d'API. Apidog fournit une plateforme unifiée pour le cycle de vie complet de l'API.
Que vous construisiez des agents IA, automatisiez des flux de travail ou créiez des fonctionnalités orientées client alimentées par GPT-5.4, des pratiques solides de développement API accélèrent la livraison et réduisent les bogues.
Commencez par des complétions de chat de base, puis ajoutez l'utilisation de l'ordinateur, la recherche d'outils et la vision selon les besoins de vos cas d'utilisation. Surveillez attentivement les coûts lors du déploiement initial et optimisez les invites et les stratégies de mise en cache.
FAQ
Comment utiliser la fonction d'utilisation de l'ordinateur de GPT-5.4 ?
Utilisez l'outil computer dans les requêtes API. Envoyez des captures d'écran comme images, recevez des commandes informatiques (clic, saisie, défilement) en réponse. Exécutez les commandes à l'aide de pyautogui ou Playwright, puis envoyez de nouvelles captures d'écran. Bouclez jusqu'à l'achèvement de la tâche. Configurez les politiques de sécurité en fonction de votre tolérance au risque.
Qu'est-ce que la recherche d'outils et comment l'activer ?
La recherche d'outils charge les définitions d'outils à la demande plutôt qu'au préalable, réduisant l'utilisation de jetons de 47%. Activez-la en fournissant une liste d'outils légère dans les requêtes. Le modèle demande les définitions complètes si nécessaire. Fonctionne automatiquement avec les serveurs MCP.
Comment utiliser la fenêtre de contexte d'1 million de jetons ?
Configurez via les paramètres extra_body : model_context_window: 1048576 et model_auto_compact_token_limit: 272000. Remarque : les requêtes dépassant 272K jetons sont comptées à un taux d'utilisation de 2x. Disponible expérimentalement dans Codex.
Quelle est la différence entre GPT-5.4 et GPT-5.4-Pro ?
GPT-5.4 Pro offre une plus grande précision sur les raisonnements complexes (89,3% contre 82,7% sur BrowseComp) mais coûte 12 fois plus cher (30$/180$ contre 2,50$/15$). Utilisez la version standard pour la plupart des charges de travail, Pro pour les tâches nécessitant une précision maximale.
Comment réduire les coûts de l'API GPT-5.4 ?
Utilisez des entrées mises en cache (90% d'économies), optimisez la longueur des invites, définissez des limites max_tokens, utilisez l'API Batch (50% de réduction), implémentez la mise en cache des réponses et choisissez des niveaux de détail appropriés pour les images.
GPT-5.4 peut-il traiter plusieurs images en une seule requête ?
Oui. Incluez plusieurs parties de contenu image_url dans un seul message. Utile pour les documents multipages, les tâches de comparaison ou les captures d'écran séquentielles.
Comment gérer les limites de débit en production ?
Implémentez une logique de réessai exponentielle (délais de 1s, 2s, 4s), utilisez l'API Batch pour le traitement en masse, répartissez les requêtes dans le temps et demandez des augmentations de limite pour les besoins à grand volume.
Quels langages de programmation GPT-5.4 prend-il le mieux en charge ?
GPT-5.4 excelle en Python, JavaScript/TypeScript, React, Node.js et les technologies web courantes. Également solide en Java, Go, Rust et SQL. Égale les performances de GPT-5.3-Codex (57,7% SWE-Bench Pro).
Comment diffuser les réponses de GPT-5.4 ?
Définissez stream=True dans les requêtes API. Itérez sur les fragments et traitez chaque delta. Réduit la latence perçue pour les réponses longues.
GPT-5.4 est-il adapté aux charges de travail de production ?
Oui. GPT-5.4 présente 33% moins d'erreurs factuelles que GPT-5.2, utilise les jetons plus efficacement et inclut une gestion robuste des erreurs. Implémentez une logique de réessai, une surveillance et un suivi des coûts pour les déploiements en production.