Blog

Cách Sử Dụng API Chế Độ WebSocket của OpenAI?

Ashley Innocent

Ashley Innocent

24 tháng 2 2026

Cách Sử Dụng API Chế Độ WebSocket của OpenAI?

Apidog cho doanh nghiệp

Triển khai tại chỗ

SSO & RBAC

Tuân thủ SOC 2

Khám phá Apidog Enterprise

Tóm tắt

OpenAI cung cấp hai chế độ API WebSocket cho các trường hợp sử dụng khác nhau: chế độ WebSocket API Phản hồi cho các quy trình làm việc tự động với việc gọi công cụ nhiều (nhanh hơn tới 40% cho hơn 20 cuộc gọi công cụ), và API Thời gian thực cho các ứng dụng thoại và âm thanh có độ trễ thấp. Cả hai đều sử dụng kết nối WebSocket liên tục thay vì các yêu cầu HTTP phi trạng thái, giúp giảm độ trễ bằng cách loại bỏ chi phí thiết lập kết nối lặp lại và cho phép các tương tác theo sự kiện, có trạng thái.

Giới thiệu

API của OpenAI đã phát triển vượt ra ngoài các mẫu yêu cầu-phản hồi đơn giản. Đối với các ứng dụng yêu cầu gọi công cụ nhanh hoặc truyền phát âm thanh thời gian thực, mô hình HTTP truyền thống tạo ra chi phí không cần thiết. Mỗi yêu cầu mới đều cần thiết lập kết nối, xác thực và truyền trạng thái — ngay cả khi bạn đang tiếp tục cùng một cuộc hội thoại.

API WebSocket của OpenAI giải quyết vấn đề này bằng cách duy trì một kết nối hai chiều, liên tục. Đối với các quy trình làm việc tự động với hơn 20 cuộc gọi công cụ tuần tự, điều này giúp thực thi từ đầu đến cuối nhanh hơn khoảng 40%. Đối với các ứng dụng thoại, nó cho phép các cuộc trò chuyện tự nhiên, có khả năng bị gián đoạn với độ trễ dưới 500ms.

💡
Kiểm tra kết nối WebSocket truyền thống yêu cầu các công cụ gỡ lỗi phức tạp. Giao diện kiểm thử WebSocket của Apidog cho phép bạn thiết lập kết nối, gửi sự kiện và giám sát phản hồi trong thời gian thực — điều cần thiết để xác thực các tích hợp OpenAI WebSocket trước khi triển khai sản xuất.
button

Hướng dẫn này bao gồm cả hai chế độ WebSocket của OpenAI: API Phản hồi cho các quy trình làm việc của tác nhân nặng về công cụ và API Thời gian thực để truyền phát âm thanh. Bạn sẽ tìm hiểu khi nào nên sử dụng từng chế độ, cách triển khai chúng và cách kiểm tra chúng một cách hiệu quả.

API WebSocket của OpenAI là gì?

API WebSocket của OpenAI cung cấp một cơ chế truyền tải thay thế cho HTTP để tương tác với các mô hình ngôn ngữ của OpenAI. Thay vì tạo một kết nối mới cho mỗi cuộc gọi API, WebSocket thiết lập một kết nối duy nhất, tồn tại lâu dài, duy trì mở trong suốt phiên của bạn.

Đặc điểm chính

Kết nối liên tục: Khi đã được thiết lập, kết nối WebSocket vẫn mở cho đến khi được đóng rõ ràng, loại bỏ chi phí kết nối cho mỗi yêu cầu.

Giao tiếp hai chiều: Cả máy khách và máy chủ đều có thể gửi tin nhắn bất cứ lúc nào, cho phép các kiến trúc theo sự kiện thực sự.

Các phiên có trạng thái: Máy chủ duy trì ngữ cảnh cho kết nối hiện tại, cho phép bạn tham chiếu các phản hồi trước đó mà không cần gửi lại toàn bộ lịch sử cuộc trò chuyện.

Mô hình theo sự kiện: Giao tiếp diễn ra thông qua các sự kiện rời rạc (tin nhắn JSON) thay vì các cặp yêu cầu-phản hồi.

Kiến thức cơ bản về Giao thức WebSocket

