OpenAI GPT‑5 API: Praktik Langsung dengan Fitur Baru

1. Reasoning Effort

GPT-5 memperkenalkan parameter reasoning effort baru yang memungkinkan Anda mengendalikan seberapa dalam model berpikir sebelum merespons. Anda dapat memilih tingkat usaha minimal, rendah, sedang, atau tinggi, sesuai kebutuhan Anda. 

Usaha minimal cocok untuk tugas sensitif terhadap kecepatan seperti pengodean cepat atau mengikuti instruksi sederhana, sementara sedang dan tinggi memungkinkan penalaran yang lebih menyeluruh dan bertahap. Fleksibilitas ini berarti Anda dapat menyeimbangkan latensi, biaya, dan akurasi.

Pertama, pasang OpenAI Python SDK dan setel kunci API Anda sebagai variabel lingkungan:

pip install openai

Setel kunci API Anda (ganti dengan kunci yang sebenarnya):

• Linux/macOS: export OPENAI_API_KEY="your_api_key_here"
• Windows (PowerShell): setx OPENAI_API_KEY "your_api_key_here"

Mari gunakan Response API untuk menghasilkan teks dengan usaha penalaran “minimal”. Ini berarti model akan merespons secara langsung, tanpa mengalokasikan token untuk penalaran internal.

import os
from openai import OpenAI

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

resp = client.responses.create(
    model="gpt-5",
    input="Who is the father of Python?",
    reasoning={"effort": "minimal"},
)

print(resp.output_text)

Keluaran:

Guido van Rossum is known as the father (creator) of Python. He first released Python in 1991.

Anda juga dapat memeriksa ringkasan penggunaan token untuk memahami bagaimana model memproses permintaan Anda:

print(f"Input tokens: {resp.usage.input_tokens}")
print(f"  - Cached tokens: {resp.usage.input_tokens_details.cached_tokens}")
print(f"Output tokens: {resp.usage.output_tokens}")
print(f"  - Reasoning tokens: {resp.usage.output_tokens_details.reasoning_tokens}")
print(f"Total tokens: {resp.usage.total_tokens}")

Seperti terlihat, nol token digunakan untuk penalaran saat effort disetel ke minimal.

Input tokens: 13
  - Cached tokens: 0
Output tokens: 31
  - Reasoning tokens: 0
Total tokens: 44

Sekarang, mari tingkatkan reasoning effort ke "high" untuk melihat bagaimana penalaran internal model berubah:

resp = client.responses.create(
    model="gpt-5",
    input="Who is the father of Python?",
    reasoning={"effort": "high"},
)

print(resp.output_text)

Keluaran:

Guido van Rossum. He created Python and first released it in 1991.

Periksa lagi penggunaan token:

print(f"Input tokens: {resp.usage.input_tokens}")
print(f"  - Cached tokens: {resp.usage.input_tokens_details.cached_tokens}")
print(f"Output tokens: {resp.usage.output_tokens}")
print(f"  - Reasoning tokens: {resp.usage.output_tokens_details.reasoning_tokens}")
print(f"Total tokens: {resp.usage.total_tokens}")

Bahkan untuk pertanyaan sederhana, model menggunakan 192 token untuk penalaran pada effort tinggi. Ini menunjukkan bagaimana Anda kini dapat mengendalikan kedalaman penalaran untuk mengoptimalkan biaya, kecepatan, atau akurasi sesuai kebutuhan.

Input tokens: 13
  - Cached tokens: 0
Output tokens: 216
  - Reasoning tokens: 192
Total tokens: 229

2. Verbosity

Dengan GPT-5, kini Anda dapat langsung mengendalikan seberapa banyak model berbicara menggunakan parameter verbosity. Setel ke rendah untuk jawaban ringkas, sedang untuk detail seimbang, atau tinggi untuk penjelasan mendalam. Ini sangat berguna untuk pembuatan kode—verbosity rendah menghasilkan kode singkat dan bersih, sementara verbosity tinggi menyertakan komentar inline dan penalaran rinci.

Anda dapat menggabungkan parameter verbosity dengan kontrol reasoning untuk menyesuaikan respons sesuai kebutuhan Anda. Baik Anda menginginkan satu kalimat singkat, jawaban lebih panjang, atau laporan komprehensif, Anda memiliki fleksibilitas penuh.

Verbosity “rendah” menghasilkan jawaban singkat dan langsung.

from openai import OpenAI

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

resp = client.responses.create(
    model="gpt-5",
    input="Who is the father of Python?",
    reasoning={"effort": "minimal"},
    text={"verbosity": "low"},
)

print(resp.output_text)

