Audio API OpenAI: Panduan dengan Proyek Demo

OpenAI Audio API

Rilis baru dari OpenAI ini mencakup tiga model:

1. gpt-4o-mini-tts: Model text-to-audio yang mampu menghasilkan audio dari teks dengan berbagai nada dan suara. Fitur menarik dari model text-to-speech ini adalah kita dapat mengarahkan seperti apa suara yang dihasilkan dengan memberikan instruksi teks spesifik. Ini menghadirkan tingkat kustomisasi tinggi, memungkinkan pembuatan pengalaman suara yang unik dan tertailor. Anda dapat mencobanya di OpenAI.fm.
2.  gpt-4o-transcribe dan gpt-4o-mini-transcribe: Dua model audio-to-text yang dirancang untuk mengonversi bahasa lisan menjadi teks tertulis. Fungsi utamanya adalah memberikan transkripsi audio yang sangat akurat dan andal. Model-model ini menunjukkan tingkat kesalahan kata (WER) yang lebih rendah, artinya mereka membuat lebih sedikit kesalahan dalam mengenali kata yang diucapkan dibandingkan solusi sebelumnya.

Model-model baru ini hadir dengan harga berikut:

Proyek Asisten Suara

Dalam tutorial ini, saya akan memandu Anda membangun asisten suara AI langsung di terminal Anda. Asisten suara ini pada dasarnya meniru model AI berbasis teks populer namun akan berinteraksi sepenuhnya melalui bahasa lisan. Bayangkan Anda dapat berbicara langsung ke komputer, mengajukan pertanyaan apa pun, dan menerima jawaban suara hampir seketika.

Proyek kita akan menggunakan arsitektur yang sederhana namun efektif. Kita akan mulai dengan menggunakan mikrofon Anda untuk menangkap prompt lisan. Setelah direkam, kita akan mengonversi masukan audio ini menjadi teks dengan bantuan model speech-to-text canggih.

Teks ini kemudian dimasukkan ke model bahasa besar untuk menghasilkan respons yang sesuai. Terakhir, kita akan mengonversi respons teks kembali menjadi audio, memungkinkan asisten untuk “berbicara” memberikan jawaban kepada Anda. Setiap langkah proses ini dirancang agar asisten suara kita akurat sekaligus menarik.

Walaupun OpenAI menawarkan Realtime API khusus yang dapat meningkatkan interaksi dengan menyederhanakan seluruh proses, kita akan memilih pendekatan berbeda. Realtime API, meski mengesankan dan cocok untuk pengembang yang mencari integrasi cepat, sering kali lebih mahal dan kurang fleksibel.

Dengan memilih membangun proyek menggunakan komponen terpisah untuk setiap langkah, kita mendapatkan kendali yang lebih besar atas kustomisasi asisten AI. Pendekatan ini memungkinkan kita menentukan model yang ingin digunakan, sehingga dapat dioptimalkan untuk kebutuhan spesifik—baik akurasi, kecepatan, maupun preferensi nada respons. Dengan begitu, asisten suara kita bukan hanya alat yang kuat, tetapi juga sangat tertailor, mampu menyesuaikan kebutuhan proyek unik.

Seluruh kode yang kita kembangkan di sini tersedia di repositori GitHub ini. 

Pengaturan Python

Untuk memulai, pertama-tama kita akan menyiapkan lingkungan Anaconda baru bernama audio-demo. Lingkungan Anaconda memungkinkan kita membuat ruang terisolasi untuk setiap proyek sehingga kita bisa memasang versi paket spesifik tanpa konflik. Jalankan perintah berikut di antarmuka baris perintah Anda:

conda create -n audio-demo -y python=3.9
conda activate audio-demo
pip install openai
pip install numpy
pip install dotenv
pip install sounddevice
pip install scipy

Mari kita uraikan fungsi setiap perintah dan paket:

1. Membuat lingkungan:

• conda create -n audio-demo -y python=3.9: Perintah ini membuat lingkungan baru bernama audio-demo dengan Python versi 3.9. Flag -y otomatis menyetujui instalasi paket tanpa konfirmasi.

2. Mengaktifkan lingkungan:

• conda activate audio-demo: Mengaktifkan lingkungan audio-demo yang baru dibuat, sehingga kita dapat bekerja di dalamnya.

3. Memasang paket:

• pip install openai: OpenAI adalah pustaka yang menyediakan akses mudah ke model dan API OpenAI.
• pip install numpy: NumPy adalah pustaka penting untuk komputasi numerik.
• pip install dotenv: Dotenv membantu memuat variabel lingkungan dari berkas .env, sehingga manajemen konfigurasi lebih mudah dan aman.
• pip install sounddevice: Sounddevice memungkinkan kita merekam dan memutar suara dengan fungsi sederhana, ideal untuk menangani input dan output audio di Python.
• pip install scipy: SciPy dibangun di atas NumPy dan menyediakan fungsionalitas tambahan untuk komputasi ilmiah dan teknis, seperti pemrosesan sinyal. Dalam kasus kita, ini digunakan untuk menyimpan berkas audio.

Dengan lingkungan audio-demo siap, kita bisa mulai mengerjakan asisten AI yang dapat memproses input audio. Penyiapan terstruktur ini membantu menjaga ruang pengembangan tetap bersih, memastikan semua dependensi tersedia untuk proyek kita.

Pengaturan Kunci API OpenAI

Untuk menggunakan OpenAI API, kita memerlukan kunci API. Kunjungi halaman kunci API mereka dan buat kunci API dengan mengeklik tombol "Generate new secret key". Salin kuncinya, buat berkas bernama .env, dan tempelkan di sana dengan format berikut:

OPENAI_API_KEY=<paste_your_api_key_here>

Contoh Teks ke Audio

Mari kita telusuri langkah-langkah membuat skrip Python yang menggunakan kemampuan text-to-audio OpenAI, mengubah teks menjadi ucapan dengan sentuhan personal. Kita menulis kode dalam berkas bernama text_to_audio.py di folder yang sama dengan berkas .env.

Impor pustaka yang diperlukan

Pertama, kita perlu mengimpor pustaka yang diperlukan untuk menyusun skrip:

import asyncio
from openai import AsyncOpenAI
from openai.helpers import LocalAudioPlayer
from dotenv import load_dotenv

Mari kita ulas singkat fungsi masing-masing impor ini:

• asyncio: Pustaka ini diperlukan untuk menulis kode asinkron di Python, yang penting saat bekerja dengan API streaming.
• AsyncOpenAI: Bagian dari pustaka OpenAI yang menyediakan alat untuk berinteraksi dengan API OpenAI secara asinkron.
• LocalAudioPlayer: Pembantu dari OpenAI yang memungkinkan kita memutar audio secara lokal di mesin kita.
• load_dotenv: Memuat variabel lingkungan dari berkas .env, tempat kita menyimpan informasi sensitif seperti kunci API.

Memuat variabel lingkungan

Selanjutnya, kita memuat kunci API dari berkas .env menggunakan fungsi load_dotenv:

load_dotenv()

Ini memastikan skrip memiliki akses yang aman ke kunci API.

Inisialisasi OpenAI

Kita membuat instance AsyncOpenAI untuk mulai berinteraksi dengan OpenAI API:

openai = AsyncOpenAI()

Tulis fungsi utama

Sekarang kita mendefinisikan fungsi utama, text_to_audio(), yang akan menggunakan fitur text-to-audio OpenAI untuk memproses input dan memutar audio yang dihasilkan:

async def text_to_audio(text, tone_and_style_instructions):
  async with openai.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input=text,
    instructions=tone_and_style_instructions,
    response_format="pcm",
  ) as response:
    await LocalAudioPlayer().play(response)

Mari kita jelaskan secara singkat apa yang kita lakukan di atas:

• Kita menentukan parameter model dan voice untuk mengendalikan sintesis ucapan. model yang digunakan adalah gpt-4o-mini-tts dan suara yang dipilih adalah "coral".
• Parameter response_format disetel ke "pcm", cocok untuk pemrosesan audio.
• LocalAudioPlayer kemudian memutar respons audio yang dihasilkan oleh API.

Jalankan fungsi

Kita melengkapi skrip dengan baris berikut untuk memastikan fungsi text_to_audio() berjalan saat skrip dieksekusi:

if __name__ == "__main__":
  asyncio.run(text_to_audio("Hello world!", "Enthusiastic voice."))

Blok kode ini memeriksa apakah skrip adalah modul utama yang dijalankan dan mengeksekusi fungsi text_to_audio() menggunakan asyncio.run() untuk menangani logika asinkron.