Kết nối WebSocket bắt đầu bằng yêu cầu nâng cấp HTTP, sau đó chuyển sang giao thức WebSocket. Đối với OpenAI, bạn sẽ kết nối với các điểm cuối như:

Lược đồ wss:// cho biết một kết nối WebSocket bảo mật (tương tự như HTTPS cho HTTP).

Giải thích hai chế độ WebSocket

OpenAI cung cấp hai chế độ WebSocket riêng biệt, mỗi chế độ được tối ưu hóa cho các trường hợp sử dụng khác nhau.

Chế độ WebSocket API Phản hồi

API Phản hồi hỗ trợ các kết nối WebSocket cho các quy trình làm việc tự động nơi bạn cần thực hiện nhiều cuộc gọi công cụ tuần tự. Chế độ này được thiết kế cho các trợ lý mã hóa, hệ thống điều phối và tác nhân tự động liên tục gọi các công cụ để hoàn thành các tác vụ phức tạp.

Cách thức hoạt động:

Trên một kết nối WebSocket đang hoạt động, dịch vụ duy trì một trạng thái phản hồi trước đó trong bộ nhớ cache cục bộ của kết nối (phản hồi gần đây nhất). Khi bạn tiếp tục một lượt, bạn chỉ gửi:

Máy chủ sử dụng lại trạng thái được lưu trong bộ nhớ cache thay vì xử lý lại toàn bộ lịch sử cuộc trò chuyện.

Lợi ích hiệu suất:

Đối với các quy trình làm việc có hơn 20 cuộc gọi công cụ, OpenAI báo cáo thực thi từ đầu đến cuối nhanh hơn tới 40% so với HTTP. Điều này đến từ:

Khả năng tương thích:

Chế độ WebSocket hoạt động với cả Giữ lại dữ liệu bằng không (ZDR) và tùy chọn store=false, làm cho nó phù hợp cho các ứng dụng nhạy cảm về quyền riêng tư.

Chế độ WebSocket API Thời gian thực

API Thời gian thực cung cấp khả năng truyền tải âm thanh trực tuyến, độ trễ thấp cho các ứng dụng điều khiển bằng giọng nói. Nó cho phép các tương tác giọng nói-sang-giọng nói trong đó mô hình có thể phản hồi đầu vào âm thanh bằng đầu ra âm thanh, xử lý gián đoạn một cách tự nhiên.

Cách thức hoạt động:

API Thời gian thực sử dụng WebSocket để tạo một phiên có trạng thái, theo sự kiện. Bạn truyền các đoạn âm thanh đến API và nó truyền lại cả bản chép lời và phản hồi âm thanh được tạo. Kết nối hỗ trợ:

Các tính năng chính:

Phát hiện Hoạt động Giọng nói (VAD): API bao gồm VAD ngữ nghĩa hiểu khi người dùng đã nói xong so với việc chỉ tạm dừng. Điều này tạo ra luồng hội thoại tự nhiên hơn.

Khả năng đa phương thức: Truy cập trực tiếp vào khả năng đa phương thức gốc của GPT-4o, xử lý cả âm thanh và văn bản trong một mô hình thống nhất.

Độ trễ thấp: Được thiết kế cho độ trễ dưới 500ms cho các tương tác thoại, phù hợp cho các cuộc trò chuyện thời gian thực.

WebSocket và HTTP: So sánh hiệu suất

Việc lựa chọn giữa WebSocket và HTTP phụ thuộc vào đặc điểm ứng dụng của bạn. Dưới đây là khi mỗi giao thức vượt trội.

So sánh WebSocket và HTTP

Khi WebSocket vượt trội hơn HTTP

Số lượng cuộc gọi công cụ cao:
Nếu quy trình làm việc của bạn thực hiện hơn 10 cuộc gọi công cụ tuần tự, kết nối liên tục của WebSocket loại bỏ chi phí thiết lập lặp lại. Mỗi yêu cầu HTTP yêu cầu:

WebSocket thực hiện điều này một lần, sau đó sử dụng lại kết nối.

Các ứng dụng nhạy cảm về độ trễ:
Đối với các ứng dụng thoại hoặc trò chuyện thời gian thực mà mỗi mili giây đều quý giá, kết nối liên tục và khả năng truyền phát của WebSocket giảm đáng kể độ trễ cảm nhận được.

