Blog

Cara Menggunakan API OpenAI WebSocket Mode?

Ashley Innocent

Ashley Innocent

24 February 2026

Cara Menggunakan API OpenAI WebSocket Mode?

Apidog untuk Perusahaan

Penerapan On-Premises

SSO & RBAC

Sesuai SOC 2

Jelajahi Apidog Enterprise

TL;DR

OpenAI menawarkan dua mode API WebSocket untuk kasus penggunaan yang berbeda: mode WebSocket Responses API untuk alur kerja agen dengan banyak panggilan alat (hingga 40% lebih cepat untuk 20+ panggilan alat), dan Realtime API untuk aplikasi suara dan audio latensi rendah. Keduanya menggunakan koneksi WebSocket persisten alih-alih permintaan HTTP tanpa status, mengurangi latensi dengan menghilangkan biaya koneksi yang berulang dan memungkinkan interaksi berbasis peristiwa, serta berstatus.

Pendahuluan

API OpenAI telah berkembang melampaui pola permintaan-respons sederhana. Untuk aplikasi yang membutuhkan panggilan alat yang cepat atau streaming audio real-time, model HTTP tradisional menciptakan biaya tambahan yang tidak perlu. Setiap permintaan baru memerlukan pengaturan koneksi, autentikasi, dan transmisi status—bahkan ketika Anda melanjutkan percakapan yang sama.

OpenAI's WebSocket API memecahkan masalah ini dengan mempertahankan koneksi dua arah yang persisten. Untuk alur kerja agen dengan 20+ panggilan alat berurutan, ini berarti eksekusi ujung-ke-ujung kira-kira 40% lebih cepat. Untuk aplikasi suara, ini memungkinkan percakapan yang alami dan dapat diinterupsi dengan latensi di bawah 500ms.

💡
Pengujian koneksi WebSocket secara tradisional memerlukan alat debugging yang kompleks. Antarmuka pengujian WebSocket Apidog memungkinkan Anda membuat koneksi, mengirim peristiwa, dan memantau respons secara real-time—penting untuk memvalidasi integrasi OpenAI WebSocket sebelum penyebaran produksi.
button

Panduan ini mencakup kedua mode WebSocket OpenAI: Responses API untuk alur kerja agen yang banyak menggunakan alat, dan Realtime API untuk streaming audio. Anda akan mempelajari kapan menggunakan masing-masing, cara mengimplementasikannya, dan cara mengujinya secara efektif.

Apa itu OpenAI WebSocket API?

OpenAI WebSocket API menyediakan mekanisme transportasi alternatif untuk HTTP untuk berinteraksi dengan model bahasa OpenAI. Alih-alih membuat koneksi baru untuk setiap panggilan API, WebSocket membangun satu koneksi jangka panjang yang tetap terbuka selama sesi Anda.

Karakteristik Utama

Koneksi Persisten: Setelah dibuat, koneksi WebSocket tetap terbuka hingga ditutup secara eksplisit, menghilangkan biaya koneksi per permintaan.

Komunikasi Dua Arah: Baik klien maupun server dapat mengirim pesan kapan saja, memungkinkan arsitektur berbasis peristiwa yang sesungguhnya.

Sesi Berstatus: Server mempertahankan konteks untuk koneksi saat ini, memungkinkan Anda merujuk respons sebelumnya tanpa mengirim ulang riwayat percakapan lengkap.

Model Berbasis Peristiwa: Komunikasi terjadi melalui peristiwa diskrit (pesan JSON) daripada pasangan permintaan-respons.

Dasar-dasar Protokol WebSocket

Koneksi WebSocket dimulai dengan permintaan upgrade HTTP, kemudian beralih ke protokol WebSocket. Untuk OpenAI, Anda akan terhubung ke titik akhir seperti:

Skema wss:// menunjukkan koneksi WebSocket aman (analog dengan HTTPS untuk HTTP).

Dua Mode WebSocket Dijelaskan

OpenAI menyediakan dua mode WebSocket yang berbeda, masing-masing dioptimalkan untuk kasus penggunaan yang berbeda.

