Cara Menggunakan Pratinjau Audio GPT-4o dengan LangChain dan ChatOpenAI

Lingkungan Virtual dan Dependensi

Sebelum menggunakan model gpt-4o-audio-preview dari OpenAI, mari siapkan lingkungan virtual untuk proyek Anda. Ini menjaga semuanya tetap rapi dan mencegah konflik dependensi, yang sangat berguna saat mengerjakan beberapa proyek.

Apa itu lingkungan virtual?

Bayangkan Anda memiliki dua proyek berbeda. Salah satunya membutuhkan versi 1.0 dari sebuah paket, sedangkan yang lain memerlukan versi 2.0. Jika Anda menginstal semuanya secara global, Anda akan mengalami konflik.

Lingkungan virtual membuat ruang kerja terisolasi, seperti gelembung, tempat Anda dapat menginstal apa pun yang dibutuhkan untuk proyek tertentu. Saat Anda membuat lingkungan untuk proyek Anda, Anda tidak perlu khawatir merusak setup Python sistem atau paket yang bertentangan.

Membuat dan mengaktifkan lingkungan virtual

Mari mulai dengan membuat lingkungan virtual untuk proyek kita. Kita akan menggunakan modul venv bawaan Python. Kita perlu:

1. Masuk ke folder proyek Anda—di sinilah lingkungan Anda akan berada. Jika Anda belum memiliki folder proyek, silakan buat terlebih dahulu.
2. Setelah berada di dalam folder, saatnya membuat lingkungan virtual. Di macOS atau Linux, jalankan python3 -m venv env. Di Windows, seperti ini python -m venv env.
1. Perhatikan bahwa venv adalah alat Python untuk membuat lingkungan virtual, dan env adalah nama folder lingkungannya. Anda bisa menamainya apa saja: env, venv, my_project_env, dll. Sebaiknya tetap singkat dan sederhana.
3. Sekarang setelah Anda membuat lingkungan virtual, saatnya mengaktifkannya. Langkah ini penting karena memastikan paket yang Anda instal hanya akan memengaruhi proyek ini saja.
1. Di macOS atau Linux, aktifkan dengan source env/bin/activate. Di Windows, gunakan: .\env\Scripts\activate

Anda akan melihat prompt terminal berubah menjadi seperti env—ini menandakan Anda sedang bekerja di dalam lingkungan virtual. Mulai sekarang, paket yang Anda instal atau perintah yang Anda jalankan akan terisolasi untuk proyek ini.

Menginstal langchain-openai

Dengan lingkungan Anda aktif, saatnya menginstal alat yang dibutuhkan. Karena kita bekerja dengan OpenAI dan LangChain, mari mulai dengan memasang paket langchain-openai. Paket ini memungkinkan kita berinteraksi dengan model-model OpenAI.

Jalankan di terminal: pip install langchain-openai.

Menyiapkan variabel lingkungan

Langkah berikutnya adalah memastikan informasi sensitif Anda, seperti kunci API, tidak tertanam langsung di skrip. Kita akan melakukannya dengan menetapkan variabel lingkungan.

Pertama-tama, Anda memerlukan akses ke model-model OpenAI. Jika belum, kunjungi platform OpenAI dan buat akun. Setelah mendaftar, Anda perlu membuat kunci API. Kunci API ini adalah akses Anda ke model OpenAI, termasuk gpt-4o-audio-preview.

Dalam kasus kita, kita perlu menetapkan OPENAI_API_KEY. Anda dapat mengaturnya secara manual setiap kali mengerjakan proyek, atau menggunakan file .env untuk menyimpannya agar mudah diakses. Mari lihat kedua metodenya.

Metode 1: Menetapkan variabel lingkungan secara manual

Jika Anda hanya bekerja sementara dan ingin penyiapan cepat, Anda dapat menetapkan variabel lingkungan langsung di terminal.

• Di macOS/Linux, jalankan: export OPENAI_API_KEY='your-api-key-here'
• Di Windows, gunakan: set OPENAI_API_KEY='your-api-key-here'

