Blog

OpenAI WebSocket Modu API'si Nasıl Kullanılır?

Ashley Innocent

Ashley Innocent

24 February 2026

OpenAI WebSocket Modu API'si Nasıl Kullanılır?

Kurumsal İçin Apidog

Şirket İçi (On-Premises) Dağıtım

SSO ve RBAC

SOC 2 Uyumlu

Apidog Enterprise'ı Keşfedin

TL;DR

OpenAI, farklı kullanım durumları için iki WebSocket API modu sunar: yoğun araç çağrısı içeren ajans iş akışları için **Yanıtlar API WebSocket modu** (20'den fazla araç çağrısı için %40'a kadar daha hızlı) ve düşük gecikmeli ses ve işitsel uygulamalar için **Gerçek Zamanlı API**. Her ikisi de durum bilgisi olmayan HTTP istekleri yerine kalıcı WebSocket bağlantıları kullanır, tekrarlanan bağlantı yükünü ortadan kaldırarak gecikmeyi azaltır ve olay odaklı, durum bilgili etkileşimleri mümkün kılar.

Giriş

OpenAI'ın API'si basit istek-yanıt modellerinin ötesine geçti. Hızlı araç çağrıları veya gerçek zamanlı ses akışı gerektiren uygulamalar için, geleneksel HTTP modeli gereksiz ek yük oluşturur. Her yeni istek, aynı görüşmeyi sürdürseniz bile bağlantı kurulumu, kimlik doğrulama ve durum iletimi gerektirir.

OpenAI'ın WebSocket API'si, kalıcı, çift yönlü bir bağlantı sürdürerek bu sorunu çözer. 20'den fazla ardışık araç çağrısı içeren ajans iş akışları için bu, uçtan uca yürütmede yaklaşık %40 daha hızlı performans anlamına gelir. Ses uygulamaları için, 500 ms'nin altında gecikmelerle doğal, kesilebilir konuşmalar sağlar.

💡
WebSocket bağlantılarını test etmek geleneksel olarak karmaşık hata ayıklama araçları gerektiriyordu. Apidog'un WebSocket test arayüzü, bağlantılar kurmanıza, olaylar göndermenize ve yanıtları gerçek zamanlı olarak izlemenize olanak tanır – OpenAI WebSocket entegrasyonlarını üretim dağıtımından önce doğrulamak için hayati önem taşır.
Uygulamayı İndir

Bu kılavuz, OpenAI'ın her iki WebSocket modunu da kapsar: araç ağırlıklı ajans iş akışları için Yanıtlar API'si ve ses akışı için Gerçek Zamanlı API. Her birini ne zaman kullanacağınızı, nasıl uygulayacağınızı ve etkili bir şekilde nasıl test edeceğinizi öğreneceksiniz.

OpenAI WebSocket API Nedir?

OpenAI WebSocket API, OpenAI'ın dil modelleriyle etkileşim için HTTP'ye alternatif bir taşıma mekanizması sağlar. Her API çağrısı için yeni bir bağlantı oluşturmak yerine, WebSocket oturumunuz boyunca açık kalan tek, uzun ömürlü bir bağlantı kurar.

Temel Özellikler

Kalıcı Bağlantı: Kurulduktan sonra, WebSocket bağlantısı açıkça kapatılana kadar açık kalır ve istek başına bağlantı ek yükünü ortadan kaldırır.

Çift Yönlü İletişim: Hem istemci hem de sunucu, istediği zaman mesaj gönderebilir, bu da gerçek olay odaklı mimarileri mümkün kılar.

Durum Bilgili Oturumlar: Sunucu, mevcut bağlantı için bağlamı korur ve tüm konuşma geçmişini yeniden göndermeden önceki yanıtlara referans vermenizi sağlar.

Olay Odaklı Model: İletişim, istek-yanıt çiftleri yerine ayrık olaylar (JSON mesajları) aracılığıyla gerçekleşir.

WebSocket Protokol Temelleri

WebSocket bağlantıları bir HTTP yükseltme isteğiyle başlar, ardından WebSocket protokolüne geçer. OpenAI için, aşağıdaki gibi uç noktalara bağlanacaksınız:

wss:// şeması, güvenli bir WebSocket bağlantısını gösterir (HTTP için HTTPS'ye benzer).