Dengan langkah-langkah ini, skrip kita siap mengonversi input teks menjadi ucapan menggunakan layanan text-to-audio OpenAI. Penyiapan ini memungkinkan kita bereksperimen dengan berbagai input dan gaya, menghidupkan teks melalui suara.

Kita dapat menjalankan skrip dengan perintah:

python text_to_audio.py

Kode lengkapnya dapat ditemukan di sini.

Transkripsi Audio dari Berkas

Di bagian ini, mari kita jelajahi cara mentranskripsi berkas audio menjadi teks menggunakan alat transkripsi audio OpenAI. Skrip kita dirancang untuk menangani berkas audio secara asinkron agar prosesnya efisien dan cepat. Kita akan mengimplementasikan skrip ini dalam berkas bernama audio_to_text.py.

Impor dan penyiapan awal sama seperti sebelumnya, kecuali kita tidak perlu mengimpor LocalAudioPlayer di sini. Berikut cara menulis fungsi yang mentranskripsi berkas audio:

async def transcribe_audio(audio_filename = "audio.wav"):
  audio_file = await asyncio.to_thread(open, audio_filename, "rb")
  stream = await openai.audio.transcriptions.create(
    model="gpt-4o-mini-transcribe",
    file=audio_file,
    response_format="text",
    stream=True,
  )
  transcript = ""
  async for event in stream:
    if event.type == "transcript.text.delta":
      print(event.delta, end="", flush=True)
      transcript += event.delta
  print()
  audio_file.close()
  return transcript

Mari kita uraikan apa yang terjadi di sini:

1. Membuka berkas audio:

• audio_file = await asyncio.to_thread(open, audio_filename, "rb"): Baris ini membuka berkas audio dalam mode baca biner ("rb"). Metode asyncio.to_thread() memungkinkan operasi pembukaan berkas berjalan di thread terpisah, mencegahnya memblokir bagian program lain.

2. Membuat stream transkripsi:

• stream = await openai.audio.transcriptions. create(...): Baris ini memanggil API transkripsi. 
• Kita menentukan parameter model sebagai gpt-4o-mini-transcribe, yang dirancang khusus untuk tugas transkripsi.
• Parameter file memuat berkas audio yang kita buka.
• response_format="text" memberi tahu API agar mengembalikan transkripsi sebagai teks.
• stream=True digunakan untuk melakukan streaming transkripsi secara real time, artinya begitu sebagian audio diproses, hasilnya segera dikembalikan, mempercepat respons.

3. Memproses stream transkripsi:

• async for event in stream: Memulai loop untuk membaca event dari stream transkripsi saat terjadi.
• if event.type == "transcript.text.delta":: Memeriksa setiap jenis event dan memprosesnya jika berjenis transcript.text.delta, yang menandakan sebagian transkripsi sudah siap.
• print(event.delta, end="", flush=True): Mencetak transkripsi bertahap saat tersedia, memastikan keluaran real time.

4. Menutup berkas audio:

• audio_file.close(): Setelah transkripsi selesai, praktik yang baik adalah menutup berkas audio untuk membebaskan sumber daya sistem.

Dengan mengeksekusi fungsi main(), kita dapat mengonversi berkas audio menjadi teks secara efisien dan memprosesnya dalam bentuk stream untuk mendapatkan umpan balik segera. Penyiapan ini ideal untuk aplikasi yang memerlukan transkripsi cepat atau melibatkan berkas audio panjang.

Anda dapat mencobanya dengan menempatkan berkas audio di folder yang sama dengan skrip, mengganti audio.wav dengan nama berkas audio Anda, lalu menjalankan perintah:

python audio_to_text.py

Kode lengkapnya dapat ditemukan di sini.

Transkripsi Audio dari Mikrofon

Karena tujuan kita adalah membuat asisten suara, kita perlu merekam prompt audio pengguna ke dalam berkas audio.

Kita akan membuat berkas baru bernama record.py dengan fungsi bernama record_audio. Fungsi ini menangkap suara dari mikrofon dan menyimpannya sebagai berkas audio. Kita tidak akan membahas rinci cara kerjanya karena bukan fokus utama artikel ini:

import sounddevice as sd
import numpy as np
import scipy.io.wavfile as wavfile

SAMPLE_RATE = 44100  # Sample rate in Hz