Sekarang kunci API Anda tersedia di skrip, dan Anda bisa mengaksesnya menggunakan modul os di Python.

Metode 2: Menggunakan file .env

Jika Anda menginginkan solusi yang lebih permanen, Anda dapat menggunakan file .env untuk menyimpan variabel lingkungan. File ini berada di folder proyek Anda dan menjaga kunci tetap aman.

Pertama, buat file .env di direktori proyek, lalu di dalamnya tambahkan kunci API seperti ini:

OPENAI_API_KEY=your-api-key-here

Selanjutnya, instal paket python-dotenv:

pip install python-dotenv

Sekarang, di skrip Python Anda, muat variabel lingkungan dari file .env seperti ini:

from dotenv import load_dotenv
import os
load_dotenv()  # Load variables from .env file
api_key = os.getenv('OPENAI_API_KEY')

Metode ini sangat berguna jika Anda memiliki banyak variabel lingkungan untuk dikelola, dan menjaga kode tetap bersih serta aman.

Opsional: LangSmith untuk pelacakan

Jika Anda ingin melacak dan memantau panggilan API untuk debugging atau tujuan kinerja, OpenAI memiliki fitur keren bernama LangSmith. Ini memberi Anda log terperinci dari setiap panggilan API yang dibuat oleh model Anda, yang sangat membantu jika Anda mencoba mengoptimalkan atau menelusuri alur kerja.

Anda dapat mengaktifkan pelacakan LangSmith seperti ini:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"

Sekali lagi, ini sepenuhnya opsional, tetapi alat yang berguna jika Anda mengerjakan aplikasi kompleks dan ingin memantau bagaimana model berperilaku.

Menginstansiasi Model gpt-4o-audio-preview dari OpenAI

Sekarang lingkungan kita sudah siap, saatnya masuk ke bagian menyenangkan—menginstansiasi model gpt-4o-audio-preview dari OpenAI. Di sinilah kita mulai berinteraksi dengan model, membuat permintaan, serta memproses input dan output.

Di bagian ini, kita akan membahas cara menginstansiasi model menggunakan kerangka kerja LangChain, menyesuaikan beberapa parameter dasar, dan menyiapkan semua yang diperlukan untuk mulai menghasilkan respons.

Apa arti menginstansiasi model?

Sebelum masuk ke kode, mari luangkan waktu sejenak untuk memahami apa yang dimaksud dengan "menginstansiasi" model. Ketika kita mengatakan kita menginstansiasi model, kita pada dasarnya membuat objek di Python yang memungkinkan kita berinteraksi dengan model gpt-4o-audio-preview. Objek ini seperti panel kontrol—menyimpan semua pengaturan, konfigurasi, dan metode yang kita perlukan untuk mengirim data ke model dan mendapatkan hasil kembali.

Penyiapan model dasar dengan LangChain

Mari mulai dengan membuat objek model ini. Karena kita bekerja dalam kerangka LangChain, kita akan menggunakan kelas ChatOpenAI dari paket langchain_openai. Kelas ini memberi kita akses mudah ke model-model OpenAI dan fungsionalitasnya.

from langchain_openai import ChatOpenAI

# Create the model object
llm = ChatOpenAI(
    model="gpt-4o-audio-preview",  # Specifying the model
    temperature=0,  # Controls randomness in the output
    max_tokens=None,  # Unlimited tokens in output (or specify a max if needed)
    timeout=None,  # Optional: Set a timeout for requests
    max_retries=2  # Number of retries for failed requests
)

Salah satu hal hebat tentang model ini adalah tingkat kustomisasinya. Anda dapat menyesuaikan parameter sesuai kebutuhan. Misalnya, jika Anda membangun aplikasi yang membutuhkan transkripsi audio, Anda dapat menyesuaikan parameter untuk menangani input yang lebih besar atau membatasi panjang output.

Sebagai contoh, jika Anda menangani permintaan sensitif waktu dan ingin memastikan model tidak memakan waktu terlalu lama, Anda juga bisa menetapkan batas waktu:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    timeout=30  # Set timeout to 30 seconds
)