Mode WebSocket Responses API

Responses API mendukung koneksi WebSocket untuk alur kerja agen di mana Anda perlu melakukan banyak panggilan alat secara berurutan. Mode ini dirancang untuk asisten pengkodean, sistem orkestrasi, dan agen otonom yang berulang kali memanggil alat untuk menyelesaikan tugas-tugas kompleks.

Cara Kerjanya:

Pada koneksi WebSocket aktif, layanan mempertahankan satu status respons sebelumnya dalam cache dalam memori lokal koneksi (respons paling baru). Ketika Anda melanjutkan giliran, Anda hanya mengirim:

Server menggunakan kembali status yang di-cache alih-alih memproses ulang seluruh riwayat percakapan.

Manfaat Kinerja:

Untuk alur kerja dengan 20+ panggilan alat, OpenAI melaporkan eksekusi ujung-ke-ujung hingga 40% lebih cepat dibandingkan dengan HTTP. Ini berasal dari:

Kompatibilitas:

Mode WebSocket berfungsi dengan opsi Zero Data Retention (ZDR) dan store=false, membuatnya cocok untuk aplikasi yang sensitif terhadap privasi.

Mode WebSocket Realtime API

Realtime API menyediakan kemampuan audio streaming latensi rendah untuk aplikasi berbasis suara. Ini memungkinkan interaksi speech-to-speech di mana model dapat menanggapi input audio dengan output audio, menangani interupsi secara alami.

Cara Kerjanya:

Realtime API menggunakan WebSocket untuk membuat sesi berstatus yang digerakkan oleh peristiwa. Anda mengalirkan potongan audio ke API, dan API mengalirkan kembali transkripsi dan respons audio yang dihasilkan. Koneksi mendukung:

Fitur Utama:

Voice Activity Detection (VAD): API mencakup VAD semantik yang memahami kapan pengguna selesai berbicara versus hanya berhenti sebentar. Ini menciptakan alur percakapan yang lebih alami.

Kemampuan Multimodal: Akses langsung ke kemampuan multimodal asli GPT-4o, memproses audio dan teks dalam model terpadu.

Latensi Rendah: Dirancang untuk latensi di bawah 500ms untuk interaksi suara, cocok untuk percakapan real-time.

WebSocket vs HTTP: Perbandingan Kinerja

Memilih antara WebSocket dan HTTP tergantung pada karakteristik aplikasi Anda. Berikut adalah kapan setiap protokol unggul.

WebSocket vs HTTP

Kapan WebSocket Mengungguli HTTP

Volume Panggilan Alat yang Tinggi:
Jika alur kerja Anda melakukan 10+ panggilan alat berurutan, koneksi persisten WebSocket menghilangkan biaya pengaturan berulang. Setiap permintaan HTTP memerlukan:

WebSocket melakukan ini sekali, lalu menggunakan kembali koneksi.

Aplikasi Sensitif Latensi:
Untuk aplikasi suara atau obrolan real-time di mana setiap milidetik berarti, koneksi persisten dan kemampuan streaming WebSocket secara signifikan mengurangi latensi yang dirasakan.

Pembaruan yang Diprakarsai Server:
WebSocket memungkinkan server untuk mendorong data ke klien tanpa polling. Untuk tugas agen yang berjalan lama, server dapat mengirim pembaruan kemajuan saat peristiwa terjadi.

Kapan HTTP Cukup

Permintaan-Respons Sederhana:
Untuk panggilan API satu kali atau alur kerja dengan 1-2 panggilan alat, HTTP lebih sederhana untuk diimplementasikan dan di-debug. Sebagian besar pengembang akrab dengan klien HTTP, dan infrastruktur (penyeimbang beban, proxy) menangani HTTP dengan baik.

Operasi Tanpa Status:
Jika Anda tidak perlu mempertahankan status sesi antar permintaan, sifat HTTP yang tanpa status sebenarnya merupakan keuntungan—tidak diperlukan manajemen koneksi.