def record_audio():
    print("[INFO: Recording... Press <Enter> to stop]")
    audio_data = []  # Initialize a list to store audio frames
    def callback(indata, frames, time, status):
        audio_data.append(indata.copy())
    with sd.InputStream(samplerate=SAMPLE_RATE, channels=1, callback=callback, dtype='int16'):
        input()  # Wait for the user to press Enter to stop recording
    print("[INFO: Recording complete]")
    print()
    audio_data = np.concatenate(audio_data)  # Concatenate the list into a single array
    filename = "output.wav"
    wavfile.write(filename, SAMPLE_RATE, audio_data)
    return audio_data

Saat fungsi ini dipanggil, perekaman dari mikrofon pengguna akan dimulai. Fungsi akan menunggu hingga pengguna menekan "Enter" lalu menyimpan audio ke dalam berkas dengan nama yang diberikan.

Untuk mengujinya, kita dapat menggabungkan fungsi ini dengan fungsi transkripsi di atas untuk mentranskripsi pesan yang diucapkan pengguna. Berikut cara membuat berkas baru bernama record_and_transcribe.py untuk mengimplementasikannya:

import asyncio
from audio_to_text import transcribe_audio
from audio_recorder import record_audio

async def main():
  record_audio("prompt.wav")
  await transcribe_audio("prompt.wav")

if __name__ == "__main__":
  asyncio.run(main())

Anda dapat mencoba menjalankannya dengan perintah python record_and_transcribe.py. Skrip akan merekam ucapan Anda hingga Anda menekan "Enter" lalu mentranskripsikan yang Anda ucapkan.

Membangun Asisten Audio

Di bagian ini, kita merangkai semuanya untuk membangun asisten audio. Kita mengimplementasikannya dalam berkas baru bernama audio_assistant.py dengan langkah-langkah berikut:

• Rekam prompt audio pengguna menggunakan fungsi record_audio().
• Konversi prompt audio menjadi teks dengan fungsi transcribe_audio().
• Gunakan model text-to-text biasa seperti gpt-4o untuk menghasilkan jawaban.
• Terakhir, konversi jawaban tekstual menjadi audio menggunakan fungsi text_to_audio().
• Ulangi hingga pengguna keluar.

Diagram berikut mengilustrasikan hal ini:

Saya mendorong Anda untuk mencoba membangunnya sendiri sebelum melanjutkan membaca.

Pertama, kita mengimpor fungsi yang telah diimplementasikan sebelumnya dan menginisialisasi klien OpenAI.

# Import the functions we created
from text_to_audio import text_to_audio
from audio_to_text import transcribe_audio
from audio_recorder import record_audio

# Import other dependencies and initialize OpenAI
import asyncio
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()
openai = AsyncOpenAI()

Lalu, kita membutuhkan fungsi untuk menghasilkan jawaban. Ini menggunakan OpenAI GPT API biasa dengan model seperti gpt-4o atau model text-to-text lainnya. Jika Anda baru dengan ini, Anda bisa melihat tutorial API GPT-4o ini.

Berikut implementasi async dari fungsi ini:

async def get_answer(prompt):
  stream = await openai.chat.completions.create(
    model="gpt-4o",
    messages=[
      {"role": "user", "content": prompt}
    ],
    stream=True,
  )
  answer = ""
  async for chunk in stream:
    content = chunk.choices[0].delta.content
    if content is not None:
      answer += content
      print(content, end="", flush=True)
  print("\n\n")
  return answer

Untuk mengimplementasikan loop utama, kita mengikuti langkah-langkah yang diuraikan di atas:

async def main(tone_and_style_instructions):
  await text_to_audio("Hello, how can I help you today?", tone_and_style_instructions)
  while True:
    record_audio("prompt.wav")
    prompt = await transcribe_audio("prompt.wav")
    print()
    answer = await get_answer(prompt)
    await text_to_audio(answer, tone_and_style_instructions)

Terakhir, kita jalankan loop utama saat skrip dieksekusi:

if __name__ == "__main__":
  tone_and_style_instructions = "Enthusiastic voice."
  asyncio.run(main(tone_and_style_instructions))

Berikut demo saat dijalankan:

Kode lengkapnya dapat ditemukan di sini.

Peningkatan Lanjutan

Jika kita mencoba menggunakan asisten dengan instruksi nada dan gaya yang kompleks, mungkin kita perhatikan ada ketidaksesuaian antara kata-kata dan nadanya. Misalnya, pertimbangkan instruksi berikut untuk suara "Emo Teenager" yang diambil dari situs OpenAI:

tone_and_style_instructions = """
Tone: Sarcastic, disinterested, and melancholic, with a hint of passive-aggressiveness.
Emotion: Apathy mixed with reluctant engagement.
Delivery: Monotone with occasional sighs, drawn-out words, and subtle disdain, evoking a classic emo teenager attitude.
"""

Nada suara pada audio akan sesuai dengan gaya ini, tetapi konten teks dari jawaban yang dihasilkan oleh fungsi get_answer() tidak mempertimbangkannya, yang dapat menimbulkan sedikit ketidakselarasan. Berikut contohnya:

Untuk mengatasi hal ini, kita dapat memasangkan pesan pengguna dalam fungsi get_answer() dengan prompt sistem yang menunjukkan bahwa teks yang dihasilkan harus mengikuti instruksi nada dan gaya.

Untuk itu, kita memberikan tone_and_style_instructions sebagai argumen kedua fungsi get_answer() dan memodifikasi permintaan chat dengan menambahkan pesan sistem:

async def get_answer(prompt, tone_and_style_instructions):
  stream = await openai.chat.completions.create(
    model="gpt-4o",
    messages=[
      {
        "role": "system", 
        "content": 
          f"""
          The text you generate is being used in a text-to-voice model.
          Make sure your answer matches the guidelines {tone_and_style_instructions}
          """
      },
      {"role": "user", "content": prompt}
    ],
    stream=True,
  )
  answer = ""
  async for chunk in stream:
    content = chunk.choices[0].delta.content
    if content is not None:
      answer += content
      print(content, end="", flush=True)
  print("\n\n")
  return answer

Berikut cara model menjawab sekarang:

Seperti yang Anda lihat, teks yang dihasilkannya kini sesuai dengan instruksi nada. Kode lengkapnya dapat ditemukan di sini.

Membangun Asisten dengan Agents API

Pada contoh sebelumnya, kita secara manual memanggil model voice-to-text dan text-to-voice untuk membangun asisten suara. Dengan melakukan itu, kita belajar cara menggunakan model baru dari voice API OpenAI secara eksplisit.

Namun, jika tujuannya adalah membangun asisten suara, ada cara yang lebih mudah menggunakan agent’s API. API ini telah diperbarui agar secara otomatis menangani alur kerja voice-to-text-to-voice yang telah kita implementasikan di sini.

Jika ini pertama kalinya Anda menggunakan agent’s API, Anda bisa melihat tutorial tentang OpenAI Agents SDK ini.

Sebelum mulai, kita perlu memasang satu dependensi lagi:

pip install 'openai-agents[voice]'

Setelah itu, kita mulai dengan mengimpor semua yang diperlukan untuk menjalankan agent dengan pipeline suara:

from dotenv import load_dotenv
load_dotenv()
import asyncio
from agents import Agent
from agents.voice import (
    AudioInput,
    SingleAgentVoiceWorkflow,
    VoicePipeline,
    VoicePipelineConfig,
    TTSModelSettings,
)
from audio_recorder import record_audio
from audio_player import AudioPlayer

AudioPlayer bukan bagian dari paket mana pun. Ia diimpor dari berkas lokal dan berisi kelas sederhana untuk membantu kita memutar audio secara real time. Ini diperlukan karena dengan VoicePipeline, kita akan menerima audio per potongan, dan kita akan memutar setiap potongan saat diterima. Berikut isi dari berkas audio_player.py:

import numpy as np
import sounddevice as sd
class AudioPlayer:
  def __enter__(self):
    self.stream = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
    self.stream.start()
    return self
  def __exit__(self, tp, val, tb):
    self.stream.close()
  def add_audio(self, audio_data):
    self.stream.write(audio_data)

Langkah berikutnya adalah membuat agent:

agent = Agent(
  name="Voice Assistant",
  instructions="You’re a helpful assistant speaking to a human.",
  model="gpt-4o-mini",
)

Berikut deskripsi parameter yang kita gunakan:

• name: Dapat berupa apa pun yang kita inginkan.
• instructions: Instruksi ini mendefinisikan peran agent. Berfungsi sebagai prompt sistem.
• model: Model yang digunakan untuk menghasilkan jawaban.

Agent berfungsi seperti get_answer() yang kita implementasikan sebelumnya. Anggap saja sebagai bagian pipeline yang menyediakan jawaban untuk prompt teks.

Berikutnya, kita mendefinisikan pipeline. Di sinilah kita menentukan semua konfigurasi terkait suara:

pipeline = VoicePipeline(
  workflow=SingleAgentVoiceWorkflow(agent),
  stt_model="gpt-4o-mini-transcribe",
  tts_model="gpt-4o-mini-tts",
  config=VoicePipelineConfig(
    tts_settings=TTSModelSettings(
      voice="coral",
      instructions="""
        Speak in an enthusiastic voice.
      """
    )
  )
)

Berikut penjelasan beberapa parameternya:

• stt_model: Model yang digunakan untuk mengonversi ucapan menjadi teks.
• tts_model: Model yang digunakan untuk mengonversi teks menjadi ucapan.
• config: Menyediakan konfigurasi pipeline. Di sini kita menggunakannya untuk menentukan suara yang ingin dipakai tts_model, serta instruksi pengucapan.

Terakhir, kita jalankan loop utama, serupa seperti yang kita lakukan sebelumnya:

async def main():
  while True:
    audio_input = AudioInput(buffer=record_audio())
    result = await pipeline.run(audio_input)
    with AudioPlayer() as player:
      async for event in result.stream():
        if event.type == "voice_stream_event_audio":
          player.add_audio(event.data)

if __name__ == "__main__":
    asyncio.run(main())

Anda dapat menemukan implementasi lengkapnya di sini.

Menambahkan tools

Perhatikan bahwa loop ini akan berjalan selamanya, karena kita tidak menentukan kondisi berhenti. Saat mengeksekusinya, Anda harus menghentikan proses secara manual. Salah satu cara untuk menghentikannya adalah dengan menyediakan tool kepada agent. 

Tools adalah fungsi yang kita sediakan kepada agent agar dapat dieksekusi untuk kita. Dalam kasus ini, kita bisa menyediakan fungsi yang menghentikan skrip. Agent menggunakan nama fungsi dan komentarnya untuk memutuskan apakah ia harus memanggilnya.

from agents import function_tool
@function_tool
def stop_conversation():
  """Stop the conversation."""
  exit()

Lalu, kita berikan tool tersebut kepada agent:

agent = Agent(
  …
  tools=[stop_conversation], # Add this line when creating the agent
)

Dengan implementasi ini, jika kita berkata, “Saya ingin menghentikan percakapan,” agent akan memahami bahwa ia perlu memanggil fungsi stop_conversation(). Perhatikan bahwa implementasi ini tidak akan keluar dengan mulus karena cara fungsi stop_conversation() diimplementasikan.

Lihat berkas ini jika Anda menginginkan skrip lengkap.

Menggunakan beberapa agent

Fitur menarik dari agents API adalah kita dapat mengonfigurasi beberapa agent untuk bekerja bersama. Berikut contoh yang diambil dari dokumentasi OpenAI:

from agents.extensions.handoff_prompt import prompt_with_handoff_instructions

spanish_agent = Agent(
  name="Spanish voice assistant",
  handoff_description="A spanish speaking agent.",
  instructions=prompt_with_handoff_instructions(
    "You're speaking to a human, so be polite and concise. Speak in Spanish.",
  ),
  model="gpt-4o-mini",
)

agent = Agent(
  name="Voice Assistant",
  instructions=prompt_with_handoff_instructions("""
    You're speaking to a human, so be polite and concise. 
    If the user speaks in Spanish, handoff to the spanish agent.
  """),
  model="gpt-4o-mini",
)

Pada contoh ini, kita mendefinisikan agent kedua yang dirancang untuk berbahasa Spanyol dan memodifikasi agent pertama dengan memberikan prompt yang berisi handoff. Saat instruksi handoff terpenuhi, agent kedua akan mengambil alih dan melanjutkan percakapan.

Skrip lengkapnya tersedia di sini.

Kesimpulan

Dengan memanfaatkan kemampuan canggih model audio terbaru OpenAI, kita telah membuat sistem yang secara efektif dapat mentranskripsi bahasa lisan menjadi teks dan menghasilkan ucapan yang menyerupai manusia dari respons tekstual. Proyek ini tidak hanya menunjukkan potensi teknologi saat ini, tetapi juga betapa mudahnya alat-alat ini diakses bagi pengembang yang tertarik membuat solusi AI kustom.