Cập nhật do máy chủ khởi tạo:
WebSocket cho phép máy chủ đẩy dữ liệu đến máy khách mà không cần thăm dò. Đối với các tác vụ tác nhân chạy dài, máy chủ có thể gửi cập nhật tiến độ khi sự kiện xảy ra.

Khi HTTP là đủ

Yêu cầu-Phản hồi đơn giản:
Đối với các cuộc gọi API một lần hoặc các quy trình làm việc với 1-2 cuộc gọi công cụ, HTTP đơn giản hơn để triển khai và gỡ lỗi. Hầu hết các nhà phát triển đều quen thuộc với các client HTTP và cơ sở hạ tầng (bộ cân bằng tải, proxy) xử lý HTTP tốt.

Các hoạt động phi trạng thái:
Nếu bạn không cần duy trì trạng thái phiên giữa các yêu cầu, bản chất phi trạng thái của HTTP thực sự là một lợi thế — không yêu cầu quản lý kết nối.

Hạn chế về cơ sở hạ tầng:
Một số môi trường triển khai (chức năng phi máy chủ, một số proxy) không hỗ trợ các kết nối WebSocket tồn tại lâu dài. HTTP hoạt động phổ biến.

Các chỉ số hiệu suất

Dựa trên tài liệu của OpenAI và thử nghiệm cộng đồng:

Chỉ sốHTTPWebSocket (API Phản hồi)WebSocket (API Thời gian thực)
Thiết lập kết nốiMỗi yêu cầu (~100-300ms)Một lần (~100-300ms)Một lần (~100-300ms)
Quy trình làm việc gọi công cụ 20+Mức cơ sởNhanh hơn ~40%Không áp dụng
Độ trễ khứ hồi giọng nóiKhông áp dụng (không được thiết kế cho điều này)Không áp dụng<500ms
Chi phí bộ nhớThấp (phi trạng thái)Trung bình (trạng thái được lưu trong bộ nhớ cache)Trung bình-Cao (trạng thái phiên)
Độ phức tạp triển khaiThấpTrung bìnhTrung bình-Cao

Cách sử dụng chế độ WebSocket API Phản hồi

Hãy cùng triển khai kết nối WebSocket với API Phản hồi cho một quy trình làm việc tự động.

Điều kiện tiên quyết

Thiết lập kết nối

Ví dụ 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
}

Ví dụ 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()

Chi tiết triển khai chính

Quản lý trạng thái:
Điểm khác biệt quan trọng so với HTTP là việc sử dụng previous_response_id trong các phần tiếp theo. Điều này cho API biết rằng nên sử dụng lại trạng thái được lưu trong bộ nhớ cache từ phản hồi cuối cùng.

Chỉ tiếp tục đầu vào:
Khi tiếp tục một lượt, chỉ gửi:

Không gửi lại toàn bộ mảng messages — máy chủ đã có ngữ cảnh đó.

Giữ lại dữ liệu bằng không:
Để sử dụng ZDR với chế độ WebSocket, hãy bao gồm store: false trong yêu cầu ban đầu của bạn.

Cách sử dụng chế độ WebSocket API Thời gian thực

API Thời gian thực cho phép các tương tác thoại có độ trễ thấp. Dưới đây là cách triển khai nó.

Điều kiện tiên quyết

Thiết lập kết nối

Ví dụ JavaScript (Trình duyệt):

// 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();
  });
}

Ví dụ 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()

Chi tiết triển khai chính

Các loại sự kiện:

API Thời gian thực sử dụng giao tiếp theo sự kiện. Các sự kiện phổ biến:

Máy khách → Máy chủ:

Máy chủ → Máy khách:

Phát hiện Hoạt động Giọng nói:

Chọn giữa hai chế độ VAD:

server_vad: Phát hiện hoạt động giọng nói cơ bản dựa trên âm lượng âm thanh và thời lượng im lặng.

semantic_vad: Phát hiện thông minh hơn hiểu rõ các khoảng dừng tự nhiên so với việc hoàn thành lượt. Sử dụng cái này cho các cuộc trò chuyện tự nhiên hơn nơi người dùng có thể tạm dừng giữa chừng.