Batasan Infrastruktur:
Beberapa lingkungan penyebaran (fungsi tanpa server, proxy tertentu) tidak mendukung koneksi WebSocket jangka panjang. HTTP berfungsi secara universal.

Metrik Kinerja

Berdasarkan dokumentasi OpenAI dan pengujian komunitas:

MetrikHTTPWebSocket (Responses API)WebSocket (Realtime API)
Pengaturan KoneksiSetiap permintaan (~100-300ms)Sekali (~100-300ms)Sekali (~100-300ms)
Alur Kerja 20+ Panggilan AlatDasar~40% lebih cepatT/A
Latensi Bolak-balik SuaraT/A (tidak dirancang untuk ini)T/A<500ms
Overhead MemoriRendah (tanpa status)Sedang (status yang di-cache)Sedang-Tinggi (status sesi)
Kompleksitas ImplementasiRendahSedangSedang-Tinggi

Cara Menggunakan Mode WebSocket Responses API

Mari kita implementasikan koneksi WebSocket ke Responses API untuk alur kerja agen.

Prasyarat

Pengaturan Koneksi

Contoh Node.js:

const WebSocket = require('ws');

// Connect to Responses API WebSocket endpoint
const ws = new WebSocket('wss://api.openai.com/v1/responses', {
  headers: {
    'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
    'OpenAI-Beta': 'responses-api=v1'
  }
});

ws.on('open', () => {
  console.log('Connected to OpenAI Responses API');

  // Send initial request
  const initialMessage = {
    model: 'gpt-4o',
    messages: [
      { role: 'user', content: 'Help me analyze this codebase and suggest improvements.' }
    ],
    tools: [
      {
        type: 'function',
        function: {
          name: 'read_file',
          description: 'Read contents of a file',
          parameters: {
            type: 'object',
            properties: {
              path: { type: 'string', description: 'File path to read' }
            },
            required: ['path']
          }
        }
      },
      {
        type: 'function',
        function: {
          name: 'search_code',
          description: 'Search for code patterns',
          parameters: {
            type: 'object',
            properties: {
              pattern: { type: 'string', description: 'Regex pattern to search' }
            },
            required: ['pattern']
          }
        }
      }
    ]
  };

  ws.send(JSON.stringify(initialMessage));
});