İki WebSocket Modu Açıklandı

OpenAI, her biri farklı kullanım durumları için optimize edilmiş iki farklı WebSocket modu sunar.

Yanıtlar API WebSocket Modu

Yanıtlar API'si, birçok ardışık araç çağrısı yapmanız gereken **ajans iş akışları** için WebSocket bağlantılarını destekler. Bu mod, karmaşık görevleri yerine getirmek için araçları tekrar tekrar çağıran kodlama yardımcıları, orkestrasyon sistemleri ve otonom aracılar için tasarlanmıştır.

Nasıl Çalışır:

Aktif bir WebSocket bağlantısında, hizmet bağlantıya özel bellekteki önbellekte bir önceki yanıt durumunu (en son yanıt) korur. Bir turu devam ettirdiğinizde, yalnızca şunları gönderirsiniz:

Sunucu, tüm konuşma geçmişini yeniden işlemeden önbelleğe alınmış durumu yeniden kullanır.

Performans Avantajları:

20'den fazla araç çağrısı içeren iş akışları için OpenAI, HTTP'ye kıyasla uçtan uca yürütmede **%40'a kadar daha hızlı performans** bildirmektedir. Bu avantajlar şunlardan kaynaklanır:

Uyumluluk:

WebSocket modu hem Sıfır Veri Saklama (ZDR) hem de store=false seçenekleriyle çalışır, bu da onu gizlilik açısından hassas uygulamalar için uygun hale getirir.

Gerçek Zamanlı API WebSocket Modu

Gerçek Zamanlı API, **ses odaklı uygulamalar** için düşük gecikmeli, akışlı ses yetenekleri sağlar. Modelin ses girişine ses çıkışı ile yanıt verebildiği, kesintileri doğal bir şekilde ele aldığı konuşmadan konuşmaya etkileşimleri mümkün kılar.

Nasıl Çalışır:

Gerçek Zamanlı API, durum bilgili, olay odaklı bir oturum oluşturmak için WebSocket kullanır. API'ye ses öbekleri akışı yaparsınız ve API hem transkripsiyonları hem de oluşturulan ses yanıtlarını geri akışla gönderir. Bağlantı şunları destekler:

Temel Özellikler:

Ses Aktivite Algılama (VAD): API, bir kullanıcının sadece duraklama yerine ne zaman konuşmayı bitirdiğini anlayan semantik VAD içerir. Bu, daha doğal bir konuşma akışı yaratır.

Çok Modlu Yetenekler: GPT-4o'nun yerel çok modlu yeteneklerine doğrudan erişim, hem sesi hem de metni tek bir modelde işleme.

Düşük Gecikme: Ses etkileşimleri için 500ms'nin altında gecikmeler için tasarlanmıştır, gerçek zamanlı konuşmalar için uygundur.

WebSocket ve HTTP: Performans Karşılaştırması

WebSocket ve HTTP arasında seçim yapmak, uygulamanızın özelliklerine bağlıdır. İşte her bir protokolün ne zaman öne çıktığı.

WebSocket ve HTTP

WebSocket'in HTTP'den Üstün Olduğu Durumlar

Yüksek Araç Çağrısı Hacmi:
İş akışınız 10'dan fazla ardışık araç çağrısı yapıyorsa, WebSocket'in kalıcı bağlantısı tekrarlanan kurulum ek yükünü ortadan kaldırır. Her HTTP isteği şunları gerektirir:

WebSocket bunu bir kez yapar, sonra bağlantıyı yeniden kullanır.

Gecikmeye Duyarlı Uygulamalar:
Her milisaniyenin önemli olduğu gerçek zamanlı sesli veya sohbet uygulamaları için, WebSocket'in kalıcı bağlantısı ve akış yetenekleri algılanan gecikmeyi önemli ölçüde azaltır.

Sunucu Tarafından Başlatılan Güncellemeler:
WebSocket, sunucunun istemcilere anket yapmadan veri göndermesine olanak tanır. Uzun süreli ajan görevleri için, sunucu olaylar meydana geldikçe ilerleme güncellemeleri gönderebilir.

HTTP'nin Yeterli Olduğu Durumlar