Kiểm tra kết nối WebSocket bằng Apidog

Kiểm tra API WebSocket khác với kiểm tra HTTP — bạn cần duy trì kết nối, gửi sự kiện và giám sát luồng tin nhắn hai chiều. Apidog cung cấp khả năng kiểm tra WebSocket chuyên biệt.

Giao diện thiết kế web Apidog

Thiết lập kiểm tra WebSocket trong Apidog

Bước 1: Tạo yêu cầu WebSocket

Trong Apidog, tạo một yêu cầu mới và chọn "WebSocket" làm giao thức. Nhập URL kết nối của bạn:

Tạo yêu cầu WebSocket trong Apidog
wss://api.openai.com/v1/responses

Bước 2: Cấu hình tiêu đề

Thêm tiêu đề xác thực:

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

Đối với API Thời gian thực, bạn cũng có thể sử dụng xác thực dựa trên URL:

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

Với khóa API trong tiêu đề giao thức con.

Bước 3: Thiết lập kết nối

Nhấp vào "Connect" (Kết nối) để thiết lập kết nối WebSocket. Apidog hiển thị:

Bước 4: Gửi sự kiện

Sử dụng công cụ soạn tin nhắn của Apidog để gửi các sự kiện JSON. Đối với API Phản hồi:

{
  "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" }
          }
        }
      }
    }
  ]
}

Bước 5: Giám sát phản hồi

Apidog hiển thị:

Kiểm tra các phần tiếp theo

Để kiểm tra mẫu tiếp theo với previous_response_id:

  1. Gửi tin nhắn ban đầu, ghi lại response.id trong phản hồi
  2. Gửi phần tiếp theo chỉ với đầu vào mới:
{
  "previous_response_id": "resp_abc123",
  "input": [
    {
      "tool_call_id": "call_xyz789",
      "output": "{\"temperature\": 72, \"conditions\": \"sunny\"}"
    }
  ]
}
  1. Quan sát độ trễ giảm so với việc gửi lại toàn bộ ngữ cảnh

Kiểm tra API Thời gian thực

Đối với API Thời gian thực, Apidog cho phép bạn:

Điều này đặc biệt hữu ích để gỡ lỗi tại sao trợ lý giọng nói của bạn có thể ngắt lời người dùng hoặc không phát hiện lời nói đúng cách.

Biến môi trường

Lưu trữ khóa API một cách an toàn bằng cách sử dụng các biến môi trường của Apidog:

{{OPENAI_API_KEY}}

Điều này cho phép bạn chuyển đổi giữa các khóa phát triển và sản xuất mà không cần chỉnh sửa yêu cầu.

Các trường hợp sử dụng trong thế giới thực

Hãy cùng khám phá các tình huống thực tế mà các chế độ WebSocket của OpenAI vượt trội.

Trường hợp sử dụng 1: Tác nhân mã hóa tự động

Tình huống: Một trợ lý mã hóa phân tích các cơ sở mã, xác định các vấn đề và tự động thực hiện các cải tiến.

Tại sao nên sử dụng WebSocket API Phản hồi:

Mẫu triển khai:

// 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...

Trường hợp sử dụng 2: Bot dịch vụ khách hàng bằng giọng nói

Tình huống: Bot hỗ trợ qua điện thoại xử lý các yêu cầu của khách hàng với luồng hội thoại tự nhiên.

Tại sao nên sử dụng WebSocket API Thời gian thực:

Mẫu triển khai:

// 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))
  }
})

Khắc phục sự cố thường gặp

Kết nối không thể thiết lập

Triệu chứng: Kết nối WebSocket không bao giờ mở, sự kiện đóng ngay lập tức.

Các nguyên nhân thường gặp:

  1. Khóa API không hợp lệ - Kiểm tra kỹ tiêu đề Authorization của bạn
  2. Thiếu tiêu đề beta - API Phản hồi yêu cầu OpenAI-Beta: responses-api=v1
  3. Hạn chế mạng - Một số mạng công ty chặn WebSocket
  4. URL không chính xác - Xác minh wss:// (không phải ws://) và đường dẫn điểm cuối