ws.on('message', (data) => {
  const response = JSON.parse(data);
  console.log('Received:', response);

  // Check if model wants to call tools
  if (response.choices[0].finish_reason === 'tool_calls') {
    const toolCalls = response.choices[0].message.tool_calls;

    // Execute tools (simplified)
    const toolResults = toolCalls.map(call => ({
      tool_call_id: call.id,
      output: executeToolLocally(call.function.name, call.function.arguments)
    }));

    // Continue the conversation with tool results
    const continuation = {
      previous_response_id: response.id, // Reference previous response
      input: toolResults
    };

    ws.send(JSON.stringify(continuation));
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});

ws.on('close', () => {
  console.log('Connection closed');
});

function executeToolLocally(name, args) {
  // Your tool execution logic
  if (name === 'read_file') {
    const { path } = JSON.parse(args);
    return fs.readFileSync(path, 'utf-8');
  }
  // ... other tools
}

Contoh Python:

import websocket
import json
import os

def on_message(ws, message):
    response = json.loads(message)
    print(f"Received: {response}")

    # Handle tool calls
    if response['choices'][0]['finish_reason'] == 'tool_calls':
        tool_calls = response['choices'][0]['message']['tool_calls']

        # Execute tools
        tool_results = []
        for call in tool_calls:
            result = execute_tool(call['function']['name'],
                                 json.loads(call['function']['arguments']))
            tool_results.append({
                'tool_call_id': call['id'],
                'output': result
            })

        # Send continuation with only new input + previous_response_id
        continuation = {
            'previous_response_id': response['id'],
            'input': tool_results
        }
        ws.send(json.dumps(continuation))

def on_error(ws, error):
    print(f"Error: {error}")

def on_close(ws, close_status_code, close_msg):
    print("Connection closed")

def on_open(ws):
    print("Connected to OpenAI Responses API")

    # Send initial request
    initial_message = {
        'model': 'gpt-4o',
        'messages': [
            {'role': 'user', 'content': 'Analyze this codebase and suggest improvements.'}
        ],
        'tools': [
            {
                'type': 'function',
                'function': {
                    'name': 'read_file',
                    'description': 'Read file contents',
                    'parameters': {
                        'type': 'object',
                        'properties': {
                            'path': {'type': 'string'}
                        },
                        'required': ['path']
                    }
                }
            }
        ]
    }
    ws.send(json.dumps(initial_message))

def execute_tool(name, args):
    if name == 'read_file':
        with open(args['path'], 'r') as f:
            return f.read()
    # ... other tools

# Create WebSocket connection
ws = websocket.WebSocketApp(
    "wss://api.openai.com/v1/responses",
    header={
        "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
        "OpenAI-Beta": "responses-api=v1"
    },
    on_open=on_open,
    on_message=on_message,
    on_error=on_error,
    on_close=on_close
)

ws.run_forever()

Detail Implementasi Utama

Manajemen Status:
Perbedaan kritis dari HTTP adalah penggunaan previous_response_id dalam kelanjutan. Ini memberi tahu API untuk menggunakan kembali status yang di-cache dari respons terakhir.

Kelanjutan Hanya Input:
Saat melanjutkan giliran, kirim hanya:

Jangan kirim ulang seluruh array messages—server sudah memiliki konteks tersebut.

Zero Data Retention:
Untuk menggunakan ZDR dengan mode WebSocket, sertakan store: false dalam permintaan awal Anda.

Cara Menggunakan Mode WebSocket Realtime API

Realtime API memungkinkan interaksi suara latensi rendah. Berikut cara mengimplementasikannya.

Prasyarat

Pengaturan Koneksi

Contoh JavaScript (Browser):

// Connect to Realtime API
const ws = new WebSocket(
  `wss://api.openai.com/v1/realtime?model=gpt-realtime`,
  ['realtime', 'openai-insecure-api-key.' + process.env.OPENAI_API_KEY]
);

ws.addEventListener('open', () => {
  console.log('Connected to Realtime API');

  // Configure session
  ws.send(JSON.stringify({
    type: 'session.update',
    session: {
      modalities: ['text', 'audio'],
      voice: 'alloy',
      input_audio_format: 'pcm16',
      output_audio_format: 'pcm16',
      turn_detection: {
        type: 'server_vad', // or 'semantic_vad' for smarter detection
        threshold: 0.5,
        prefix_padding_ms: 300,
        silence_duration_ms: 500
      }
    }
  }));
});

ws.addEventListener('message', (event) => {
  const message = JSON.parse(event.data);

  switch (message.type) {
    case 'session.created':
      console.log('Session created:', message.session);
      break;

    case 'conversation.item.created':
      console.log('New item:', message.item);
      break;

    case 'response.audio.delta':
      // Received audio chunk - play it
      const audioChunk = base64ToArrayBuffer(message.delta);
      playAudioChunk(audioChunk);
      break;

    case 'response.audio_transcript.delta':
      // Received transcript chunk
      console.log('Transcript:', message.delta);
      break;

    case 'input_audio_buffer.speech_started':
      console.log('User started speaking');
      break;

    case 'input_audio_buffer.speech_stopped':
      console.log('User stopped speaking');
      break;

    case 'error':
      console.error('API error:', message.error);
      break;
  }
});

// Send audio from microphone
async function streamMicrophoneToAPI() {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const audioContext = new AudioContext({ sampleRate: 24000 });
  const source = audioContext.createMediaStreamSource(stream);
  const processor = audioContext.createScriptProcessor(4096, 1, 1);

  processor.onaudioprocess = (e) => {
    const inputData = e.inputBuffer.getChannelData(0);

    // Convert Float32 to Int16 PCM
    const pcmData = new Int16Array(inputData.length);
    for (let i = 0; i < inputData.length; i++) {
      pcmData[i] = Math.max(-32768, Math.min(32767, inputData[i] * 32768));
    }

    // Send to API
    ws.send(JSON.stringify({
      type: 'input_audio_buffer.append',
      audio: arrayBufferToBase64(pcmData.buffer)
    }));
  };

  source.connect(processor);
  processor.connect(audioContext.destination);
}

// Send text input
function sendTextMessage(text) {
  ws.send(JSON.stringify({
    type: 'conversation.item.create',
    item: {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: text }
      ]
    }
  }));

  // Request response generation
  ws.send(JSON.stringify({
    type: 'response.create'
  }));
}

