API O3 OpenAI: Tutorial Langkah demi Langkah dengan Contoh

Model o3 dari OpenAI mampu menyelesaikan masalah kompleks bertahap, memadukan input visual dan tekstual, serta menggunakan alat seperti Python, pencarian, atau inspeksi gambar untuk meningkatkan jawabannya.

Dalam tutorial ini, saya akan menjelaskan langkah demi langkah cara menggunakan o3 melalui API, apa yang membuat o3 berbeda dari model generalis seperti GPT-4o, dan cara mengelola biaya penalaran secara efektif.

Kami terus memperbarui pembaca tentang hal terbaru di AI melalui The Median, buletin gratis setiap Jumat yang merangkum kisah-kisah kunci minggu ini. Berlangganan dan tetap tajam hanya dalam beberapa menit per minggu:

Kapan Sebaiknya Menggunakan O3?

Model o3 dari OpenAI dirancang untuk tugas tingkat lanjut dan kompleks yang memerlukan penalaran mendalam dan otonomi. Model ini sangat efektif untuk pemecahan masalah yang rumit di bidang seperti pengembangan perangkat lunak, matematika, penelitian ilmiah, dan interpretasi data visual.

Kapabilitas agentik model ini memungkinkannya menggunakan alat secara mandiri seperti penelusuran web, Python, dan pembuatan gambar, menjadikannya ideal untuk tugas yang menuntut analisis bertahap dan pengambilan keputusan dinamis.

Pertimbangkan menggunakan model o3 melalui API ketika proyek Anda melibatkan tugas penalaran multimodal yang kompleks yang mendapatkan manfaat dari otonomi tinggi dan keterampilan analitis lanjut.

Mari lihat perbandingan singkat antara o3, o4-mini, dan GPT-4o:

Sumber: OpenAI

Harga juga merupakan faktor penting yang perlu dipertimbangkan saat menggunakan API:

Sumber: OpenAI

OpenAI O3 API: Cara Terhubung ke API OpenAI

Sebelum Anda dapat mulai menggunakan kapabilitas penalaran lanjutan o3, Anda perlu menyiapkan akses ke OpenAI API. Di bagian ini, saya akan memandu Anda melalui:

• Menetapkan kunci API Anda secara aman
• Melakukan panggilan API pertama ke model o3
• Menyoroti perbedaan penyiapan kunci untuk model penalaran

Langkah 1: Dapatkan kredensial API

Untuk mengakses OpenAI API, Anda memerlukan kunci API yang valid, yang bisa diperoleh dari halaman OpenAI API Keys, dan pastikan penagihan Anda diaktifkan.

Catatan: Untuk menggunakan o3, Anda harus terlebih dahulu memverifikasi organisasi OpenAI Anda di sini. Verifikasi dapat memerlukan waktu hingga 15 menit untuk aktif.

Langkah 2: Impor pustaka openai

Kita mulai dengan memasang dan memperbarui pustaka openai untuk mengakses model O3 melalui API. Jalankan perintah berikut:

pip install --upgrade openai

Setelah terpasang, kita mengimpor kelas OpenAI dari pustaka openai:

from openai import OpenAI

Langkah 3: Inisialisasi objek klien

Untuk berinteraksi dengan API OpenAI, kita melakukan autentikasi dengan menetapkan kunci API rahasia kita, sehingga dapat membuat permintaan resmi ke model seperti o3.

client = OpenAI(api_key=YOUR_API_KEY)

Langkah 4: Lakukan panggilan API

Sekarang penyiapan sudah selesai, mari lakukan panggilan API pertama ke o3 dan lihat bagaimana ia menangani tugas penalaran bertahap sederhana melalui Responses API.

Contoh 1: Prompt sederhana tanpa alat

Mari pahami panggilan API o3 dengan contoh prompt sederhana.

response = client.responses.create(
    model="o3",
    input=[{"role": "user", "content": "What’s the difference between inductive and deductive reasoning?"}]
)
print(response.output_text)

Contoh ini mengirim pertanyaan bahasa alami langsung ke model o3 tanpa menggunakan alat atau parameter penalaran khusus.

• model="o3" memberi tahu API untuk menggunakan model penalaran o3.
• input=[{"role": "user", "content": "..."}] mendefinisikan satu pesan pengguna yang meminta penjelasan konseptual.
• Secara internal, O3 menggunakan rantai penalaran tingkat menengah sebelum menghasilkan keluaran akhir.

Ini adalah token yang akan dihitung ke biaya akhir kita:

• Token input: Prompt
• Token penalaran: chain-of-thought internal o3
• Token output: Keluaran akhir

Contoh 2: Pemecahan masalah kode dan matematika