Giải pháp:
Sử dụng Apidog để kiểm tra kết nối với các thông báo lỗi chi tiết. Trình kiểm tra yêu cầu hiển thị chính xác các tiêu đề nào được gửi đi, giúp dễ dàng phát hiện khóa API bị thiếu hoặc không chính xác.

Mã gỡ lỗi:

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)
});

Độ trễ cao mặc dù sử dụng WebSocket

Triệu chứng: Kết nối WebSocket hoạt động nhưng không nhanh hơn HTTP.

Các nguyên nhân thường gặp:

  1. Không sử dụng previous_response_id - Bạn đang gửi lại toàn bộ ngữ cảnh
  2. Khởi động nguội - Yêu cầu đầu tiên trên kết nối mới chậm hơn
  3. Độ trễ mạng - Khoảng cách địa lý đến máy chủ API
  4. Tải trọng lớn - Gửi dữ liệu không cần thiết trong các phần tiếp theo

Giải pháp:
Xác minh bạn chỉ gửi đầu vào mới trong các phần tiếp theo:

// SAI - gửi toàn bộ ngữ cảnh mỗi lần
ws.send({
  messages: [...allPreviousMessages, newMessage],
  tools: [...]
})

// ĐÚNG - tham chiếu trạng thái được lưu trong bộ nhớ cache
ws.send({
  previous_response_id: lastResponse.id,
  input: [newMessage]
})

Rò rỉ bộ nhớ trong các kết nối chạy dài

Triệu chứng: Bộ nhớ ứng dụng tăng theo thời gian với kết nối liên tục.

Các nguyên nhân thường gặp:

  1. Trình nghe sự kiện không bị loại bỏ - Tích lũy trình nghe khi kết nối lại
  2. Bộ đệm âm thanh không được giải phóng - Giữ các tham chiếu đến âm thanh đã phát
  3. Lịch sử tin nhắn tăng lên - Lưu trữ tất cả các tin nhắn đã nhận

Giải pháp:

// Dọn dẹp trình nghe sự kiện khi kết nối lại
function cleanupAndReconnect(ws) {
  ws.removeAllListeners();
  ws.close();

  const newWs = createConnection();
  return newWs;
}

// Giải phóng bộ đệm âm thanh sau khi phát
function playAndRelease(audioBuffer) {
  const audioContext = new AudioContext({ sampleRate: 24000 });
  audioContext.decodeAudioData(audioBuffer, (buffer) => {
    const source = audioContext.createBufferSource();
    source.buffer = buffer;
    source.connect(audioContext.destination);
    source.start();

    source.onended = () => {
      source.disconnect();
      // Bộ đệm sẽ được thu gom rác
    };
  });
}

// Giới hạn lịch sử tin nhắn
const messageHistory = [];
const MAX_HISTORY = 100;

ws.on('message', (data) => {
  messageHistory.push(data);
  if (messageHistory.length > MAX_HISTORY) {
    messageHistory.shift(); // Xóa cũ nhất
  }
});

Kết luận

Các chế độ API WebSocket của OpenAI mở ra những khả năng mới cho các ứng dụng AI. Chế độ WebSocket API Phản hồi mang lại hiệu suất nhanh hơn tới 40% cho các quy trình làm việc tự động với việc gọi công cụ nhiều, làm cho nó trở nên lý tưởng cho các trợ lý mã hóa tự động và hệ thống điều phối. API Thời gian thực cung cấp độ trễ dưới 500ms cho các ứng dụng thoại, cho phép các cuộc trò chuyện tự nhiên, có khả năng bị gián đoạn.

Việc lựa chọn chế độ phù hợp phụ thuộc vào trường hợp sử dụng của bạn:

Bản chất liên tục, theo sự kiện của các kết nối WebSocket yêu cầu các phương pháp kiểm tra khác với HTTP. Kiểm tra API WebSocket của OpenAI bằng client WebSocket thời gian thực của Apidog — nhập khóa API của bạn, thiết lập kết nối, gửi sự kiện và giám sát phản hồi với nhật ký chi tiết. Hãy dùng thử miễn phí để xác thực các tích hợp của bạn trước khi triển khai sản xuất.

button

Thực hành thiết kế API trong Apidog

Khám phá cách dễ dàng hơn để xây dựng và sử dụng API

Đăng ký miễn phíTải xuống