function playAudioChunk(arrayBuffer) {
  const audioContext = new AudioContext({ sampleRate: 24000 });
  audioContext.decodeAudioData(arrayBuffer, (buffer) => {
    const source = audioContext.createBufferSource();
    source.buffer = buffer;
    source.connect(audioContext.destination);
    source.start();
  });
}

Contoh Python:

import websocket
import json
import base64
import pyaudio

# Audio configuration
RATE = 24000
CHUNK = 4096
FORMAT = pyaudio.paInt16
CHANNELS = 1

audio = pyaudio.PyAudio()

def on_open(ws):
    print("Connected to Realtime API")

    # Configure session
    ws.send(json.dumps({
        'type': 'session.update',
        'session': {
            'modalities': ['text', 'audio'],
            'voice': 'alloy',
            'input_audio_format': 'pcm16',
            'output_audio_format': 'pcm16',
            'turn_detection': {
                'type': 'server_vad',
                'threshold': 0.5,
                'silence_duration_ms': 500
            }
        }
    }))

    # Start streaming microphone
    stream_microphone(ws)

def on_message(ws, message):
    data = json.loads(message)

    if data['type'] == 'response.audio.delta':
        # Decode and play audio
        audio_chunk = base64.b64decode(data['delta'])
        play_audio(audio_chunk)

    elif data['type'] == 'response.audio_transcript.delta':
        print(f"Transcript: {data['delta']}", end='', flush=True)

    elif data['type'] == 'input_audio_buffer.speech_started':
        print("\n[User speaking...]")

    elif data['type'] == 'error':
        print(f"Error: {data['error']}")

def stream_microphone(ws):
    stream = audio.open(
        format=FORMAT,
        channels=CHANNELS,
        rate=RATE,
        input=True,
        frames_per_buffer=CHUNK
    )

    def audio_thread():
        while True:
            audio_data = stream.read(CHUNK)
            ws.send(json.dumps({
                'type': 'input_audio_buffer.append',
                'audio': base64.b64encode(audio_data).decode('utf-8')
            }))

    import threading
    threading.Thread(target=audio_thread, daemon=True).start()

def play_audio(audio_chunk):
    stream = audio.open(
        format=FORMAT,
        channels=CHANNELS,
        rate=RATE,
        output=True
    )
    stream.write(audio_chunk)
    stream.stop_stream()
    stream.close()

# Create WebSocket connection
ws = websocket.WebSocketApp(
    f"wss://api.openai.com/v1/realtime?model=gpt-realtime",
    header={
        "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"
    },
    on_open=on_open,
    on_message=on_message
)

ws.run_forever()

Detail Implementasi Utama

Tipe Peristiwa:

Realtime API menggunakan komunikasi berbasis peristiwa. Peristiwa umum:

Klien → Server:

Server → Klien:

Deteksi Aktivitas Suara:

Pilih antara dua mode VAD:

server_vad: Deteksi aktivitas suara dasar berdasarkan volume audio dan durasi hening.

semantic_vad: Deteksi yang lebih cerdas yang memahami jeda alami vs. penyelesaian giliran. Gunakan ini untuk percakapan yang lebih alami di mana pengguna mungkin berhenti sejenak di tengah pemikiran.

Menguji Koneksi WebSocket dengan Apidog

Pengujian API WebSocket berbeda dari pengujian HTTP—Anda perlu mempertahankan koneksi, mengirim peristiwa, dan memantau aliran pesan dua arah. Apidog menyediakan kemampuan pengujian WebSocket khusus.