Basit İstek-Yanıt:
Tek seferlik API çağrıları veya 1-2 araç çağrısı içeren iş akışları için HTTP'yi uygulamak ve hata ayıklamak daha basittir. Çoğu geliştirici HTTP istemcilerine aşinadır ve altyapı (yük dengeleyiciler, proxy'ler) HTTP'yi iyi yönetir.

Durum Bilgisiz İşlemler:
İstekler arasında oturum durumu tutmanız gerekmiyorsa, HTTP'nin durum bilgisiz doğası aslında bir avantajdır – bağlantı yönetimi gerekmez.

Altyapı Kısıtlamaları:
Bazı dağıtım ortamları (sunucusuz işlevler, belirli proxy'ler) uzun ömürlü WebSocket bağlantılarını desteklemez. HTTP evrensel olarak çalışır.

Performans Metrikleri

OpenAI'ın dokümantasyonuna ve topluluk testlerine dayanarak:

MetrikHTTPWebSocket (Yanıtlar API)WebSocket (Gerçek Zamanlı API)
Bağlantı KurulumuHer istek (~100-300ms)Bir kez (~100-300ms)Bir kez (~100-300ms)
20+ Araç Çağrısı İş AkışıTemel~%40 daha hızlıUygulanamaz
Ses Gidiş-Dönüş GecikmesiUygulanamaz (bunun için tasarlanmamış)Uygulanamaz<500ms
Bellek YüküDüşük (durum bilgisiz)Orta (önbelleğe alınmış durum)Orta-Yüksek (oturum durumu)
Uygulama KarmaşıklığıDüşükOrtaOrta-Yüksek

Yanıtlar API WebSocket Modu Nasıl Kullanılır

Ajans iş akışı için Yanıtlar API'sine bir WebSocket bağlantısı uygulayalım.

Ön Koşullar

Bağlantı Kurulumu

Node.js Örneği:

const WebSocket = require('ws');

// Yanıtlar API WebSocket uç noktasına bağlan
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('OpenAI Yanıtlar API\'sine Bağlandı');

  // Başlangıç isteğini gönder
  const initialMessage = {
    model: 'gpt-4o',
    messages: [
      { role: 'user', content: 'Bu kod tabanını analiz etmeme ve iyileştirmeler önermeme yardımcı ol.' }
    ],
    tools: [
      {
        type: 'function',
        function: {
          name: 'read_file',
          description: 'Bir dosyanın içeriğini oku',
          parameters: {
            type: 'object',
            properties: {
              path: { type: 'string', description: 'Okunacak dosya yolu' }
            },
            required: ['path']
          }
        }
      },
      {
        type: 'function',
        function: {
          name: 'search_code',
          description: 'Kod desenlerini ara',
          parameters: {
            type: 'object',
            properties: {
              pattern: { type: 'string', description: 'Aranacak Regex deseni' }
            },
            required: ['pattern']
          }
        }
      }
    ]
  };

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

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

  // Modelin araç çağırmak isteyip istemediğini kontrol et
  if (response.choices[0].finish_reason === 'tool_calls') {
    const toolCalls = response.choices[0].message.tool_calls;

    // Araçları yürüt (basitleştirilmiş)
    const toolResults = toolCalls.map(call => ({
      tool_call_id: call.id,
      output: executeToolLocally(call.function.name, call.function.arguments)
    }));

    // Konuşmayı araç sonuçlarıyla devam ettir
    const continuation = {
      previous_response_id: response.id, // Önceki yanıta referans
      input: toolResults
    };

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

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

ws.on('close', () => {
  console.log('Bağlantı kapatıldı');
});

function executeToolLocally(name, args) {
  // Araç yürütme mantığınız
  if (name === 'read_file') {
    const { path } = JSON.parse(args);
    return fs.readFileSync(path, 'utf-8');
  }
  // ... diğer araçlar
}

Python Örneği:

import websocket
import json
import os

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

    # Araç çağrılarını ele al
    if response['choices'][0]['finish_reason'] == 'tool_calls':
        tool_calls = response['choices'][0]['message']['tool_calls']

        # Araçları yürüt
        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
            })

        # Yalnızca yeni girdi + previous_response_id ile devamı gönder
        continuation = {
            'previous_response_id': response['id'],
            'input': tool_results
        }
        ws.send(json.dumps(continuation))

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

def on_close(ws, close_status_code, close_msg):
    print("Bağlantı kapatıldı")

