OpenAI Responses API: Panduan Utama untuk Pengembang

Apa itu Responses API dari OpenAI?

Responses API adalah API terbaru dan tercanggih dari OpenAI. API ini menggabungkan kekuatan Chat Completions dan Assistants API ke dalam satu antarmuka yang ringkas. Dirilis pada Maret 2025, API ini mempertahankan kapabilitas yang sudah dikenal sambil menyediakan pendekatan yang lebih terintegrasi untuk membangun aplikasi AI. 

Inovasi utamanya adalah penyederhanaan pengembangan dengan secara otomatis menangani orkestrasi logika dan mengintegrasikan alat bawaan OpenAI untuk penelusuran web dan penelusuran file secara native tanpa memerlukan implementasi kustom.

Dalam tutorial ini, kami akan membahas cara menggunakan Responses API di proyek Anda. Anda akan melihat bagaimana API ini menangani pembuatan teks, bekerja dengan gambar, dan memberikan respons streaming. Kami akan menelaah alat bawaan yang membuat pengembangan lebih cepat dan lebih sederhana dari sebelumnya, menunjukkan bagaimana alat tersebut bekerja bersama dalam kerangka API. 

Di akhir panduan ini, Anda akan memahami kapan harus menggunakan Responses API alih-alih opsi OpenAI lainnya dan bagaimana pengetahuan ini dapat membantu Anda membangun aplikasi yang lebih efisien dengan lebih sedikit kode dan upaya. Jika Anda baru dalam OpenAI API, lihat kursus pengantar kami, Working with the OpenAI API, untuk memulai perjalanan Anda mengembangkan aplikasi bertenaga AI.

Mulai Menggunakan Responses API

Responses API menyediakan antarmuka yang lebih ringkas dan ramah pengguna untuk berinteraksi dengan model OpenAI, menggabungkan hal-hal yang sebelumnya membutuhkan sintaks yang panjang dan kompleks menjadi solusi yang elegan. 

Sebelum masuk ke kasus penggunaan spesifik, mari siapkan lingkungan kita dan pahami sintaks dasarnya.

from openai import OpenAI
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Initialize the client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

Langkah inisialisasi ini membuat objek klien yang akan menangani semua permintaan API Anda. Paket dotenv membantu mengelola kunci API Anda dengan aman melalui variabel lingkungan alih-alih menuliskannya langsung di skrip — praktik terbaik yang membuat kode Anda lebih portabel dan aman di berbagai lingkungan.

Menghasilkan konten dengan Responses API

Penggunaan paling langsung dari Responses API adalah menghasilkan konten teks. Mari jelajahi skenario dunia nyata: misalkan Anda sedang membangun platform e-commerce dan perlu secara otomatis membuat deskripsi produk yang menarik berdasarkan detail produk dasar.

Secara tradisional, ini memerlukan rekayasa prompt yang cermat dan beberapa iterasi. Dengan Responses API, Anda dapat membuat fungsi sederhana yang menanganinya dengan elegan:

def generate_product_description(product_name, features, target_audience):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a professional copywriter specialized in creating concise, compelling product descriptions. Focus on benefits rather than just features.",
       input=f"""
       Create a product description for {product_name}.
       Key features:
       - {features[0]}
       - {features[1]}
       - {features[2]}
       Target audience: {target_audience}
       Keep it under 150 words.
       """,
       temperature=0.7,
       max_output_tokens=200
   )
  
   return response.output_text

# Example usage
headphones_desc = generate_product_description(
   "NoiseGuard Pro Headphones",
   ["Active noise cancellation", "40-hour battery life", "Memory foam ear cushions"],
   "Business travelers and remote workers"
)

print(headphones_desc)

Keluaran:

Experience unparalleled focus and comfort with NoiseGuard Pro Headphones—your perfect travel and work companion. 
Designed for business travelers and remote workers, these headphones feature cutting-edge active noise cancellation to block out distractions, allowing you to concentrate on what truly matters. 
With an impressive 40-hour battery life, you can enjoy uninterrupted productivity or relaxation on even the longest journeys. 
The luxurious memory foam ear cushions ensure a snug, comfortable fit for all-day wear, reducing fatigue and enhancing your listening experience. 
Elevate your work and travel with NoiseGuard Pro—where clarity meets comfort.

