GPT-5 模型的最新版本為開發者帶來了尖端的 AI 能力，並在編碼、推理和創造力方面取得了顯著進步。GPT-5 模型新增了一些 API 功能，使開發者能夠建立可精細控制的輸出。本入門指南在 API 的背景下介紹了 GPT-5，總結了其差異，並解釋瞭如何將其應用於程式碼和自動化任務。
GPT-5 專為開發者打造。新版 GPT-5 使用的工具可讓您控制詳細程度、推理深度和輸出格式。在本指南中，您將學習如何開始使用 GPT-5，瞭解它的一些獨特引數，並檢視 OpenAI Cookbook 中的程式碼示例，這些示例展示了比先前版本模型提供更多功能的流程。
GPT-5有哪些新功能？
GPT-5 更智慧、更可控，更適合處理複雜工作。它非常擅長程式碼生成、推理和工具使用。該模型在工程基準測試中展現出頂尖效能，能夠編寫精美的前端 UI，良好地遵循指令，並能夠在完成多步驟任務時自主執行。該模型旨在讓您感覺自己正在與真正的協作者互動。其主要功能包括：
突破效能力
- 在 SWE-bench (74.9%) 和 Aider (88%) 上均表現出色
- 能夠生成複雜、響應迅速的 UI 程式碼，同時展現設計感
- 能夠修復棘手的 bug 並理解大型程式碼庫
- 能夠像真正的 AI 代理一樣規劃任務，因為它能夠精準地使用 API，並能夠從工具故障中正確恢復。
更智慧的推理，更少的幻覺
- 更少的事實錯誤和幻覺
- 更好地理解和執行使用者指令
- 代理行為和工具整合
- 能夠執行多步驟、多工具的工作流程
為什麼透過API使用GPT-5？
GPT-5 專為開發者打造，在實際編碼和資料任務中實現了專家級效能。它擁有強大的 API，能夠實現自動化、精準度和控制力。無論您是除錯還是構建完整的應用程式，GPT-5 都能輕鬆與您的工作流程整合，幫助您在極低負載的情況下提升生產力和可靠性。
- 開發者專屬：專為編碼工作流程構建，因此易於整合到開發工具和 IDE 中。
- 久經驗證的效能：SOTA 實際任務（例如錯誤修復、程式碼編輯），包含必要的錯誤和標記。
- 細粒度控制：透過對詳細程度、推理和藍圖工具呼叫等新引數進行控制，您可以調整輸出並開發自動化流水線。
入門指南
要在您的應用程式中開始使用 GPT-5，您需要配置對 API 的訪問許可權，瞭解可用的不同端點，並根據您的需求選擇合適的模型變體。本節將指導您如何配置 API 憑據、選擇哪個端點進行聊天或響應，以及如何瀏覽 GPT-5 模型，以便您充分發揮其潛力。
- 訪問 GPT-5 API
首先，設定您的 API 憑據：如果您想使用 OPENAI_API_KEY 作為環境變數。然後安裝或升級 OpenAI SDK 以使用 GPT-5。之後，您可以像呼叫任何其他模型一樣透過 API 呼叫 GPT-5 模型（gpt-5、gpt-5-mini、gpt-5-nano）。建立一個 .env 檔案並將 API 金鑰儲存為：
OPENAI_API_KEY=sk-abc1234567890—
- API 金鑰和身份驗證
要進行任何 GPT-5 API 呼叫，您需要一個有效的 OpenAI API 金鑰。您可以設定環境變數 OPENAI_API_KEY，或將金鑰直接傳遞給客戶端。請務必妥善保管您的金鑰，因為它將用於驗證您的請求。
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get("OPENAI_API_KEY")
)
- 選擇正確的端點
GPT-5 提供 Responses API，作為與模型互動的統一端點，透過同一介面提供推理跟蹤、工具呼叫和高階控制，使其成為最佳選擇。OpenAI 建議所有新部署都使用此 API。
from openai import OpenAI
import os
client = OpenAI()
response = client.responses.create(
model="gpt‑5",
input=[{"role": "user", "content": "Tell me a one-sentence bedtime story about a unicorn."}]
)
print(response.output_text)
模型變體
| 模型變體 | 最佳應用場景 | 關鍵優勢 |
|---|---|---|
| gpt‑5 | 複雜的、需要多步驟推理和編碼任務 | 高效能 |
| gpt‑5‑mini | 需要兼顧速度和價值的平衡任務 | 成本較低，速度尚可 |
| gpt‑5‑nano | 即時或資源受限的環境 | 超低延遲，成本最低 |
GPT-5 版本
以程式設計方式使用GPT-5
要訪問 GPT-5，我們可以使用 OpenAI SDK 來呼叫 GPT-5。例如，如果您使用 Python：
from openai import OpenAI client = OpenAI()
然後使用 client.responses.create 提交包含 GPT-5 訊息和引數的請求。SDK 將自動使用您的 API 金鑰對請求進行身份驗證。
API請求結構
典型的 GPT-5 API 請求包含以下欄位：
- model：GPT-5 變體（GPT-5、GPT-5-mini 或 GPT-5-nano）。
- input/messages:
- 對於響應 API：使用包含訊息列表的輸入欄位（每條訊息都具有角色和內容）。
- 對於聊天完成 API：使用具有相同結構的 messages 欄位。
- text：這是一個可選引數，包含一個輸出樣式引數字典，例如：
- verbosity：“low”、“medium”或“high”，用於控制詳細程度。
- reasoning：這是一個可選引數，包含一個字典，用於控制模型應用的推理工作量，例如：
- effort：“minimal”，用於更快、更輕量的任務。
- tools：這是一個可選引數，包含一個自定義工具定義列表，例如用於函式呼叫或語法約束。
- 關鍵引數：verbosity、reasoning_effort、max_tokens
與 GPT-5 互動時，各種引數允許您自定義模型的響應方式。這種感知使您能夠更好地控制與收到的響應相關的質量、效能和成本。
- verbosity：管理模型響應中提供的詳細程度。可接受的系列（值）：低、中或高
- “low”通常在尚未顯示的文字區域中顯示，並提供簡短、切中要點的答案
- “high”提供全面、詳細的解釋和答案
- reasoning_effort：指模型在響應之前進行的內部推理量。可接受的系列（值）：最小、低、中、高。
- 設定為“minimal”通常會返回最快的答案，且幾乎不包含任何解釋。
- 設定為“high”可以為模型的輸出提供更多空間進行更深入的分析，因此，相對於之前的設定，輸出可能更加完善。
- max_tokens：設定模型響應中令牌數量的上限。最大令牌數有助於控制成本或限制預期答案的長度。
API呼叫示例
這是一個使用 OpenAI 庫呼叫 GPT-5 的 Python 示例。它接收併傳送使用者提示，然後列印模型的響應：
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5",
input=[{"role": "user", "content": "Hello GPT-5, what can you do?"}],
text={"verbosity": "medium"},
reasoning={"effort": "minimal"}
)
print(response.output)
輸出：
高階功能
在下一節中，我們將測試 GPT-5 API 的 4 項新功能。
詳細程度控制
詳細程度引數允許您指示 GPT-5 應該簡潔還是詳細。您可以將詳細程度設定為“低”、“中”或“高”。詳細程度越高，模型的輸出就越長、越詳細。相反，低詳細程度使模型專注於提供更簡短的答案。
示例：編碼用例：斐波那契數列
from openai import OpenAI
client = OpenAI(api_key="sk-proj---")
prompt = "Output a Python program for fibonacci series"
def ask_with_verbosity(verbosity: str, question: str):
response = client.responses.create(
model="gpt-5-mini",
input=question,
text={
"verbosity": verbosity
}
)
# Extract assistant's text output
output_text = ""
for item in response.output:
if hasattr(item, "content"):
for content in item.content:
if hasattr(content, "text"):
output_text += content.text
# Token usage details
usage = response.usage
print("--------------------------------")
print(f"Verbosity: {verbosity}")
print("Output:")
print(output_text)
print("Tokens => input: {} | output: {}".format(
usage.input_tokens, usage.output_tokens
))
此用例包含不同詳細程度的程式碼生成。
- Low：生成最少的程式碼，且僅包含極少的解釋。
ask_with_verbosity("low", prompt)
響應：
Verbosity: low
Output:
```python
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
def main():
try:
n = int(input("Enter how many Fibonacci numbers to print: "))
if n <= 0:
print("Please enter a positive integer.")
return
except ValueError:
print("Invalid input.")
return
print(*fibonacci(n))
if __name__ == "__main__":
main()
```
Tokens => input: 13 | output: 375
- Medium：生成帶有內聯註釋和一些結構元素的程式碼。
ask_with_verbosity("medium", prompt)
響應：
Verbosity: medium
Output:
Here's a simple Python program that prints the first N Fibonacci numbers (starting with 0, 1). It validates input and uses an efficient iterative approach:
```python
def fib_series(n):
"""Return a list with the first n Fibonacci numbers (0, 1, 1, 2, ...)."""
if n <= 0:
return []
if n == 1:
return [0]
series = [0, 1]
for _ in range(2, n):
series.append(series[-1] + series[-2])
return series
def main():
try:
n = int(input("Enter number of Fibonacci terms to generate: ").strip())
except ValueError:
print("Please enter a valid integer.")
return
if n <= 0:
print("Enter a positive integer.")
return
series = fib_series(n)
print("Fibonacci series (first {} terms):".format(n))
print(", ".join(map(str, series)))
if __name__ == "__main__":
main()
```
If you want other variants (e.g., recursive version, generator that yields values indefinitely, or printing up to a maximum value instead of a count), tell me which and I can provide it.
Tokens => input: 13 | output: 590
- High：生成帶有引數、驗證和詳細註釋的完整生產指令碼。
ask_with_verbosity("high", prompt)
響應：
Verbosity: high
Output:
Below are several Python programs/functions for generating Fibonacci numbers and the Fibonacci series. I include a short explanation for each, examples of how to use them, and notes about performance so you can choose the one that best fits your needs.
Note: the usual convention shown here is F0 = 0, F1 = 1, Fn = Fn-1 + Fn-2.
1) Simple iterative version — recommended for generating a sequence (O(n) time, O(1) extra space)
```python
def fibonacci_list(n):
"""Return a list with the first n Fibonacci numbers: F0 .. F(n-1).
n must be a non-negative integer."""
if n < 0:
raise ValueError("n must be non-negative")
if n == 0:
return []
if n == 1:
return [0]
seq = [0, 1]
for _ in range(2, n):
seq.append(seq[-1] + seq[-2])
return seq
# Example usage:
if __name__ == "__main__":
k = int(input("Which Fibonacci index (n)? "))
print(f"F_{k} =", fibonacci_n(k))
```
2) Generator style — iterate lazily over the sequence
```python
def fib_generator():
"""Infinite Fibonacci generator: yields 0, 1, 1, 2, 3, ..."""
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# Example: print first 10 Fibonacci numbers
if __name__ == "__main__":
import itertools
for x in itertools.islice(fib_generator(), 10):
print(x, end=" ")
print()
```
```
3) Recursive with memoization (fast and simple)
```python
from functools import lru_cache
@lru_cache(maxsize=None)
def fib_memo(n):
if n < 0:
raise ValueError("n must be non-negative")
if n < 2:
return n
return fib_memo(n-1) + fib_memo(n-2)
# Example:
if __name__ == "__main__":
print(fib_memo(100)) # works quickly thanks to memoization
```
```
Which one should you use?
- For typical use (print the first N Fibonacci numbers or compute F_n for moderate n), use the simple iterative fibonacci_list or fibonacci_n.
- For very large n (e.g., thousands or millions of digits), use the fast doubling method (fib_fast_doubling) — it computes F_n in O(log n) arithmetic operations using Python's big integers.
- Avoid the naive recursion except for teaching/demonstration.
- Use memoized recursion for convenience if you want recursive style but still need speed.
If you tell me which variant you want (print series vs return nth value, starting indices, how you want input, or limits like very large n), I can provide a single small script tailored to that use-case.
Tokens => input: 13 | output: 1708
自由格式函式呼叫
GPT-5 現在可以使用新的工具“type”: “custom”將原始文字有效負載（從 Python 指令碼到 SQL 查詢的任何內容）傳送到您的自定義工具，而無需將資料包裝成 JSON。這與傳統的結構化函式呼叫不同，讓您在與外部執行時互動時擁有更大的靈活性，例如：
- 帶有沙盒的 code_exec（Python、C++、Java 等）
- SQL 資料庫
- Shell 環境
- 配置生成器
請注意，自定義工具型別不支援並行工具呼叫。
為了說明自由格式工具呼叫的用法，我們將要求 GPT-5 執行以下任務：
- 生成用於計算兩個 5×5 矩陣乘法的 Python、C++ 和 Java 程式碼。
- 僅列印程式碼中每次迭代所用的時間（以毫秒為單位）。
- 呼叫所有三個函式，然後停止
from openai import OpenAI
from typing import List, Optional
MODEL_NAME = "gpt-5-mini"
# Tools that will be passed to every model invocation
TOOLS = [
{
"type": "custom",
"name": "code_exec_python",
"description": "Executes python code",
},
{
"type": "custom",
"name": "code_exec_cpp",
"description": "Executes c++ code",
},
{
"type": "custom",
"name": "code_exec_java",
"description": "Executes java code",
},
]
client = OpenAI(api_key="ADD-YOUR-API-KEY")
def create_response(
input_messages: List[dict],
previous_response_id: Optional[str] = None,
):
"""Wrapper around client.responses.create."""
kwargs = {
"model": MODEL_NAME,
"input": input_messages,
"text": {"format": {"type": "text"}},
"tools": TOOLS,
}
if previous_response_id:
kwargs["previous_response_id"] = previous_response_id
return client.responses.create(**kwargs)
def run_conversation(
input_messages: List[dict],
previous_response_id: Optional[str] = None,
):
"""Recursive function to handle tool calls and continue conversation."""
response = create_response(input_messages, previous_response_id)
# Check for tool calls in the response
tool_calls = [output for output in response.output if output.type == "custom_tool_call"]
if tool_calls:
# Handle all tool calls in this response
for tool_call in tool_calls:
print("--- tool name ---")
print(tool_call.name)
print("--- tool call argument (generated code) ---")
print(tool_call.input)
print() # Add spacing
# Add synthetic tool result to continue the conversation
input_messages.append({
"type": "function_call_output",
"call_id": tool_call.call_id,
"output": "done",
})
# Continue the conversation recursively
return run_conversation(input_messages, previous_response_id=response.id)
else:
# No more tool calls - check for final response
if response.output and len(response.output) > 0:
message_content = response.output[0].content
if message_content:
print("--- final model response ---")
print(message_content)
else:
print("--- conversation completed (no final message) ---")
return response
# Your prompt
prompt = """
Write code to multiply two 5x5 matrices in three languages: C++, Python, and Java using code_exec functions. Each language should multiply the matrices 10 times and measure the time taken for each iteration.
ALWAYS CALL THESE THREE FUNCTIONS EXACTLY ONCE: code_exec_python, code_exec_cpp, and code_exec_java tools to perform the matrix multiplication in each language once.
Print only the time it takes to multiply the matrices (in milliseconds) per iteration.
"""
# Initial developer message
messages = [
{
"role": "developer",
"content": prompt,
}
]
# Start the conversation
run_conversation(messages)
三種語言的答覆：
--- tool name ---
code_exec_python
--- tool call argument (generated code) ---
import time
N = 5
A = [[i + j for j in range(N)] for i in range(N)]
B = [[i * j for j in range(N)] for i in range(N)]
def matmul(A, B):
N = len(A)
C = [[0] * N for _ in range(N)]
for i in range(N):
for j in range(N):
s = 0
for k in range(N):
s += A[i][k] * B[k][j]
C[i][j] = s
return C
for _ in range(10):
t1 = time.perf_counter()
C = matmul(A, B)
t2 = time.perf_counter()
ms = (t2 - t1) * 1000.0
# Print only the time in milliseconds per iteration
print(ms)
--- tool name ---
code_exec_cpp
--- tool call argument (generated code) ---
#include <bits/stdc++.h>
using namespace std;
int main() {
const int N = 5;
double A[N][N], B[N][N], C[N][N];
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) {
A[i][j] = i + j;
B[i][j] = i * j;
}
for (int it = 0; it < 10; ++it) {
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
C[i][j] = 0.0;
auto t1 = chrono::high_resolution_clock::now();
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
double s = 0.0;
for (int k = 0; k < N; ++k)
s += A[i][k] * B[k][j];
C[i][j] = s;
}
}
auto t2 = chrono::high_resolution_clock::now();
double ms = chrono::duration<double, milli>(t2 - t1).count();
cout << ms << endl;
}
return 0;
}
--- tool name ---
code_exec_java
--- tool call argument (generated code) ---
public class Main {
public static void main(String[] args) {
int N = 5;
double[][] A = new double[N][N];
double[][] B = new double[N][N];
double[][] C = new double[N][N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
A[i][j] = i + j;
B[i][j] = i * j;
}
for (int it = 0; it < 10; it++) {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
C[i][j] = 0.0;
long t1 = System.nanoTime();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
double s = 0.0;
for (int k = 0; k < N; k++)
s += A[i][k] * B[k][j];
C[i][j] = s;
}
}
long t2 = System.nanoTime();
double ms = (t2 - t1) / 1_000_000.0;
System.out.println(ms);
}
}
}
上下文無關語法 (CFG) 強制執行
GPT-5 的上下文無關語法 (CFG) 強制執行功能使開發者能夠將輸出約束為嚴格的結構，這在格式非常精確的情況下非常理想，例如 SQL 或正規表示式。例如，可以為 MS SQL (TOP) 和 PostgreSQL (LIMIT) 設定單獨的語法，並確保 GPT-5 為這兩個資料庫生成語法有效的查詢。
mssql_grammar 指定了有效的 SQL Server 查詢的確切結構，包括 SELECT TOP、過濾、排序和語法。它將模型限制為：
- 返回固定數量的行（TOP N）
- 根據 total_amount 和 order_date 進行過濾
- 使用正確的語法，例如 ORDER BY … DESC 和分號
- 僅使用具有固定列、關鍵字和值格式的安全只讀查詢
PostgreSQL 語法
- postgres_grammar 與 mssql_grammar 類似，但其設計旨在透過使用 LIMIT 而不是 TOP 來匹配 PostgreSQL 的語法。它將模型限制為：
- 使用 LIMIT N 限制結果大小
- 使用相同的過濾和排序規則
- 驗證識別符號、數字和日期格式
- 透過限制 SQL 結構來限制不安全/不受支援的 SQL 操作。
import textwrap
# ----------------- grammars for MS SQL dialect -----------------
mssql_grammar = textwrap.dedent(r"""
// ---------- Punctuation & operators ----------
SP: " "
COMMA: ","
GT: ">"
EQ: "="
SEMI: ";"
// ---------- Start ----------
start: "SELECT" SP "TOP" SP NUMBER SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SEMI
// ---------- Projections ----------
select_list: column (COMMA SP column)*
column: IDENTIFIER
// ---------- Tables ----------
table: IDENTIFIER
// ---------- Filters ----------
amount_filter: "total_amount" SP GT SP NUMBER
date_filter: "order_date" SP GT SP DATE
// ---------- Sorting ----------
sort_cols: "order_date" SP "DESC"
// ---------- Terminals ----------
IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
NUMBER: /[0-9]+/
DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
""")
# ----------------- grammars for PostgreSQL dialect -----------------
postgres_grammar = textwrap.dedent(r"""
// ---------- Punctuation & operators ----------
SP: " "
COMMA: ","
GT: ">"
EQ: "="
SEMI: ";"
// ---------- Start ----------
start: "SELECT" SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SP "LIMIT" SP NUMBER SEMI
// ---------- Projections ----------
select_list: column (COMMA SP column)*
column: IDENTIFIER
// ---------- Tables ----------
table: IDENTIFIER
// ---------- Filters ----------
amount_filter: "total_amount" SP GT SP NUMBER
date_filter: "order_date" SP GT SP DATE
// ---------- Sorting ----------
sort_cols: "order_date" SP "DESC"
// ---------- Terminals ----------
IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
NUMBER: /[0-9]+/
DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
""")
該示例使用 GPT-5 和自定義 mssql_grammar 工具生成一個 SQL Server 查詢，該查詢返回客戶最近下達的高價值訂單。mssql_grammar 建立了語法規則來強制執行 SQL Server 語法，並生成了正確的 SELECT TOP 語法以返回有限的結果。
from openai import OpenAI
client = OpenAI()
sql_prompt_mssql = (
"Call the mssql_grammar to generate a query for Microsoft SQL Server that retrieve the "
"five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, "
"where total_amount > 500 and order_date is after '2025-01-01'. "
)
response_mssql = client.responses.create(
model="gpt-5",
input=sql_prompt_mssql,
text={"format": {"type": "text"}},
tools=[
{
"type": "custom",
"name": "mssql_grammar",
"description": "Executes read-only Microsoft SQL Server queries limited to SELECT statements with TOP and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.",
"format": {
"type": "grammar",
"syntax": "lark",
"definition": mssql_grammar
}
},
],
parallel_tool_calls=False
)
print("--- MS SQL Query ---")
print(response_mssql.output[1].input)
響應：
--- MS SQL Query --- SELECT TOP 5 customer_id, order_id, order_date, total_amount FROM orders WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC;
此版本以 PostgreSQL 為目標平臺，並使用 postgres_grammar 工具幫助 GPT-5 生成相容的查詢。它遵循與上一個示例相同的邏輯，但使用 LIMIT 作為返回結果的限制，以演示相容的 PostgreSQL 語法。
sql_prompt_pg = (
"Call the postgres_grammar to generate a query for PostgreSQL that retrieve the "
"five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, "
"where total_amount > 500 and order_date is after '2025-01-01'. "
)
response_pg = client.responses.create(
model="gpt-5",
input=sql_prompt_pg,
text={"format": {"type": "text"}},
tools=[
{
"type": "custom",
"name": "postgres_grammar",
"description": "Executes read-only PostgreSQL queries limited to SELECT statements with LIMIT and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.",
"format": {
"type": "grammar",
"syntax": "lark",
"definition": postgres_grammar
}
},
],
parallel_tool_calls=False,
)
print("--- PG SQL Query ---")
print(response_pg.output[1].input)
響應：
--- PG SQL Query --- SELECT customer_id, order_id, order_date, total_amount FROM orders WHERE total_amount > 500 AND order_date > '2025-01-01' ORDER BY order_date DESC LIMIT 5;
最小推理工作量
GPT-5 現在支援新的最小推理工作量。使用最小推理工作量時，模型將輸出很少甚至不輸出推理標記。這適用於開發者希望快速生成首個使用者可見標記的用例。
注意：如果未提供推理工作量，則預設值為中等。
from openai import OpenAI
client = OpenAI()
prompt = "Translate the following sentence to Spanish. Return only the translated text."
response = client.responses.create(
model="gpt-5",
input=[
{ 'role': 'developer', 'content': prompt },
{ 'role': 'user', 'content': 'Where is the nearest train station?' }
],
reasoning={ "effort": "minimal" }
)
# Extract model's text output
output_text = ""
for item in response.output:
if hasattr(item, "content"):
for content in item.content:
if hasattr(content, "text"):
output_text += content.text
# Token usage details
usage = response.usage
print("--------------------------------")
print("Output:")
print(output_text)
響應：
--------------------------------Output:¿Dónde está la estación de tren más cercana?
定價
OpenAI 提供不同級別的 GPT-5 模型，以滿足各種效能和預算需求。GPT-5 適用於複雜任務。GPT-5-mini 任務完成速度快且成本更低，而 GPT-5-nano 則適用於即時或輕量級用例。短期對話中重複使用的代幣可享受 90% 的折扣，從而大幅降低多輪互動的成本。
| 模型 | 輸入成本 (每百萬token) | 輸出成本 (每百萬token) | Token限制 |
|---|---|---|---|
| GPT‑5 | $1.25 | $10.00 | 400K 上下文視窗 / 128K 最大輸出token |
| GPT‑5-mini | $0.25 | $2.00 | 400K 上下文視窗 / 128K 最大輸出token |
| GPT‑5-nano | $0.05 | $0.40 | 400K 上下文視窗 / 128K 最大輸出token |
小結
GPT-5 為開發者開啟了 AI 的新紀元。它透過 API 將頂級編碼智慧與更強大的控制能力相結合。您可以使用其功能，例如控制冗長程度、啟用自定義工具呼叫、強制語法以及執行極簡推理。藉助這些功能，您可以構建更智慧、更可靠的應用程式。
從自動化複雜的工作流程到加速日常工作流程，GPT-5 的設計具有極高的靈活性和效能，可幫助開發者進行創作。在您的專案中，探索並探索 GPT-5 的特性和功能，以充分利用其優勢。
評論留言