Antarmuka Desain Web Apidog

Menyiapkan Tes WebSocket di Apidog

Langkah 1: Buat Permintaan WebSocket

Di Apidog, buat permintaan baru dan pilih "WebSocket" sebagai protokol. Masukkan URL koneksi Anda:

Buat Permintaan WebSocket di Apidog
wss://api.openai.com/v1/responses

Langkah 2: Konfigurasi Header

Tambahkan header autentikasi:

Authorization: Bearer YOUR_OPENAI_API_KEY
OpenAI-Beta: responses-api=v1

Untuk Realtime API, Anda juga dapat menggunakan autentikasi berbasis URL:

wss://api.openai.com/v1/realtime?model=gpt-realtime

Dengan kunci API di header subprotokol.

Langkah 3: Bangun Koneksi

Klik "Connect" untuk membangun koneksi WebSocket. Apidog menunjukkan:

Langkah 4: Kirim Peristiwa

Gunakan pembuat pesan Apidog untuk mengirim peristiwa JSON. Untuk Responses API:

{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "What's the weather in San Francisco?"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {
          "type": "object",
          "properties": {
            "location": { "type": "string" }
          }
        }
      }
    }
  ]
}

Langkah 5: Pantau Respons

Apidog menampilkan:

Menguji Kelanjutan

Untuk menguji pola kelanjutan dengan previous_response_id:

  1. Kirim pesan awal, catat response.id dalam respons
  2. Kirim kelanjutan dengan hanya input baru:
{
  "previous_response_id": "resp_abc123",
  "input": [
    {
      "tool_call_id": "call_xyz789",
      "output": "{\"temperature\": 72, \"conditions\": \"sunny\"}"
    }
  ]
}
  1. Amati latensi yang berkurang dibandingkan dengan mengirim ulang konteks lengkap

Menguji Realtime API

Untuk Realtime API, Apidog memungkinkan Anda:

Ini sangat berguna untuk men-debug mengapa asisten suara Anda mungkin memotong pengguna atau tidak mendeteksi ucapan dengan benar.

Variabel Lingkungan

Simpan kunci API dengan aman menggunakan variabel lingkungan Apidog:

{{OPENAI_API_KEY}}

Ini memungkinkan Anda beralih antara kunci pengembangan dan produksi tanpa mengedit permintaan.

Kasus Penggunaan Dunia Nyata

Mari kita jelajahi skenario praktis di mana mode WebSocket OpenAI unggul.

Kasus Penggunaan 1: Agen Pengkodean Otonom

Skenario: Asisten pengkodean yang menganalisis basis kode, mengidentifikasi masalah, dan membuat perbaikan secara otonom.

Mengapa Responses API WebSocket:

Pola Implementasi:

// Initial task
ws.send({ messages: [{ role: 'user', content: 'Audit security vulnerabilities' }], tools: [...] })

// First response: model calls read_file
ws.on('message', (resp1) => {
  ws.send({ previous_response_id: resp1.id, input: [tool_result_1] })
})

// Second response: model calls search_code
ws.on('message', (resp2) => {
  ws.send({ previous_response_id: resp2.id, input: [tool_result_2] })
})

// Continue for 20+ iterations...

Kasus Penggunaan 2: Bot Layanan Pelanggan Suara

Skenario: Bot dukungan telepon yang menangani pertanyaan pelanggan dengan alur percakapan yang alami.

Mengapa Realtime API WebSocket:

Pola Implementasi:

// Stream phone audio to API
phoneSystem.on('audio', (chunk) => {
  ws.send({
    type: 'input_audio_buffer.append',
    audio: base64Encode(chunk)
  })
})

// Play AI responses immediately
ws.on('message', (event) => {
  if (event.type === 'response.audio.delta') {
    phoneSystem.playAudio(base64Decode(event.delta))
  }
})

Memecahkan Masalah Umum

Koneksi Gagal Dibuat

Gejala: Koneksi WebSocket tidak pernah terbuka, peristiwa penutupan segera.