Keluaran:

Guido van Rossum.

Verbosity “tinggi” menghasilkan respons yang jauh lebih rinci dan penjelasan mendalam.

resp = client.responses.create(
    model="gpt-5",
    input="Who is the father of Python?",
    reasoning={"effort": "minimal"},
    text={"verbosity": "high"},
)

print(resp.output_text)

Keluaran:

Guido van Rossum is known as the "father of Python." He created Python in the late 1980s and released the first version (Python 0.9.0) in 1991. He also served for many years as Python's "Benevolent Dictator For Life" (BDFL), guiding the language's development.

3. Multi-Turn dengan Chain-of-Thought Handoff

Salah satu peningkatan terbesar GPT-5 adalah kemampuannya untuk meneruskan penalaran chain-of-thought (CoT) antar giliran dalam Responses API. Ini berarti model mengingat penalaran internal dari langkah sebelumnya, menghindari pemikiran ulang yang berulang dan meningkatkan kecepatan serta akurasi. 

Dalam percakapan multi-giliran, terutama saat menggunakan alat, cukup teruskan previous_response_id untuk menjaga konteks penalaran tetap aktif.

Permintaan pertama menanyakan, “Siapa ayah dari Python?”, dan permintaan kedua, yang ditautkan ke yang pertama melalui previous_response_id, meminta model untuk “Tulis sebuah blog tentang itu” tanpa mengulang subjeknya. Dengan meneruskan ID respons sebelumnya, model mempertahankan konteks penalaran.

from openai import OpenAI

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

first = client.responses.create(
    model="gpt-5",
    input="Who is the father of Python?",
    reasoning={"effort": "minimal"},
    text={"verbosity": "low"},
)

followup = client.responses.create(
    model="gpt-5",
    previous_response_id=first.id,
    input="Write a blog on it.",
    reasoning={"effort": "medium"},
    text={"verbosity": "high"},
)

print(followup.output_text)

Hasilnya, kita mendapatkan sebuah blog tentang ayah dari Python. 

4. Freeform Input

Alat kustom di GPT-5 kini mendukung masukan freeform, memungkinkan model mengirim teks mentah, seperti kode, kueri SQL, atau perintah shell langsung ke alat Anda. Ini merupakan lompatan besar dari pendekatan lama yang hanya berbasis JSON terstruktur, memberi Anda fleksibilitas lebih dalam cara model berinteraksi dengan sistem Anda. Baik Anda membangun eksekutor kode, mesin kueri, atau interpreter DSL, freeform input membuat GPT-5 jauh lebih adaptif untuk tugas dunia nyata yang tidak terstruktur.

Pada kode di bawah, kami mendefinisikan sebuah runner SQL palsu, mendaftarkannya sebagai alat kustom, dan membuat permintaan awal di mana model merespons dengan kueri SQL freeform. Kueri itu diekstrak, dieksekusi secara lokal, dan hasilnya dikirim kembali ke model menggunakan call_id yang sama untuk mempertahankan konteks pemanggilan alat. Terakhir, GPT‑5 mengubah keluaran alat mentah itu menjadi jawaban berbahasa natural. 

from openai import OpenAI
import random

client = OpenAI()

def run_sql_query(sql: str) -> str:
    print("\n[FAKE DB] Executing SQL:\n", sql)
    categories = ["Electronics", "Clothing", "Furniture", "Toys", "Books"]
    result = "category   | total_sales\n" + "-" * 28 + "\n"
    for cat in categories:
        result += f"{cat:<11} | {random.randint(5000, 200000)}\n"
    return result


tools = [
    {
        "type": "custom",
        "name": "sql_query_runner",
        "description": "Runs raw SQL queries on the company sales database.",
    }
]

messages = [
    {
        "role": "user",
        "content": "Show me the total sales for each product category last month.",
    }
]

# 1) First call - model emits a freeform tool call
resp = client.responses.create(model="gpt-5", tools=tools, input=messages)

# IMPORTANT: carry the tool call into the next turn
messages += resp.output  # <-- this preserves the tool_call with its call_id

# Find the tool call from the response output
tool_call = next(
    (
        x
        for x in resp.output
        if getattr(x, "type", "") in ("custom_tool_call", "function_call", "tool_call")
    ),
    None,
)
assert tool_call is not None, "No tool call found."

# Freeform text is in input (fallback to arguments for safety) raw_text = getattr(tool_call, "input", None) or getattr(tool_call, "arguments", "") sql_text = raw_text.strip() # 2) Execute the tool locally fake_result = run_sql_query(sql_text) # 3) Send tool result back, referencing the SAME call_id messages.append( { "type": "function_call_output", "call_id": tool_call.call_id, "output": fake_result, } ) # 4) Final call - model turns tool output into a natural answer final = client.responses.create(model="gpt-5", tools=tools, input=messages) print("\nFinal output text:\n", final.output_text)

Keluaran: 

[FAKE DB] Executing SQL:
 SELECT table_schema, table_name 
FROM information_schema.tables 
WHERE table_schema NOT IN ('information_schema','pg_catalog') 
ORDER BY 1,2;

Final output text:
 Here are the total sales by category for last month (July 2025):

- Electronics: 31,766
- Clothing: 90,266
- Furniture: 55,471
- Toys: 124,625
- Books: 74,263

Want this as a CSV or chart?

5. Membatasi Keluaran

Untuk skenario yang membutuhkan presisi tinggi, GPT-5 mendukung context-free grammars (CFG) guna mengendalikan format keluaran secara ketat. Dengan melampirkan tata bahasa seperti sintaks SQL atau bahasa khusus domain, Anda dapat memastikan respons model selalu cocok dengan struktur yang Anda butuhkan. Ini sangat berharga untuk alur kerja bernilai tinggi atau otomatis, di mana penyimpangan kecil pada format dapat menyebabkan kesalahan.

Pada contoh kode, kami membuat alat sql_query_runner dan mendefinisikan sintaks SQL-nya menggunakan tata bahasa Lark, memastikan bahwa setiap SQL yang dihasilkan model selalu valid dan mengikuti struktur kami secara tepat. 

Pada panggilan model pertama, GPT‑5 menggunakan alat ini untuk menghasilkan kueri SQL yang sesuai tata bahasa untuk penjualan bulan lalu per kategori. Kami kemudian mengeksekusi kueri tersebut secara lokal, mengirim hasilnya kembali ke model menggunakan call_id yang sama, dan melakukan panggilan kedua di mana GPT‑5 mengubah data mentah itu menjadi jawaban berbahasa natural yang jelas. 

from openai import OpenAI
import random

client = OpenAI()


def run_sql_query(sql: str) -> str:
    cats = ["Electronics", "Clothing", "Furniture", "Toys", "Books"]
    rows = [f"{c:<11} | {random.randint(5_000, 200_000)}" for c in cats]
    return "category   | total_sales\n" + "-" * 28 + "\n" + "\n".join(rows)


tools = [
    {
        "type": "custom",
        "name": "sql_query_runner",
        "description": "Runs raw SQL on the sales DB.",
        "format": {
            "type": "grammar",
            "syntax": "lark",
            "definition": r"""
start: SELECT CATEGORY COMMA SUM LPAREN SALES RPAREN AS TOTAL_SALES FROM ORDERS WHERE ORDER_MONTH EQ ESCAPED_STRING GROUP BY CATEGORY ORDER BY TOTAL_SALES (DESC|ASC)?

SELECT: "SELECT"
CATEGORY: "category"
COMMA: ","
SUM: "SUM"
LPAREN: "("
SALES: "sales"
RPAREN: ")"
AS: "AS"
TOTAL_SALES: "total_sales"
FROM: "FROM"
ORDERS: "orders"
WHERE: "WHERE"
ORDER_MONTH: "order_month"
EQ: "="
GROUP: "GROUP"
BY: "BY"
ORDER: "ORDER"
DESC: "DESC"
ASC: "ASC"

%import common.ESCAPED_STRING
%ignore /[ \t\r\n]+/
        """,
        },
    }
]

msgs = [
    {
        "role": "user",
        "content": "Show me the total sales for each product category last month.",
    }
]

print("\n=== 1) First Model Call ===")
resp = client.responses.create(
    model="gpt-5", input=msgs, tools=tools, text={"format": {"type": "text"}}
)
print("Raw model output objects:\n", resp.output)

msgs += resp.output
tool_call = next(
    x
    for x in resp.output
    if getattr(x, "type", "") in ("custom_tool_call", "function_call", "tool_call")
)
sql = (getattr(tool_call, "input", None) or getattr(tool_call, "arguments", "")).strip()
print("\nExtracted SQL from tool call:\n", sql)

print("\n=== 2) Local Tool Execution ===")
tool_result = run_sql_query(sql)
print(tool_result)

msgs.append(
    {
        "type": "function_call_output",
        "call_id": getattr(tool_call, "call_id", None) or tool_call["call_id"],
        "output": tool_result,
    }
)

print("\n=== 3) Second Model Call ===")
final = client.responses.create(
    model="gpt-5", input=msgs, tools=tools, text={"format": {"type": "text"}}
)
print("\nFinal natural-language answer:\n", final.output_text)

Seperti terlihat, model pertama kali menghasilkan kueri SQL yang sesuai tata bahasa, lalu menjalankan fungsi untuk mengambil data penjualan. Terakhir, GPT-5 mengonversi data tersebut menjadi ringkasan berbahasa natural yang jelas dan berperingkat untuk penjualan bulan lalu per kategori.

=== 1) First Model Call ===
Raw model output objects:
 [ResponseReasoningItem(id='rs_6897acee8afc819f9e7ae0f675bfa4ee0d5175a46255063b', summary=[], type='reasoning', content=None, encrypted_content=None, status=None), ResponseCustomToolCall(call_id='call_vzcHPT7EGvb7QbhF2djVIJZA', input='SELECT category, SUM(sales) AS total_sales FROM orders WHERE order_month = "2025-07" GROUP BY category ORDER BY total_sales DESC', name='sql_query_runner', type='custom_tool_call', id='ctc_6897acf67a34819f84a085191e4ca1fb0d5175a46255063b', status='completed')]

Extracted SQL from tool call:
 SELECT category, SUM(sales) AS total_sales FROM orders WHERE order_month = "2025-07" GROUP BY category ORDER BY total_sales DESC

=== 2) Local Tool Execution ===
category   | total_sales
----------------------------
Electronics | 52423
Clothing    | 59976
Furniture   | 172713
Toys        | 69667
Books       | 14633

=== 3) Second Model Call ===

Final natural-language answer:
 Here are the total sales by category for last month (2025-07):

- Furniture: 172,713
- Toys: 69,667
- Clothing: 59,976
- Electronics: 52,423
- Books: 14,633

Want this as a chart or need a different month?

6. Allowed Tools

Parameter allowed_tools yang baru memungkinkan Anda mendefinisikan subset alat yang dapat digunakan model dari seluruh toolkit Anda. Anda dapat mengatur mode ke auto (model boleh memilih) atau required (model harus menggunakan salah satunya). Ini meningkatkan keamanan, prediktabilitas, dan caching prompt dengan mencegah model memanggil alat yang tidak diinginkan, sambil tetap memberinya fleksibilitas untuk memilih opsi terbaik dari set yang diizinkan.

Toolkit penuh berisi get_weather dan send_email, tetapi kami hanya mengizinkan get_weather dan menetapkan mode ke "required", memaksa model untuk menggunakannya. 

Ketika ditanya, “Bagaimana cuaca di Oslo?”, GPT‑5 merespons dengan pemanggilan fungsi ke get_weather dan argumen yang benar {"city": "Oslo"}. 

from openai import OpenAI

client = OpenAI()

# Full toolset (N)

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
    {
        "type": "function",
        "name": "send_email",
        "parameters": {
            "type": "object",
            "properties": {"to": {"type": "string"}, "body": {"type": "string"}},
            "required": ["to", "body"],
        },
    },
]

# Allowed subset (M < N), mode=required  → must call get_weather

resp = client.responses.create(
    model="gpt-5",
    input="What's the weather in Oslo?",
    tools=tools,
    tool_choice={
        "type": "allowed_tools",
        "mode": "required",  # use "auto" to let it decide
        "tools": [{"type": "function", "name": "get_weather"}],
    },
)
for item in resp.output:
    if getattr(item, "type", None) in ("function_call", "tool_call", "custom_tool_call"):
        print("Tool name:", getattr(item, "name", None))
        print("Arguments:", getattr(item, "arguments", None))

Keluaran:

Tool name: get_weather
Arguments: {"city":"Oslo"}

7. Preambles

Preamble adalah penjelasan singkat yang terlihat oleh pengguna yang dapat dihasilkan GPT-5 sebelum memanggil suatu alat, menjelaskan mengapa panggilan tersebut dilakukan. Ini meningkatkan transparansi, kepercayaan pengguna, dan kemudahan debug, terutama dalam alur kerja yang kompleks. Dengan cukup menginstruksikan model untuk “menjelaskan sebelum memanggil alat,” Anda dapat membuat interaksi terasa lebih manusiawi dan disengaja tanpa menambah latensi yang signifikan.

Pada kode di bawah, kami mendefinisikan alat fungsi get_weather dan menambahkan instruksi sistem yang meminta model mengeluarkan satu kalimat singkat yang terlihat oleh pengguna dengan awalan "Preamble:" sebelum melakukan pemanggilan alat. 

Ketika ditanya, “Bagaimana cuaca di Oslo?”, GPT‑5 terlebih dahulu menghasilkan preamble yang menjelaskan bahwa model sedang memeriksa layanan cuaca langsung, lalu memanggil alat get_weather dengan argumen yang benar {"city": "Oslo"}. Setelah menjalankan alat secara lokal dan mengembalikan hasilnya, model memberikan jawaban akhir berbahasa natural. 

from openai import OpenAI
client = OpenAI()


def get_weather(city: str):
    return {"city": city, "temperature_c": 12}

# Tool
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current temperature for a city.",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
        "additionalProperties": False
    },
    "strict": True,
}]

# Messages (enable preamble via system instruction)
msgs = [
    {"role": "system", "content": "Before you call a tool, explain why you are calling it in ONE short sentence prefixed with 'Preamble:'."},
    {"role": "user", "content": "What's the weather in Oslo?"}
]

# 1) Model call → expect a visible preamble + a tool call
resp = client.responses.create(model="gpt-5", input=msgs, tools=tools)
print("=== First response objects ===")
for item in resp.output:
    t = getattr(item, "type", None)
    if t == "message":  # preamble is a normal assistant message
        print("PREAMBLE:", getattr(item, "content", None))
    if t in ("function_call","tool_call","custom_tool_call"):
        print("TOOL:", getattr(item, "name", None))
        print("ARGS:", getattr(item, "arguments", None))
tool_call = next(x for x in resp.output if getattr(x, "type", None) in ("function_call","tool_call","custom_tool_call"))
msgs += resp.output  # keep context

# 2) Execute tool locally (fake)
import json
args = json.loads(getattr(tool_call, "arguments", "{}"))
city = args.get("city", "Unknown")
tool_result = get_weather(city)

# 3) Return tool result
msgs.append({"type": "function_call_output", "call_id": tool_call.call_id, "output": json.dumps(tool_result)})

# 4) Final model call → natural answer
final = client.responses.create(model="gpt-5", input=msgs, tools=tools)
print("\n=== Final answer ===")
print(final.output_text)

Seperti terlihat, model terlebih dahulu memberikan preamble singkat yang menjelaskan maksudnya, lalu dengan benar memanggil alat get_weather dengan {"city": "Oslo"}, dan akhirnya mengembalikan suhu dalam bahasa natural.

=== First response objects ===
PREAMBLE: [ResponseOutputText(annotations=[], text='Preamble: I'm checking a live weather service to get the current conditions for Oslo.', type='output_text', logprobs=[])]
TOOL: get_weather
ARGS: {"city":"Oslo"}

=== Final answer ===
It's currently about 12°C in Oslo.

8. Optimisasi Prompt

GPT-5 dirancang untuk unggul dengan prompt yang dirancang dengan baik, dan OpenAI menyediakan Prompt Optimizer untuk membantu Anda menyetelnya. Alat ini secara otomatis menyesuaikan prompt Anda dengan gaya penalaran GPT-5, meningkatkan akurasi dan efisiensi. 

Buka Edit prompt - OpenAI API dan tulis prompt sederhana, seperti "Buat aplikasi web klon Netflix." Alat ini akan menguraikan prompt Anda menjadi struktur terperinci yang dioptimalkan untuk model GPT-5. 

Sumber: Prompt Optimizer

Cukup salin prompt tersebut dan tambahkan ke obrolan ChatGPT untuk mulai membangun layanan web Netflix Anda sendiri. 

9. Migrasi ke Model GPT-5

OpenAI sangat merekomendasikan para pengembang untuk bermigrasi dari model lama ke keluarga GPT‑5 baru guna menurunkan biaya, meningkatkan akurasi, dan memperbaiki kualitas respons.

Migrasi sangat mudah; cukup ikuti tabel di bawah ini untuk memilih model GPT‑5 dan tingkat penalaran yang tepat untuk kasus penggunaan Anda.

Pemikiran Akhir

GPT-5 bukan sekadar model yang lebih cerdas; ini adalah perangkat pengembang untuk membangun sistem AI yang cerdas, andal, dan efisien. Dengan kendali terperinci atas penalaran, verbosity, penggunaan alat, dan format keluaran, model ini beradaptasi dari tugas pengodean cepat hingga alur kerja multi-langkah yang kompleks. 

Dengan memanfaatkan fitur baru dan praktik terbaiknya, Anda dapat mengembangkan aplikasi AI siap produksi menggunakan OpenAI SDK dengan upaya minimal.

Jika Anda baru mulai bekerja dengan OpenAI, pastikan untuk melihat sumber daya berikut:

• Working with the OpenAI API :  Pelajari dasar-dasar berinteraksi dengan model OpenAI.
• OpenAI Fundamentals Track :  Jalur pembelajaran komprehensif untuk teknologi OpenAI.