Gpt-4o-audio-preview dengan Input dan Output Audio

Sekarang model gpt-4o-audio-preview sudah berjalan, mari masuk ke kemampuannya menangani input dan output audio.

Mengunggah dan mengenkode file audio

Sebelum mulai bekerja dengan audio, langkah pertama adalah memuat dan mengenkode file audio Anda ke dalam format yang dapat dipahami model. OpenAI mengharapkan data audio dikirim dalam format base64, jadi kita akan mulai dengan mengunggah file dan mengenkodenya.

Misalkan Anda memiliki file .wav yang ingin diproses model—saya menamainya gpt.wav. Anda dapat menggantinya dengan file Anda menggunakan kode berikut. Begini cara memuat dan menyiapkan file tersebut:

import base64

# Open the audio file and convert to base64
with open("gpt.wav", "rb") as f:
   audio_data = f.read()

# Convert binary audio data to base64
audio_b64 = base64.b64encode(audio_data).decode()

Apa yang terjadi di sini? Kita membaca file audio sebagai data biner (mode "rb"), lalu menggunakan pustaka base64 untuk mengenkodenya menjadi string base64. Inilah format yang diperlukan OpenAI untuk memproses input audio.

Mengirim audio ke model untuk transkripsi

Setelah audio Anda dienkode, saatnya mengoperkannya ke model. Model gpt-4o-audio-preview dapat menyalin ucapan dari file audio—jadi jika Anda pernah perlu mengubah podcast, memo suara, atau rekaman rapat menjadi teks, inilah yang Anda tunggu! Mari lihat cara kerjanya.

# Define the input message with audio
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Transcribe the following:"},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Send the request to the model and get the transcription
output_message = llm.invoke(messages)
print(output_message.content)

Dalam contoh ini, kita mengirim dua bagian data ke model:

• Pesan teks yang menginstruksikan untuk "Transcribe the following."
• Data audio yang dikodekan base64 dengan format ditetapkan sebagai .wav.

Model memproses input ini dan mengembalikan transkripsi audio. Jadi, jika file audio Anda berisi kalimat yang diucapkan, "Saya sedang belajar cara menggunakan AI," model akan mengembalikan output teks seperti: "I'm learning how to use AI."

Menghasilkan output audio dengan gpt-4o-audio-preview

Namun model gpt-4o-audio-preview tidak hanya memahami audio—model ini juga bisa menghasilkan audio. Berikut cara mengonfigurasi model untuk menghasilkan output audio:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    temperature=0,
    model_kwargs={
        "modalities": ["text", "audio"],  # We’re telling the model to handle both text and audio
        "audio": {"voice": "alloy", "format": "wav"},  # Configure voice and output format
    }
)

# Send a request and ask the model to respond with audio
messages = [("human", "Are you human? Reply either yes or no.")]
output_message = llm.invoke(messages)

# Access the generated audio data
audio_response = output_message.additional_kwargs['audio']['data']

Mari kita uraikan:

• modalities=["text", "audio"]: Kita memberi tahu model bahwa kita ingin menangani teks dan audio. Ini memungkinkan model menghasilkan respons berbicara.
• audio={"voice": "alloy", "format": "wav"}: Di sini kita menentukan suara (dalam hal ini, "alloy") dan format output audio (.wav). OpenAI menyediakan beberapa suara, sehingga Anda dapat menyesuaikan pengalaman sesuai kebutuhan aplikasi Anda.

Respons audio yang dikodekan base64 disimpan di output_message.additional_kwargs['audio']['data'], dan Anda dapat dengan mudah mendekode serta menyimpannya untuk diputar.

Menyimpan dan memutar kembali file audio

Sekarang Anda sudah menghasilkan audio, kemungkinan Anda ingin menyimpan file dan memutarnya kembali, bukan? Berikut cara mengambil data audio berformat base64 itu, mendekodenya, dan menyimpannya sebagai file .wav:

# Decode the base64 audio data
audio_bytes = base64.b64decode(output_message.additional_kwargs['audio']['data'])

# Save the audio file
with open("output.wav", "wb") as f:
    f.write(audio_bytes)
print("Audio saved as output.wav")

Sekarang Anda dapat memutar file .wav ini di komputer lokal menggunakan pemutar media apa pun. Jadi sekarang, saat Anda memanggil model, ia tidak hanya menghasilkan respons teks tetapi juga file audio yang mengucapkan respons tersebut.

Kasus Penggunaan Lanjutan gpt-4o-audio-preview

Di bagian ini, saya akan membahas cara mengikat alat ke model gpt-4o-audio-preview, menangani alur kerja yang lebih kompleks, dan bahkan merangkai beberapa langkah untuk membuat solusi yang sepenuhnya otomatis. Jika Anda ingin membangun asisten suara yang tidak hanya menyalin audio tetapi juga mengambil informasi dari sumber eksternal, bagian ini akan membantu.

Pemanggilan alat

Mari mulai dengan pemanggilan alat. Ini adalah mengajarkan model AI Anda cara menggunakan alat atau fungsi eksternal untuk meningkatkan kemampuannya. Alih-alih hanya memproses teks atau audio, model dapat melakukan tugas tambahan seperti mengambil data dari API, melakukan perhitungan, atau bahkan melihat informasi cuaca.

Model gpt-4o-audio-preview dari OpenAI dapat dikombinasikan dengan alat dan fungsi lain menggunakan metode bind_tools dari LangChain. Dengan metode ini, Anda dapat membuat alur kerja yang mulus di mana model memutuskan kapan dan bagaimana menggunakan alat yang Anda sediakan.

Saya akan memandu Anda melalui contoh praktis mengikat alat ke model. Dalam hal ini, kita akan mengikat alat yang mengambil cuaca.

Pertama, kita mendefinisikan model Pydantic yang merepresentasikan alat yang ingin digunakan. Lalu, kita mengikat alat itu ke model gpt-4o-audio-preview agar bisa dipanggil saat diperlukan. Untuk ini, Anda memerlukan kunci API dari OpenWeatherMap.

import requests
from pydantic import BaseModel, Field

# Define a tool schema using Pydantic
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&APPID={API_KEY}&units=metric"      
       response = requests.get(base_url)      
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           # Print the status code and response for debugging
           print(f"Error: {response.status_code}, {response.text}")
           return f"Could not fetch the weather for {self.location}."

# Example usage
weather_tool = GetWeather(location="Edinburgh, GB")  # Using city name and country code
ai_msg = weather_tool.fetch_weather()
print(ai_msg)

Mari lihat apa yang terjadi:

• Mendefinisikan alat: Kita mendefinisikan alat bernama GetWeather, yang menerima lokasi sebagai input dan mengembalikan cuaca terkini untuk lokasi tersebut menggunakan API OpenWeatherMap.
• Mengambil cuaca di Edinburgh: Kali ini, kita mengambil cuaca untuk Edinburgh, UK.
• Data cuaca waktu nyata: Alat mengambil data cuaca waktu nyata menggunakan API eksternal dan mengembalikannya.

Dalam contoh ini, saya ingin mengetahui cuaca di Edinburgh. Saat saya menjalankannya, saya mendapatkan keluaran: The weather in Edinburgh, GB is broken clouds with a temperature of 13.48°C.

Merangkai tugas: Membangun alur kerja multi-langkah

Dengan merangkai tugas, Anda dapat membuat alur kerja multi-langkah yang menggabungkan beberapa alat dan panggilan model untuk menangani permintaan yang kompleks. Bayangkan skenario di mana Anda ingin asisten Anda menyalin audio kemudian melakukan tindakan untuk lokasi yang disebutkan dalam audio. Dalam contoh ini, kita akan merangkai tugas transkripsi audio dengan pencarian cuaca berdasarkan lokasi yang ditranskripsi.

import base64
import requests
from pydantic import BaseModel, Field
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Define the tool schema for fetching weather
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&appid={API_KEY}&units=metric"       
       response = requests.get(base_url)
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           return f"Could not fetch the weather for {self.location}."

# Instantiate the LLM model
llm = ChatOpenAI(
   model="gpt-4o-audio-preview"
)
# Function to handle audio transcription using the LLM
def audio_to_text(audio_b64: str) -> str:
   # Define the message to send for transcription
   messages = [
       (
           "human",
           [
               {"type": "text", "text": "Transcribe the following:"},
               {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
           ],
       )
   ]
   # Invoke the model and get the transcription
   output_message = llm.invoke(messages)
   # Return the transcription from the model's output
   return output_message.content

# Create a prompt template for transcription and weather lookup
prompt = ChatPromptTemplate.from_messages(
   [
       ("system", "You are an assistant that transcribes audio and fetches weather information."),
       ("human", "Transcribe the following and tell me the weather in the location mentioned in the audio."),
   ]
)

# Bind the tool to the model
llm_with_tools = llm.bind_tools([GetWeather])

# Chain the transcription and weather tool
chain = prompt | llm_with_tools

# Read and encode the audio file in base64
audio_file = "weather_input.wav" #Replace with your audio file
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Transcribe the audio to get the location
transcribed_location = audio_to_text(audio_b64)

# Print the transcription result for debugging
print(f"Transcribed location: {transcribed_location}")

# Check if transcription returned a valid result
if transcribed_location:
   # Fetch weather for the transcribed location
   weather_tool = GetWeather(location=transcribed_location)
   weather_result = weather_tool.fetch_weather()
   print(f"Weather result: {weather_result}")
else:
   print("No valid location was transcribed from the audio.")

Mari kita uraikan kodenya:

• Transkripsi audio: Pengguna memberikan input audio (dienkode dalam base64). Audio ini dikirim ke model, yang kemudian menyalin isinya. Misalnya, transkripsi dapat berbunyi "Edinburgh".
• Pencarian cuaca: Setelah menyalin audio dan menentukan lokasi, model kemudian memanggil alat GetWeather untuk mengambil cuaca untuk lokasi tersebut.
• Alur kerja otomatis penuh: Penyiapan ini menciptakan alur kerja multi-langkah otomatis di mana model terlebih dahulu memahami apa yang diucapkan dalam audio (menyalinnya) lalu bertindak berdasarkan informasi tersebut dengan mengambil data cuaca yang relevan.

Untuk contoh ini, saya memberikan file audio ke model di mana saya mengatakan: “Edinburgh”. Ini keluaran yang saya dapatkan:Transcribed location: Edinburgh

Weather result: The weather in Edinburgh is broken clouds with a temperature of 13.47°C.

Fine-tuning gpt-4o-audio-preview

Dalam beberapa kasus, Anda mungkin ingin melakukan fine-tune model untuk menangani tugas spesifik dengan lebih efektif. Misalnya, jika Anda membangun aplikasi yang menyalin audio medis, Anda mungkin ingin model memiliki pemahaman mendalam tentang istilah dan jargon medis. OpenAI memungkinkan Anda melakukan fine-tune model dengan melatihnya pada dataset kustom.

Mari lihat caranya:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the fine-tuned audio-capable model
fine_tuned_model = ChatOpenAI(
    temperature=0,
    model="ft:gpt-4o-audio-preview:your-organization::model-id"
)

# Step 2: Capture and encode the input audio file (medical report)
audio_file = "medical_report.wav"
with open(audio_file, "rb") as audio_file:
    audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription request
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Please transcribe this medical report audio."},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Step 4: Invoke the fine-tuned model to transcribe the audio
result = fine_tuned_model.invoke(messages)

# Step 5: Extract and print the transcribed text from the response
transcription = result.content  # This contains the transcription
print(f"Transcription: {transcription}")

# Debugging: Print the full structure of the additional_kwargs for inspection
print(result.additional_kwargs)

Ini menggunakan model yang di-fine-tune secara khusus untuk menangani audio medis, tetapi Anda juga dapat melakukan fine-tune model untuk kasus penggunaan lain, seperti transkripsi legal, rekaman layanan pelanggan, atau pengeditan podcast. 

Contoh Praktis: Membangun Asisten Berkemampuan Suara

Terakhir, mari lihat contoh praktis di mana kita membangun asisten berkemampuan suara yang mendengarkan pertanyaan pengguna melalui audio, menghasilkan jawaban, dan membalas kembali menggunakan audio. 

Rincian alur kerja

Ini alur kerja yang akan kita ikuti:

1. Pengguna berbicara ke mikrofon, dan audio direkam.
2. Model menyalin audio tersebut.
3. Transkripsi diproses untuk menghasilkan jawaban.
4. Model kemudian menghasilkan respons audio yang dapat diputar kembali kepada pengguna.

Implementasi

Mari lihat cara mengodainya:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the audio-capable model with configuration for generating audio
llm = ChatOpenAI(
   model="gpt-4o-audio-preview",
   temperature=0,
   model_kwargs={
       "modalities": ["text", "audio"],  # Enable both text and audio modalities
       "audio": {"voice": "alloy", "format": "wav"},  # Set the desired voice and output format
   }
)

# Step 2: Capture and encode the audio 
audio_file = "math_joke_audio.wav" #You can replace your audio file here
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription and audio response
messages = [
   (
       "human",
       [
           {"type": "text", "text": "Answer the question."},
           {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
       ],
   )
]

# Step 4: Invoke the model to transcribe the audio and generate a response
result = llm.invoke(messages)

# Step 5: Extract the audio response
audio_response = result.additional_kwargs.get('audio', {}).get('data')  # Safely check if audio exists

# Step 6: Save the audio response to a file if it exists
if audio_response:
   # Decode the base64 audio data and save it as a .wav file
   audio_bytes = base64.b64decode(audio_response)
   with open("response.wav", "wb") as f:
       f.write(audio_bytes)
   print("Audio response saved as 'response.wav'")
else:
   print("No audio response available")

Cara kerjanya

Mari kita uraikan cara kerjanya:

• Input audio: Pengguna memberikan input audio, seperti mengajukan pertanyaan (misalnya, "Ceritakan lelucon matematika"). Audio dienkode ke base64 dan diberikan ke asisten.
• Transkripsi: Model menyalin audio menjadi teks. Transkripsi ini tersedia jika Anda ingin mencatat atau menampilkannya.
• Pembuatan respons: Berdasarkan transkripsi, model menghasilkan respons menggunakan pengetahuannya (misalnya, "Ibu kota Prancis adalah Paris")
• Output audio: Respons dikonversi ke format audio. Audio disimpan sebagai file (misalnya, "response.wav"), yang dapat diputar kembali kepada pengguna menggunakan pemutar audio apa pun.

Asisten ini dibuat untuk berbicara dengan audio. Ia mendengarkan suara pengguna, memahami pertanyaan, lalu menjawab dengan suaranya sendiri. Penyiapan ini sangat cocok untuk membangun asisten suara sederhana, dan Anda dapat membuatnya lebih canggih nanti jika diperlukan!

Kesimpulan

Dalam tutorial ini, kita mengeksplorasi model gpt-4o-audio-preview dari OpenAI, mencakup penyiapan, input/output audio, kasus penggunaan lanjutan, dan bahkan membangun asisten suara dasar. Model yang kuat ini memberikan fondasi tangguh untuk membuat aplikasi berkemampuan audio di dunia nyata.

Jika Anda ingin meningkatkan pengetahuan praktis LangChain, saya merekomendasikan blog berikut:

• Cara Membangun Antarmuka Pengguna untuk Aplikasi AI Menggunakan Streamlit dan LangChain
• RAG Dengan Llama 3.1 8B, Ollama, dan Langchain: Tutorial
• Membangun Agen LangChain untuk Mengotomatiskan Tugas di Python