Hanya dengan beberapa baris kode, kita telah membuat salinan pemasaran berkualitas yang biasanya memerlukan penulis profesional. Fungsi ini juga dapat digunakan kembali — cukup ubah parameternya, dan Anda dapat menghasilkan deskripsi untuk produk apa pun di katalog Anda.

Contoh ini menunjukkan pola kunci saat menggunakan Responses API:

1. Parameter instructions berfungsi sebagai prompt sistem, yang mendefinisikan perilaku dan konteks AI.
2. Parameter temperature (0–2) mengontrol tingkat keacakan—nilai lebih rendah menghasilkan keluaran yang lebih deterministik sedangkan nilai lebih tinggi meningkatkan kreativitas.
3. Parameter max_output_tokens membatasi panjang respons, yang membantu mengendalikan biaya dan memastikan keluaran yang ringkas.
4. Objek respons memuat teks yang dihasilkan dalam properti output_text.

Menganalisis gambar untuk aplikasi praktis

Banyak aplikasi dunia nyata perlu memproses teks dan gambar sekaligus. Misalnya, platform e-commerce perlu menganalisis foto produk, sistem moderasi konten perlu meninjau unggahan, dan aplikasi media sosial perlu memahami konten visual.

Responses API unggul dalam tugas multimodal seperti analisis gambar tanpa memerlukan endpoint terpisah atau kode integrasi yang kompleks:

def analyze_product_image(image_url):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a product photography expert and e-commerce consultant.",
       input=[
           {"role": "user", "content": "Analyze this product image and provide the following details:\n1. Product category\n2. Key visible features\n3. Potential quality issues\n4. Suggested improvements for the product photography"},
           {
               "role": "user",
               "content": [
                   {
                       "type": "input_image",
                       "image_url": image_url
                   }
               ],
           },
       ],
       temperature=0.2
   )
  
   return response.output_text

# Example with a sports team image
analysis = analyze_product_image("https://upload.wikimedia.org/wikipedia/commons/a/a5/Barcelona_fc_lamina_elgrafico.jpg")
print(analysis)

Keluaran:

1. **Product Category**: Sports team memorabilia or vintage sports photography.

2. **Key Visible Features**:
  - The image features a group of individuals in sports uniforms, likely a football (soccer) team.
  - The uniforms have distinct vertical stripes in red and blue.
  - A football is visible in the foreground.
  - The setting appears to be an outdoor field, possibly a stadium.

...

Fungsi ini dapat diintegrasikan ke dalam platform e-commerce untuk secara otomatis menganalisis foto produk saat penjual mengunggahnya. Sistem dapat memberikan umpan balik langsung tentang kualitas gambar dan menyarankan perbaikan, yang pada akhirnya mengarah ke tingkat konversi yang lebih baik melalui listing berkualitas lebih tinggi — semuanya tanpa peninjauan manual.

Saat bekerja dengan gambar, Anda harus mengirimkan array objek pesan ke parameter input alih-alih string, masing-masing dengan nilai role dan content.

 Konten gambar ditentukan sebagai objek dengan type: input_image dan sebuah image_url. Anda dapat menggabungkan teks dan gambar dalam permintaan yang sama, sehingga memungkinkan interaksi multimodal yang kaya.

Menerapkan streaming untuk aplikasi yang responsif

Pengguna mengharapkan umpan balik instan. Menunggu beberapa detik untuk respons AI dapat menurunkan keterlibatan — itulah mengapa streaming sangat penting untuk menciptakan pengalaman pengguna yang responsif, terutama dalam aplikasi chat atau waktu nyata.

Bayangkan Anda sedang membangun alat analisis umpan balik pelanggan untuk tim produk. Alih-alih membuat mereka menunggu analisis lengkap, Anda dapat melakukan streaming hasilnya saat hasil tersebut dihasilkan:

def analyze_customer_feedback(feedback_text):
   print("Analyzing customer feedback in real-time:")
  
   stream = client.responses.create(
       model="gpt-4o",
       instructions="Extract key sentiments, product issues, and actionable insights from this feedback.",
       input=feedback_text,
       stream=True,
       temperature=0.3,
       max_output_tokens=500
   )
  
   full_response = ""
   print("\nAnalysis results:")
   for event in stream:
       if event.type == "response.output_text.delta":
           print(event.delta, end="")
           full_response += event.delta
       elif event.type == "response.error":
           print(f"\nError occurred: {event.error}")
  
   return full_response

# Example with a complex customer review
feedback = """
I've been using the SmartHome Hub for about 3 months now. The voice recognition is fantastic
and the integration with my existing devices was mostly seamless. However, the app crashes
at least once a day, and the night mode feature often gets stuck until I restart the system.
Customer support was helpful but couldn't fully resolve the app stability issues.
"""

analysis_result = analyze_customer_feedback(feedback)

Dalam aplikasi nyata, Anda akan mengganti pernyataan print dengan pembaruan UI, sehingga pengguna dapat melihat analisis terbentuk secara waktu nyata—mirip dengan bagaimana aplikasi chat modern menampilkan AI "sedang berpikir" saat menghasilkan respons. Ini menciptakan pengalaman yang lebih menarik dan memberi pengguna umpan balik langsung bahwa permintaan mereka sedang diproses.

Implementasi streaming bekerja dengan cara:

1. Menyetel stream=True dalam metode create
2. Memproses respons sebagai iterable event dengan tipe tertentu
3. Menangani tipe event yang berbeda secara terpisah: response.output_text.delta untuk potongan konten, response.error untuk kesalahan

Sekarang setelah kita membahas fungsionalitas dasar Responses API, mari jelajahi alat bawaannya yang semakin meningkatkan kapabilitasnya.

Alat Bawaan OpenAI Responses API

Responses API mengintegrasikan beberapa alat bawaan yang memperluas kapabilitasnya melampaui pembuatan teks dasar. Alat-alat ini memungkinkan pengembang membuat aplikasi yang lebih bertenaga tanpa perlu kode integrasi yang kompleks atau panggilan API berulang.

Penelusuran web: mengakses informasi waktu nyata

Alat penelusuran web memungkinkan Responses API mengambil informasi terkini dari internet, mengatasi keterbatasan LLM yang hanya terbatas pada data latihannya.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
   model="gpt-4o",
   tools=[{"type": "web_search_preview"}],
   input="What are some news related to the stock market?",
)

print(response.output_text)

Keluaran:

Recent developments in the stock market have been significantly influenced by escalating trade tensions between the United States and China. On April 5, 2025, President Donald Trump announced an additional 34% tariff on Chinese goods, raising total tariffs to 54% this year. In response, China imposed reciprocal 34% tariffs on U.S. products and introduced export restrictions on certain rare earth elements. These actions led to a sharp global market selloff, with the S&P 500 falling 9% for the week, marking the steepest decline since the pandemic. (reuters.com)

…..