def on_open(ws):
    print("OpenAI Yanıtlar API'sine Bağlandı")

    # Başlangıç isteğini gönder
    initial_message = {
        'model': 'gpt-4o',
        'messages': [
            {'role': 'user', 'content': 'Bu kod tabanını analiz et ve iyileştirmeler öner.'}
        ],
        'tools': [
            {
                'type': 'function',
                'function': {
                    'name': 'read_file',
                    'description': 'Dosya içeriğini oku',
                    '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()
    # ... diğer araçlar

# WebSocket bağlantısı oluştur
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()

Temel Uygulama Detayları

Durum Yönetimi:
HTTP'den kritik fark, devam eden isteklerde previous_response_id kullanmaktır. Bu, API'ye son yanıttan önbelleğe alınmış durumu yeniden kullanmasını söyler.

Yalnızca Girdi Devamları:
Bir turu devam ettirirken, yalnızca şunları gönderin:

Tam messages dizisini yeniden göndermeyin; sunucu bu bağlama zaten sahiptir.

Sıfır Veri Saklama:
WebSocket moduyla ZDR kullanmak için, ilk isteğinize store: false ekleyin.

Gerçek Zamanlı API WebSocket Modu Nasıl Kullanılır

Gerçek Zamanlı API, düşük gecikmeli ses etkileşimlerini etkinleştirir. İşte nasıl uygulanacağı.

Ön Koşullar

Bağlantı Kurulumu

JavaScript (Tarayıcı) Örneği:

// Gerçek Zamanlı API'ye bağlan
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('Gerçek Zamanlı API\'ye Bağlandı');

  // Oturumu yapılandır
  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', // veya daha akıllı algılama için 'semantic_vad'
        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('Oturum oluşturuldu:', message.session);
      break;

    case 'conversation.item.created':
      console.log('Yeni öğe:', message.item);
      break;

    case 'response.audio.delta':
      // Ses öbeği alındı - oynat
      const audioChunk = base64ToArrayBuffer(message.delta);
      playAudioChunk(audioChunk);
      break;

    case 'response.audio_transcript.delta':
      // Transkript öbeği alındı
      console.log('Transkript:', message.delta);
      break;

    case 'input_audio_buffer.speech_started':
      console.log('Kullanıcı konuşmaya başladı');
      break;

    case 'input_audio_buffer.speech_stopped':
      console.log('Kullanıcı konuşmayı durdurdu');
      break;

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

// Mikrofondan ses gönder
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);

    // Float32'yi Int16 PCM'ye dönüştür
    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));
    }

    // API'ye gönder
    ws.send(JSON.stringify({
      type: 'input_audio_buffer.append',
      audio: arrayBufferToBase64(pcmData.buffer)
    }));
  };

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

// Metin girişi gönder
function sendTextMessage(text) {
  ws.send(JSON.stringify({
    type: 'conversation.item.create',
    item: {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: text }
      ]
    }
  }));

  // Yanıt üretimi iste
  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();
  });
}

Python Örneği:

import websocket
import json
import base64
import pyaudio

# Ses yapılandırması
RATE = 24000
CHUNK = 4096
FORMAT = pyaudio.paInt16
CHANNELS = 1

audio = pyaudio.PyAudio()

def on_open(ws):
    print("Gerçek Zamanlı API'ye Bağlandı")

    # Oturumu yapılandır
    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
            }
        }
    }))

    # Mikrofon akışını başlat
    stream_microphone(ws)

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

    if data['type'] == 'response.audio.delta':
        # Sesi çöz ve oynat
        audio_chunk = base64.b64decode(data['delta'])
        play_audio(audio_chunk)

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

    elif data['type'] == 'input_audio_buffer.speech_started':
        print("\n[Kullanıcı konuşuyor...]")

    elif data['type'] == 'error':
        print(f"Hata: {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()

# WebSocket bağlantısı oluştur
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()

Temel Uygulama Detayları

Olay Türleri:

Gerçek Zamanlı API, olay odaklı iletişim kullanır. Yaygın olaylar:

İstemci → Sunucu:

Sunucu → İstemci:

Ses Aktivite Algılama:

İki VAD modu arasında seçim yapın:

server_vad: Ses seviyesi ve sessizlik süresine dayalı temel ses aktivite algılama.

semantic_vad: Doğal duraklamalar ile sıra tamamlama arasındaki farkı anlayan daha akıllı algılama. Kullanıcıların düşünürken duraklayabileceği daha doğal konuşmalar için bunu kullanın.

Apidog ile WebSocket Bağlantılarını Test Etme

WebSocket API'lerini test etmek, HTTP testinden farklıdır – bir bağlantıyı sürdürmeniz, olaylar göndermeniz ve çift yönlü mesaj akışını izlemeniz gerekir. Apidog, özel WebSocket test yetenekleri sunar.

Apidog Web Tasarım Arayüzü

Apidog'da WebSocket Testleri Kurulumu

Adım 1: WebSocket İsteği Oluşturun

Apidog'da yeni bir istek oluşturun ve protokol olarak "WebSocket"i seçin. Bağlantı URL'nizi girin:

Apidog'da WebSocket İsteği Oluştur
wss://api.openai.com/v1/responses

Adım 2: Başlıkları Yapılandırın

Kimlik doğrulama başlıklarını ekleyin:

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

Gerçek Zamanlı API için, URL tabanlı kimlik doğrulamasını da kullanabilirsiniz:

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

API anahtarı alt protokol başlığında.

Adım 3: Bağlantı Kurun

WebSocket bağlantısını kurmak için "Bağlan"a tıklayın. Apidog şunları gösterir:

Adım 4: Olayları Gönderin

JSON olaylarını göndermek için Apidog'un mesaj oluşturucusunu kullanın. Yanıtlar API'si için:

{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "San Francisco'da hava nasıl?"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Mevcut hava durumunu al",
        "parameters": {
          "type": "object",
          "properties": {
            "location": { "type": "string" }
          }
        }
      }
    }
  ]
}

Adım 5: Yanıtları İzleyin

Apidog şunları görüntüler:

Devam Eden İstekleri Test Etme

previous_response_id ile devam eden istek modelini test etmek için:

  1. İlk mesajı gönderin, yanıttaki response.id'yi not alın
  2. Yalnızca yeni girdi ile devam eden isteği gönderin:
{
  "previous_response_id": "resp_abc123",
  "input": [
    {
      "tool_call_id": "call_xyz789",
      "output": "{\"temperature\": 72, \"conditions\": \"sunny\"}"
    }
  ]
}
  1. Tam bağlamı yeniden göndermeye kıyasla azalan gecikmeyi gözlemleyin

Gerçek Zamanlı API'yi Test Etme

Gerçek Zamanlı API için Apidog size şunları sağlar:

Bu, sesli asistanınızın neden kullanıcıları kesintiye uğrattığını veya konuşmayı düzgün algılamadığını hata ayıklamak için özellikle faydalıdır.

Ortam Değişkenleri

API anahtarlarını Apidog'un ortam değişkenlerini kullanarak güvenli bir şekilde saklayın:

{{OPENAI_API_KEY}}

Bu, istekleri düzenlemeden geliştirme ve üretim anahtarları arasında geçiş yapmanızı sağlar.

Gerçek Dünya Kullanım Durumları

OpenAI'ın WebSocket modlarının öne çıktığı pratik senaryoları inceleyelim.

Kullanım Durumu 1: Otonom Kodlama Aracısı

Senaryo: Kod tabanlarını analiz eden, sorunları belirleyen ve otonom olarak iyileştirmeler yapan bir kodlama asistanı.

Neden Yanıtlar API WebSocket:

Uygulama Modeli:

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

Kullanım Durumu 2: Sesli Müşteri Hizmetleri Botu

Senaryo: Müşteri sorularını doğal konuşma akışıyla ele alan telefon destek botu.

Neden Gerçek Zamanlı API WebSocket:

Uygulama Modeli:

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

Sık Karşılaşılan Sorunları Giderme

Bağlantı Kurulamıyor

Belirtiler: WebSocket bağlantısı asla açılmıyor, anında kapanma olayı.

Yaygın Nedenler:

  1. Geçersiz API anahtarı - Authorization başlığınızı tekrar kontrol edin
  2. Eksik beta başlığı - Yanıtlar API'si OpenAI-Beta: responses-api=v1 gerektirir
  3. Ağ kısıtlamaları - Bazı kurumsal ağlar WebSocket'i engeller
  4. Yanlış URL - wss:// (ws:// değil) ve uç nokta yolunu doğrulayın

Çözüm:
Bağlantıyı ayrıntılı hata mesajlarıyla test etmek için Apidog'u kullanın. İstek denetleyicisi, hangi başlıkların gönderildiğini tam olarak göstererek eksik veya yanlış API anahtarlarını tespit etmeyi kolaylaştırır.

Hata Ayıklama Kodu:

ws.on('error', (error) => {
  console.error('Bağlantı hatası:', error);
});

ws.on('close', (code, reason) => {
  console.log(`Kod ${code} ile kapatıldı: ${reason}`);
  // Yaygın kodlar:
  // 1006: Anormal kapanma (genellikle kimlik doğrulama sorunları)
  // 1008: Politika ihlali (geçersiz başlıklar)
});

WebSocket'e Rağmen Yüksek Gecikme

Belirtiler: WebSocket bağlantısı çalışıyor ancak HTTP'den daha hızlı değil.

Yaygın Nedenler:

  1. previous_response_id kullanmıyorsunuz - Tüm bağlamı yeniden gönderiyorsunuz
  2. Soğuk başlangıç - Yeni bağlantıdaki ilk istek daha yavaştır
  3. Ağ gecikmesi - API sunucularına coğrafi uzaklık
  4. Büyük yükler - Devam eden isteklerde gereksiz veri gönderme

Çözüm:
Devam eden isteklerde yalnızca yeni girdi gönderdiğinizi doğrulayın:

// YANLIŞ - her seferinde tam bağlamı gönderir
ws.send({
  messages: [...allPreviousMessages, newMessage],
  tools: [...]
})

// DOĞRU - önbelleğe alınmış duruma referans verir
ws.send({
  previous_response_id: lastResponse.id,
  input: [newMessage]
})

Uzun Süreli Bağlantılarda Bellek Sızıntıları

Belirtiler: Uygulama belleği, kalıcı bağlantıyla zamanla artar.

Yaygın Nedenler:

  1. Olay dinleyicileri kaldırılmamış - Yeniden bağlantıda dinleyiciler birikiyor
  2. Ses arabellekleri serbest bırakılmamış - Çalınan seslere referanslar tutuluyor
  3. Mesaj geçmişi büyüyor - Tüm alınan mesajları saklama

Çözüm:

// Yeniden bağlantıda olay dinleyicilerini temizle
function cleanupAndReconnect(ws) {
  ws.removeAllListeners();
  ws.close();

  const newWs = createConnection();
  return newWs;
}

// Oynadıktan sonra ses arabelleklerini serbest bırak
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();
      // Arabellek çöp toplama ile temizlenecek
    };
  });
}

// Mesaj geçmişini sınırlayın
const messageHistory = [];
const MAX_HISTORY = 100;

ws.on('message', (data) => {
  messageHistory.push(data);
  if (messageHistory.length > MAX_HISTORY) {
    messageHistory.shift(); // En eskisini kaldır
  }
});

Sonuç

OpenAI'ın WebSocket API modları, yapay zeka uygulamaları için yeni olanaklar sunuyor. Yanıtlar API WebSocket modu, yoğun araç çağrısı içeren ajans iş akışları için %40'a kadar daha hızlı yürütme sağlayarak, otonom kodlama yardımcıları ve orkestrasyon sistemleri için idealdir. Gerçek Zamanlı API, ses uygulamaları için 500 ms'nin altında gecikme sunarak doğal, kesilebilir konuşmaları mümkün kılar.

Doğru modu seçmek, kullanım durumunuza bağlıdır:

WebSocket bağlantılarının kalıcı, olay odaklı yapısı, HTTP'den farklı test yaklaşımları gerektirir. OpenAI'ın WebSocket API'lerini Apidog'un gerçek zamanlı WebSocket istemcisiyle test edin – API anahtarınızı içe aktarın, bağlantılar kurun, olaylar gönderin ve ayrıntılı günlükleme ile yanıtları izleyin. Üretim dağıtımından önce entegrasyonlarınızı doğrulamak için ücretsiz deneyin.

Uygulamayı İndir

API Tasarım-Öncelikli Yaklaşımı Apidog'da Uygulayın

API'leri oluşturmanın ve kullanmanın daha kolay yolunu keşfedin

Ücretsiz Kaydolİndir