Pada contoh ini, kita meminta o3 untuk menulis kode dan menjelaskan matematika di balik penyelesaian persamaan kuadrat. Ini adalah tugas dua bagian, tidak hanya memerlukan pengkodean tetapi juga penjelasan matematis yang terperinci.

prompt = "Write a Python function that solves quadratic equations and also explain the math behind it."
response = client.responses.create(
    model="o3",
    reasoning={"effort": "high"},
    input=[{"role": "user", "content": prompt}]
)
print(response.output_text)

Tugas ini memerlukan penalaran matematika bertahap, pertama menyelesaikan rumus kuadrat, lalu menjelaskan penurunannya. Parameter reasoning={"effort": "high"} memaksa o3 untuk "berpikir lebih keras," menghasilkan jejak penalaran yang lebih besar. Ini sangat cocok untuk tugas yang memerlukan kedalaman teknis atau solusi multi-tahap.

Catatan biaya: Upaya penalaran yang lebih tinggi berarti lebih banyak token penalaran, yang menghasilkan biaya keluaran lebih tinggi.

Contoh 3: Tugas refaktorisasi kode

Pada contoh ini, kita memberikan tugas refaktorisasi kode kepada O3 beserta serangkaian instruksi.

prompt = """
Instructions:
- Given the React component below, change it so that nonfiction books have red
  text. 
- Return only the code in your reply
- Do not include any additional formatting, such as markdown code blocks
- For formatting, use four space tabs, and do not allow any lines of code to 
  exceed 80 columns
const books = [
  { title: 'Dune', category: 'fiction', id: 1 },
  { title: 'Frankenstein', category: 'fiction', id: 2 },
  { title: 'Moneyball', category: 'nonfiction', id: 3 },
];
export default function BookList() {
  const listItems = books.map(book =>
    <li>
      {book.title}
    </li>
  );
  return (
    <ul>{listItems}</ul>
  );
}
"""
response = client.responses.create(
    model="o3",
    reasoning={"effort": "medium", "summary": "detailed"},
    input=[
        {
            "role": "user",
            "content": prompt,
        }
    ]
)
print(response.output_text)

Pada kode di atas, kita memberikan O3 tugas pengeditan kode yang sangat terstruktur dengan aturan pemformatan yang terperinci.

• Parameter reasoning={"effort": "medium"} menginstruksikannya untuk menalar dengan cermat namun efisien.
• Parameter summary="detailed" meminta ringkasan internal penuh dari proses berpikir model. O3 akan menalar secara internal dan opsional mengembalikan jejak yang diringkas jika Anda memeriksa bidang summary nanti.

Tip: Tersedia beberapa pengaturan ringkasan yang dapat Anda gunakan, seperti "concise", "detailed", atau "auto."

Contoh 4: Penalaran visual

Mari gunakan foto konferensi ini dan minta o3 membuat jadwal berdasarkan minat kita.

Langkah 4.1: Fungsi pembantu

Mari mulai dengan mengimpor pustaka yang diperlukan dan menulis fungsi pembantu:

import base64, mimetypes, pathlib
def to_data_url(path: str) -> str:
    mime = mimetypes.guess_type(path)[0] or "application/octet-stream"
    data = pathlib.Path(path).read_bytes()
    b64  = base64.b64encode(data).decode()
    return f"data:{mime};base64,{b64}"

Fungsi to_data_url() mengonversi file gambar lokal menjadi data URL yang dikodekan base64, yang diperlukan karena API OpenAI mengharapkan input gambar dalam format URL, bukan sebagai file mentah.

Fungsi to_data_url melakukan hal berikut:

• Membaca file gambar (path) dari komputer Anda.
• Menyimpulkan tipenya (misalnya, image/png).
• Lalu mengodekan konten biner menjadi string base64.
• Terakhir mengembalikan data URL

Langkah 4.2: Kirim teks dan gambar ke O3

Sekarang gambar kita sudah dikodekan, kita mengirimkan teks dan informasi gambar yang telah dikodekan ke O3.

prompt = (
    "Create a schedule using this blurry conference photo. "
    "Ensure 10-minute gaps between talks and include all talks related to LLMs."
)
image_path   = "IMAGE_PATH"
image_url    = to_data_url(image_path)        
response = client.chat.completions.create(
    model="o3",                                  
    messages=[
        {
            "role": "user",
            "content": [
                { "type": "text",      "text": prompt },
                { "type": "image_url", "image_url": { "url": image_url } }
            ],
        }
    ],
)
print(response.choices[0].message.content)

Berikut cara kerjanya:

• Kita mulai dengan memanggil client.chat.completions.create(), di mana konten input berupa daftar yang berisi:
• instruksi teks (permintaan penjadwalan pengguna),
• dan data gambar (foto konferensi).
• Model o3 memproses kedua input tersebut secara bersamaan selama chain-of-thought internalnya.
• Terakhir, kita mencetak response.choices[0].message.content, yang berisi jadwal yang dihasilkan model setelah menalar atas instruksi teks dan data visual.

Pertimbangan biaya penting:

• Input gambar dihitung sebagai token input.
• Model menggunakan inspeksi visual di dalam loop penalaran.
• Jika rantai penalaran panjang, kita harus mengelola biaya dengan cermat menggunakan parameter max_completion_tokens, yang akan kita bahas di bagian berikutnya.

Mari lihat hasilnya:

Mengelola Biaya dengan Token Penalaran

O3 menggunakan token penalaran selain token input/output biasa, yang berarti lebih banyak token daripada token input/output reguler dan karenanya biaya keluaran lebih tinggi. Mengikuti contoh sebelumnya, mari uraikan bagaimana token penalaran memengaruhi biaya.

print(response.usage)

CompletionUsage(completion_tokens=3029,prompt_tokens=1007, total_tokens=4036, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=2112, rejected_prediction_tokens=0), prompt_tokens_details=PromptTokensDetails(audio_tokens=0, cached_tokens=0))

Jika Anda ingin mengendalikan biaya, terapkan parameter max_completion_tokens untuk membatasi total penggunaan:

limit_token_response = client.chat.completions.create(
    model="o3",                                  
    messages=[
        {
            "role": "user",
            "content": [
                { "type": "text",      "text": prompt },
                { "type": "image_url", "image_url": { "url": image_url } }
            ],
        }
    ],
    max_completion_tokens=3000,
)
print(limit_token_response.usage)

CompletionUsage(completion_tokens=2746, prompt_tokens=1007, total_tokens=3753, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=2112, rejected_prediction_tokens=0), prompt_tokens_details=PromptTokensDetails(audio_tokens=0, cached_tokens=0))

Dari keluaran di atas, kita dapat melihat bahwa menetapkan nilai max_completion_tokens sangat penting dalam mengendalikan perilaku model. Dengan membatasi jumlah maksimum token yang dihasilkan, kita mencegah o3 menghasilkan keluaran yang terlalu panjang atau mengonsumsi token penalaran berlebihan, yang membantu mengoptimalkan biaya API secara keseluruhan. Ini sangat penting pada tugas kompleks di mana penalaran internal bisa mendominasi penggunaan token tanpa menghasilkan keluaran yang sebanding bagi pengguna.

Penting: Saat menggunakan o3 untuk tugas visual yang kompleks, selalu tetapkan max_completion_tokens cukup tinggi secara konservatif. Jika batas token terlalu rendah, model dapat menghabiskan semua token selama penalaran internal dan tidak mengembalikan keluaran yang terlihat.

Praktik Terbaik Prompting dengan O3

Model O3 berperilaku berbeda dibandingkan model generalis seperti GPT-4o atau Claude 3.5 Sonnet, karena o3 melakukan penalaran chain-of-thought yang mendalam secara internal. Model ini berkinerja terbaik dengan prompt yang lugas dan berorientasi tujuan, yaitu, menspesifikasikan langkah secara berlebihan dapat menurunkan kinerjanya.

Berikut beberapa praktik terbaik yang direkomendasikan OpenAI untuk melakukan prompting pada o3:

• Buat prompt ringkas dan jelas: O3 optimal dengan instruksi langsung tanpa perlu penjelasan bertele-tele.
• Hindari prompt chain-of-thought: Tidak perlu menyuruh O3 untuk "berpikir selangkah demi selangkah"—ia menalarnya secara internal.
• Gunakan pembatas untuk kejelasan: Gunakan tanda kutip tiga, tag XML, atau pembatas lain untuk mengatur bagian-bagian input.
• Batasi konteks tambahan: Jika menggunakan retrieval-augmented generation (RAG), sertakan hanya informasi yang paling relevan agar model tidak kewalahan.

Kesimpulan

Sepanjang blog ini, kita mempelajari cara terhubung ke model O3 OpenAI melalui API, mengelola biaya token penalaran, dan menyusun prompt yang efektif menggunakan praktik terbaik. Jika proyek Anda memerlukan kapabilitas penalaran tingkat lanjut, seperti matematika bertahap, refaktorisasi kode, atau pemahaman visual, O3 adalah pilihan terbaik.

Untuk mempelajari lebih lanjut cara bekerja dengan API, saya merekomendasikan blog berikut:

• O4-Mini API: Tutorial Langkah demi Langkah dengan Proyek Demo
• Grok 3 API: Panduan Langkah demi Langkah dengan Contoh
• GPT-Image-1 API: Panduan Langkah demi Langkah dengan Contoh
• DeepSeek API: Panduan dengan Contoh dan Perhitungan Biaya