## Escalating US-China Trade Tensions Impact Global Markets:
- [China says 'market has spoken' after US tariffs spark selloff](https://www.reuters.com/world/china/china-says-market-has-spoken-after-us-tariffs-spark-selloff-2025-04-05/?utm_source=openai)
- [Trump touts "economic revolution" as economists warn of recession](https://www.axios.com/2025/04/05/trump-tariffs-stock-market-recession?utm_source=openai)
- [Believe it or not, there were some winners in the stock market this week](https://apnews.com/article/ce81e9ae6fb463dc763dfaa464778343?utm_source=openai)

Saat diaktifkan, alat penelusuran web melakukan beberapa operasi, mulai dari menganalisis kueri hingga mensintesis informasi dari berbagai sumber dengan sitasi yang tepat. Kapabilitas ini membuka peluang untuk aplikasi kaya informasi seperti alat analisis finansial yang memberikan wawasan pasar, platform agregasi berita yang menggabungkan berbagai sumber, atau sumber belajar yang melengkapi konten inti dengan riset terkini.

Manfaat utama alat ini adalah kemampuan untuk menyediakan informasi tepat waktu tanpa perlu membangun dan memelihara integrasi penelusuran kustom atau sistem web scraping. Alat ini menangani proses penelusuran sambil menyajikan hasil dengan sitasi yang tepat untuk menjaga transparansi mengenai sumber informasi.

Penelusuran file: mengekstrak informasi dari dokumen

Sementara penelusuran web membawa pengetahuan eksternal ke dalam aplikasi Anda, alat penelusuran file berfokus pada membuka informasi dari dokumen. Alat ini memungkinkan API menelusuri dan mengekstrak informasi dari dokumen yang telah diunggah ke OpenAI.

Alat penelusuran file memungkinkan beberapa kapabilitas utama:

• Menelusuri berbagai jenis file (PDF, dokumen Word, presentasi, dll.).
• Menemukan informasi spesifik dalam dokumen berdasarkan kueri bahasa natural.
• Mengekstrak dan mensintesis informasi dari beberapa dokumen secara bersamaan.
• Menyediakan sitasi ke bagian spesifik dari dokumen sumber.
• Mendukung kueri kompleks yang merujuk informasi di beberapa file.

Kapabilitas ini sangat cocok untuk kasus penggunaan analisis dokumen seperti mengekstrak informasi dari kontrak hukum, menganalisis makalah penelitian, atau membangun basis pengetahuan dari dokumentasi teknis. Alat ini dapat mengidentifikasi bagian yang relevan di banyak dokumen dan mensintesis informasi sebagai respons terhadap kueri spesifik.

Implementasinya memerlukan pengunggahan file terlebih dahulu ke endpoint files milik OpenAI, lalu meneruskan ID file ke Responses API saat membuat kueri. Ini menciptakan alur kerja yang ringkas bagi aplikasi yang perlu merujuk informasi spesifik dalam dokumen tanpa mengharuskan pengguna melakukan penelusuran manual.

Penggunaan komputer: kapabilitas interaksi antarmuka

Bertumpu pada pemahaman teks dan dokumen, alat penggunaan komputer memperluas kapabilitas AI ke ranah interaksi antarmuka. Alat ini merepresentasikan kemajuan signifikan yang menjembatani pemahaman bahasa dan manipulasi antarmuka pengguna.

Alat penggunaan komputer dapat melakukan berbagai interaksi antarmuka:

• Menavigasi situs web dan aplikasi web secara otonom.
• Mengisi formulir dengan informasi yang sesuai.
• Mengekstrak data dari halaman web dan aplikasi.
• Menjalankan proses multi-langkah di berbagai layar.
• Berinteraksi dengan elemen seperti tombol, dropdown, dan kolom teks.
• Memahami konteks dan tujuan berbagai elemen antarmuka.

Aplikasi potensial mencakup otomasi proses untuk tugas berulang, bantuan terpandu untuk alur kerja kompleks, dan peningkatan aksesibilitas bagi pengguna yang kesulitan dengan antarmuka tradisional. Alat ini dapat digunakan untuk mengotomatiskan pengisian formulir, menavigasi situs web yang kompleks, atau melakukan pengujian antarmuka pengguna.

Teknologinya bekerja dengan memungkinkan AI melihat dan berinteraksi dengan elemen layar, memahami konteks, dan mengeksekusi tindakan berdasarkan instruksi bahasa natural. Ini menciptakan kemungkinan untuk otomasi dan asistensi yang jika tidak demikian akan memerlukan pengembangan khusus kode antarmuka.

Kapabilitas alat tambahan

Ekosistem alat dalam Responses API terus berkembang, dengan OpenAI secara teratur menambahkan kapabilitas baru. Dokumentasi alat yang komprehensif mencakup detail implementasi untuk semua alat yang tersedia saat ini, sementara artikel tentang alat baru untuk membangun agen memberikan konteks strategis tentang bagaimana alat ini berevolusi.

Alat bawaan ini menyediakan kapabilitas kuat secara langsung, tetapi banyak aplikasi memerlukan koneksi ke layanan khusus atau sistem proprieter. Di sinilah function calling menjadi esensial, memungkinkan Anda memperluas Responses API dengan alat kustom dan layanan eksternal Anda sendiri — fokus pada bagian berikutnya.

Function Calling di Responses API

Meskipun alat bawaan menyediakan kapabilitas yang kuat, banyak aplikasi memerlukan koneksi ke layanan khusus atau sistem proprieter. Function calling memungkinkan Anda memperluas Responses API dengan alat kustom Anda sendiri, sehingga model dapat menentukan kapan dan bagaimana memanggil fungsi Anda berdasarkan masukan pengguna.

Function calling menciptakan jembatan antara pemahaman bahasa AI dan sistem eksternal Anda — baik itu mengambil kurs nilai tukar, menghitung jarak, atau memeriksa ketersediaan janji temu. Pola ini mengikuti alur kerja yang jelas:

1. Anda mendefinisikan fungsi yang dapat digunakan AI, menentukan parameter dan tipenya.
2. AI memutuskan kapan memanggil fungsi tersebut berdasarkan kueri pengguna.
3. Kode Anda mengeksekusi fungsi dengan parameter yang diberikan AI.
4. Anda mengembalikan hasilnya ke AI, yang kemudian memasukkannya ke dalam responsnya.

Membuat alat konversi mata uang

Mari implementasikan fungsi konversi mata uang sederhana sebagai contoh:

# Dictionary of exchange rates (relative to USD)
exchange_rates = {
   "USD": 1.0,
   "EUR": 0.93,
   "GBP": 0.79,
   "JPY": 153.2,
   "CAD": 1.37,
   "AUD": 1.52
}

def convert_currency(amount, from_currency, to_currency):
   """Convert an amount from one currency to another."""
   # Normalize currency codes to uppercase
   from_currency = from_currency.upper()
   to_currency = to_currency.upper()
  
   # Check if currencies are supported
   if from_currency not in exchange_rates:
       return {"error": f"Currency not supported: {from_currency}"}
   if to_currency not in exchange_rates:
       return {"error": f"Currency not supported: {to_currency}"}
  
   # Convert to USD first, then to target currency
   amount_in_usd = amount / exchange_rates[from_currency]
   converted_amount = amount_in_usd * exchange_rates[to_currency]
  
   return {
       "original_amount": amount,
       "from_currency": from_currency,
       "to_currency": to_currency,
       "converted_amount": round(converted_amount, 2)
   }

Fungsi ini menerima tiga parameter: jumlah yang akan dikonversi, mata uang sumber, dan mata uang target. Fungsi ini melakukan konversi sederhana menggunakan kurs yang telah ditentukan dan mengembalikan hasil terstruktur dengan detail konversi.

Mendefinisikan fungsi untuk Responses API

Sekarang, kita perlu memberi tahu model tentang fungsi kita agar model dapat memutuskan kapan harus memanggilnya:

from openai import OpenAI
import json

client = OpenAI()

tools = [
   {
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }
]

Definisi ini secara jelas menetapkan:

• Nama fungsi convert_currency yang sesuai dengan fungsi Python kita.
• Deskripsi yang menjelaskan kapan fungsi harus digunakan.
• Tiga parameter wajib dengan tipe dan deskripsinya.
• Flag strict: true untuk memastikan model mengikuti spesifikasi parameter kita dengan tepat.

Menangani kueri pengguna

Mari simulasi percakapan saat pengguna bertanya tentang konversi mata uang:

input_messages = [
   {"role": "user", "content": "How much is 100 euros in Japanese yen?"}
]

response = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)

Saat model melihat pertanyaan tentang konversi mata uang ini, model mengenali bahwa ia harus menggunakan fungsi kita. Model secara otomatis mengidentifikasi bahwa:

• Jumlahnya adalah 100
• Mata uang sumber adalah euro (EUR)
• Mata uang target adalah yen Jepang (JPY)

Memproses panggilan fungsi

Sekarang kita mengekstrak detail panggilan fungsi dan mengeksekusi fungsi kita:

tool_call = response.output[0]
print(f"Function called: {tool_call.name}")
print(f"Arguments: {tool_call.arguments}")

args = json.loads(tool_call.arguments)

# Execute the function with the parameters determined by the model
conversion_result = convert_currency(**args)
print(f"Function results: {conversion_result}")

Model telah menerjemahkan kueri bahasa natural menjadi parameter terstruktur. Fungsi kita kemudian melakukan perhitungan berdasarkan parameter ini dan mengembalikan jumlah yang telah dikonversi.

Mengembalikan hasil fungsi ke model

Terakhir, kita kirimkan hasilnya kembali ke model agar model dapat menghasilkan respons yang ramah pengguna:

input_messages.append(tool_call)  # append model's function call message
input_messages.append(
   {  # append result message
       "type": "function_call_output",
       "call_id": tool_call.call_id,
       "output": json.dumps(conversion_result)
   }
)

response_2 = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)
print(response_2.output_text)

Keluaran:

100 euros is equal to 16,473.12 Japanese yen based on current exchange rates.

Model telah mengambil data konversi mentah kita dan mengubahnya menjadi respons yang natural dan mudah dibaca. Model menafsirkan hasil numerik dengan benar dan menyajikannya dalam format mata uang yang sesuai.

Menggabungkan semuanya

Dalam aplikasi nyata, Anda akan ingin merangkum seluruh proses ini ke dalam satu antarmuka yang menangani alur percakapan secara mulus. Berikut cara Anda membuat asisten lengkap yang mengelola keseluruhan proses function calling:

def currency_assistant(user_message, conversation_history=None):
   """A complete assistant that handles currency conversion queries."""
   if conversation_history is None:
       conversation_history = []
  
   # Add the user's new message to the conversation
   conversation_history.append({"role": "user", "content": user_message})
  
   # Define available tools (our currency conversion function)
   tools = [{
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }]
  
   # Get initial response from the model
   response = client.responses.create(
       model="gpt-4o",
       input=conversation_history,
       tools=tools,
   )
  
   # Check if the model wants to call a function
   if response.output and isinstance(response.output, list) and response.output[0].type == "function_call":
       tool_call = response.output[0]
      
       # Process the function call
       args = json.loads(tool_call.arguments)
       result = convert_currency(**args)
      
       # Add the function call and its result to the conversation
       conversation_history.append(tool_call)
       conversation_history.append({
           "type": "function_call_output",
           "call_id": tool_call.call_id,
           "output": json.dumps(result)
       })
      
       # Get the final response with the function results incorporated
       final_response = client.responses.create(
           model="gpt-4o",
           input=conversation_history,
           tools=tools,
       )
      
       return final_response.output_text, conversation_history
   else:
       # If no function call was needed, return the direct response
       return response.output_text, conversation_history

# Example usage
response, conversation = currency_assistant("How much is 50 British pounds in Australian dollars?")
print("Assistant:", response)

# Continue the conversation
response, conversation = currency_assistant("And what if I wanted to convert 200 Canadian dollars instead?", conversation)
print("Assistant:", response)

Implementasi ini:

1. Mempertahankan riwayat percakapan untuk memberikan konteks bagi pertanyaan lanjutan.
2. Menangani seluruh proses function calling dalam satu antarmuka.
3. Menentukan kapan function calling diperlukan dan kapan model dapat merespons langsung.
4. Mendukung percakapan multi-giliran di mana konteks sebelumnya penting.

Dengan pendekatan ini, Anda dapat menciptakan pengalaman percakapan yang mulus di mana pengguna berinteraksi secara natural tanpa menyadari proses function calling yang kompleks di balik layar. Asisten menangani transisi antara pemahaman bahasa natural, panggilan fungsi terstruktur, dan generasi bahasa natural.

Membangun aplikasi yang lebih kompleks mungkin melibatkan:

1. Mendukung banyak fungsi, masing-masing untuk jenis kueri yang berbeda.
2. Mengelola autentikasi dan otorisasi untuk operasi sensitif.
3. Menerapkan penanganan kesalahan dan pemulihan yang lebih canggih.
4. Menambahkan logging dan pemantauan untuk penggunaan dan kinerja fungsi.
5. Membuat antarmuka pengguna yang mendukung interaksi teks, suara, atau multimodal.

Function calling memungkinkan Responses API menghubungkan masukan bahasa natural dengan layanan dan data Anda. Ini menciptakan jembatan antara permintaan pengguna dan sistem bisnis Anda, memungkinkan pengguna membuat permintaan dalam bahasa biasa sementara aplikasi Anda menangani detail teknis implementasi di latar belakang.

Di luar function calling, kapabilitas kuat lain dari Responses API adalah kemampuan menghasilkan keluaran terstruktur. Fitur ini melengkapi function calling dengan menyediakan cara untuk menerima respons dalam format spesifik yang selaras dengan kebutuhan aplikasi Anda.

Keluaran Terstruktur dengan Responses API

Saat membangun aplikasi AI, Anda sering memerlukan respons dalam format tertentu agar lebih mudah diintegrasikan dengan sistem Anda. Responses API mendukung keluaran terstruktur yang memungkinkan Anda menerima data dalam format yang terdefinisi dengan baik dan konsisten, bukan teks bebas. Fitur ini sangat berharga ketika Anda perlu:

1. Mengekstrak informasi spesifik dari teks tak terstruktur.
2. Transformasi masukan pengguna menjadi data terstruktur.
3. Memastikan format respons konsisten untuk pemrosesan tahap lanjut.
4. Mengintegrasikan keluaran AI langsung dengan basis data atau API.

Keluaran terstruktur mengurangi kebutuhan parsing dan validasi tambahan, sehingga aplikasi Anda lebih andal dan mudah dirawat.

Mengekstrak informasi produk dari deskripsi

Mari jelajahi contoh praktis: bayangkan Anda sedang membangun platform e-commerce dan perlu secara otomatis mengekstrak detail produk dari deskripsi produk yang tak terstruktur untuk mengisi basis data Anda.

from openai import OpenAI
import json

client = OpenAI()

product_description = """
Our Premium Laptop Backpack is perfect for professionals and students alike.
Made with water-resistant material, it features padded compartments that fit
laptops up to 15.6 inches. The backpack includes 3 main storage areas,
5 smaller pockets, and has an integrated USB charging port. Available in
navy blue, black, and gray. Current retail price: $79.99, though it's
currently on sale for $64.99 until the end of the month.
"""

response = client.responses.create(
   model="gpt-4o",
   input=f"Extract structured product information from this description: {product_description}",
   text={
       "format": {
           "type": "json_schema",
           "name": "product_details",
           "schema": {
               "type": "object",
               "properties": {
                   "product_name": {"type": "string"},
                   "category": {"type": "string"},
                   "features": {"type": "array", "items": {"type": "string"}},
                   "colors": {"type": "array", "items": {"type": "string"}},
                   "pricing": {
                       "type": "object",
                       "properties": {
                           "regular_price": {"type": "number"},
                           "sale_price": {"type": "number"},
                           "currency": {"type": "string"},
                       },
                       "additionalProperties": False,
                       "required": ["regular_price", "sale_price", "currency"],
                   },
               },
               "required": ["product_name", "features", "colors", "pricing","category"],
               "additionalProperties": False,
           },
           "strict": True,
       }
   },
)

product_data = json.loads(response.output_text)
print(json.dumps(product_data, indent=2))

Keluaran:

{
 "product_name": "Premium Laptop Backpack",
 "category": "Backpack",
 "features": [
   "Water-resistant material",
   "Padded compartments for laptops up to 15.6 inches",
   "3 main storage areas",
   "5 smaller pockets",
   "Integrated USB charging port"
 ],
 "colors": [
   "Navy blue",
   "Black",
   "Gray"
 ],
 "pricing": {
   "regular_price": 79.99,
   "sale_price": 64.99,
   "currency": "USD"
 }
}

Data JSON berformat ini kini dapat diintegrasikan langsung dengan basis data produk Anda, menghilangkan kebutuhan akan logika parsing kustom dan mengurangi kemungkinan kesalahan.

Memahami konfigurasi keluaran terstruktur

Kunci keluaran terstruktur yang efektif dan bebas kesalahan adalah mendefinisikan skema Anda dengan benar. Mari uraikan elemen penting dari konfigurasinya:

text={
   "format": {
       "type": "json_schema",        # Specifies we're using JSON Schema
       "name": "product_details",    # A descriptive name for this schema
       "schema": {
           # Your JSON Schema definition here
           "type": "object",
           "properties": {
               # Each property with type information, e.g.
               "product_name": {"type": "string"},
               # ... other properties
           },
           "required": ["product_name", ...], # All other properties
           "additionalProperties": False
       },
       "strict": True                # Enforce schema constraints strictly
   }
}

Komponen terpenting adalah:

1. Definisi skema: Mendeskripsikan struktur, termasuk semua properti dan tipenya.
2. Bidang wajib: Mencantumkan properti yang harus disertakan dalam respons.
3. Properti tambahan: Saat disetel ke False, mencegah bidang ekstra yang tidak didefinisikan dalam skema.
4. Mode ketat: Saat True, memastikan model mengikuti skema secara presisi.

Tips praktis menggunakan keluaran terstruktur

Untuk hasil terbaik dengan keluaran terstruktur, ikuti pedoman berikut:

1. Rancang skema dengan cermat: Sertakan semua bidang wajib tetapi tetap fokus pada informasi esensial.
2. Gunakan tipe data yang sesuai: Cocokkan tipe skema Anda dengan cara Anda akan menggunakan data (angka untuk perhitungan, string untuk teks).
3. Tetapkan batasan yang jelas: Gunakan enum untuk bidang dengan opsi terbatas dan minimum/maximum untuk batas numerik.
4. Uji dengan masukan beragam: Pastikan skema Anda menangani berbagai format input dan kasus tepi.
5. Sertakan deskripsi yang jelas: Menambahkan deskripsi ke bidang membantu model menafsirkan informasi apa yang perlu diekstrak.

Perbandingan dengan Chat Completions API

Sementara Responses API menyediakan keluaran terstruktur melalui JSON Schema, Chat Completions API menawarkan pendekatan alternatif menggunakan model Pydantic yang jauh lebih sederhana:

from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI

client = OpenAI()

class ProductDetails(BaseModel):
   product_name: str
   category: str = Field(default=None)
   features: List[str]
   specifications: Optional[dict] = None
   colors: List[str]
   pricing: dict

# With Chat Completions API
completion = client.beta.chat.completions.parse(
   model="gpt-4o",
   messages=[
       {"role": "system", "content": "Extract structured product information."},
       {"role": "user", "content": product_description}
   ],
   response_format=ProductDetails
)

pydantic_product = completion.choices[0].message.parsed

Masing-masing pendekatan memiliki manfaat:

• Responses API menggunakan JSON Schema standar langsung di panggilan API
• Chat Completions API terintegrasi dengan sistem tipe Python melalui Pydantic

Menurut saya, saya akan menggunakan Chat Completions API agar dapat menghindari penulisan JSON Schema mentah. Tentu saja, sampai OpenAI menambahkan dukungan untuk model Pydantic ke Responses API.

Untuk informasi lebih lanjut, lihat dokumentasi Responses API untuk Structured Outputs.

Kesimpulan

OpenAI Responses API menyederhanakan cara pengembang berinteraksi dengan model bahasa dengan menggabungkan kekuatan API sebelumnya ke dalam antarmuka terpadu yang memerlukan lebih sedikit kode dan kompleksitas. API ini mendukung pembuatan teks, analisis gambar, function calling, dan keluaran terstruktur, sehingga kapabilitas AI lebih mudah diakses sekaligus memungkinkan pengembang fokus pada pemecahan masalah bisnis alih-alih tantangan integrasi.

Saat Anda melanjutkan perjalanan dengan Responses API, sumber daya tambahan berikut mungkin bermanfaat untuk memperdalam pemahaman dan memperluas keterampilan implementasi Anda:

• Working with the OpenAI API
• OpenAI Fundamentals Track
• GPT-4.5: Apa yang Baru di Model Terbaru OpenAI
• Deep Research dengan OpenAI
• Tutorial Function Calling GPT-4.5
• Tutorial GPT-4.5 API
• Tutorial OpenAI Agents SDK