Penyebab Umum:

  1. Kunci API tidak valid - Periksa kembali header Authorization Anda
  2. Header beta hilang - Responses API memerlukan OpenAI-Beta: responses-api=v1
  3. Pembatasan jaringan - Beberapa jaringan perusahaan memblokir WebSocket
  4. URL salah - Verifikasi wss:// (bukan ws://) dan jalur endpoint

Solusi:
Gunakan Apidog untuk menguji koneksi dengan pesan kesalahan terperinci. Inspektur permintaan menunjukkan dengan tepat header mana yang dikirim, membuatnya mudah untuk menemukan kunci API yang hilang atau salah.

Kode Debugging:

ws.on('error', (error) => {
  console.error('Connection error:', error);
});

ws.on('close', (code, reason) => {
  console.log(`Closed with code ${code}: ${reason}`);
  // Common codes:
  // 1006: Abnormal closure (often auth issues)
  // 1008: Policy violation (invalid headers)
});

Latensi Tinggi Meskipun Menggunakan WebSocket

Gejala: Koneksi WebSocket berfungsi tetapi tidak lebih cepat dari HTTP.

Penyebab Umum:

  1. Tidak menggunakan previous_response_id - Anda mengirim ulang konteks lengkap
  2. Mulai dingin (cold start) - Permintaan pertama pada koneksi baru lebih lambat
  3. Latensi jaringan - Jarak geografis ke server API
  4. Payload besar - Mengirim data yang tidak perlu dalam kelanjutan

Solusi:
Verifikasi Anda hanya mengirim input baru dalam kelanjutan:

// SALAH - mengirim konteks lengkap setiap saat
ws.send({
  messages: [...allPreviousMessages, newMessage],
  tools: [...]
})

// BENAR - mereferensikan status yang di-cache
ws.send({
  previous_response_id: lastResponse.id,
  input: [newMessage]
})

Kebocoran Memori dalam Koneksi yang Berjalan Lama

Gejala: Memori aplikasi tumbuh seiring waktu dengan koneksi persisten.

Penyebab Umum:

  1. Pendengar peristiwa tidak dihapus - Mengakumulasi pendengar saat penyambungan ulang
  2. Buffer audio tidak dilepaskan - Menyimpan referensi ke audio yang diputar
  3. Riwayat pesan tumbuh - Menyimpan semua pesan yang diterima

Solusi:

// Bersihkan dan sambungkan ulang pendengar peristiwa
function cleanupAndReconnect(ws) {
  ws.removeAllListeners();
  ws.close();

  const newWs = createConnection();
  return newWs;
}

// Lepaskan buffer audio setelah diputar
function playAndRelease(audioBuffer) {
  const source = audioContext.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioContext.destination);
  source.start();

  source.onended = () => {
    source.disconnect();
    // Buffer will be garbage collected
  };
}

// Batasi riwayat pesan
const messageHistory = [];
const MAX_HISTORY = 100;

ws.on('message', (data) => {
  messageHistory.push(data);
  if (messageHistory.length > MAX_HISTORY) {
    messageHistory.shift(); // Remove oldest
  }
});

Kesimpulan

Mode WebSocket API OpenAI membuka kemungkinan baru untuk aplikasi AI. Mode WebSocket Responses API memberikan eksekusi hingga 40% lebih cepat untuk alur kerja agen dengan banyak panggilan alat, membuatnya ideal untuk asisten pengkodean otonom dan sistem orkestrasi. Realtime API menyediakan latensi di bawah 500ms untuk aplikasi suara, memungkinkan percakapan yang alami dan dapat diinterupsi.

Memilih mode yang tepat tergantung pada kasus penggunaan Anda:

Sifat koneksi WebSocket yang persisten dan digerakkan oleh peristiwa memerlukan pendekatan pengujian yang berbeda dari HTTP. Uji API WebSocket OpenAI dengan klien WebSocket real-time Apidog—impor kunci API Anda, buat koneksi, kirim peristiwa, dan pantau respons dengan pencatatan terperinci. Cobalah secara gratis untuk memvalidasi integrasi Anda sebelum penyebaran produksi.

button

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh