रियल-टाइम स्पीच-टू-टेक्स्ट (STT)

WebSockets का इस्तेमाल करके लाइव स्ट्रीमिंग ऑडियो को रियल-टाइम में टेक्स्ट में बदलें।

हमारे सर्वर पर रॉ ऑडियो स्ट्रीम करें और दोनों तरफ़ से रियल-टाइम ट्रांसक्रिप्शन प्राप्त करें। सर्वर आंशिक नतीजे (यूज़र के बोलते ही लाइव टेक्स्ट) और अंतिम नतीजे (शब्द-स्तर के टाइमस्टैम्प के साथ पूरे वाक्य) के साथ जवाब देता है।

ऑथेंटिकेशन और कनेक्शन

आपको अपने WebSocket कनेक्शन को ऑथेंटिकेट करना होगा। इसका तरीका आपके क्लाइंट एनवायरनमेंट पर निर्भर करता है:

• फ्रंटएंड ब्राउज़र: स्टैंडर्ड ब्राउज़र WebSockets कस्टम HTTP हेडर को सपोर्ट नहीं करते हैं। आपको अपनी API की (API key) को क्वेरी पैरामीटर (?api_key=YOUR_KEY) के तौर पर शामिल करना होगा।
• बैकएंड / Python / Node.js: आप स्टैंडर्ड HTTP हेडर Authorization: Bearer YOUR_API_KEY का इस्तेमाल कर सकते हैं।

ऑडियो से जुड़ी जानकारी

सॉकेट के ज़रिए बाइनरी फ़्रेम भेजने से पहले, पक्का कर लें कि आपका ऑडियो स्ट्रीम बिल्कुल मेल खाता हो:

• सैंपल रेट: 16,000 Hz (16 kHz)
• बिट डेप्थ: 16-बिट पूर्णांक (Int16)
• चैनल: 1 (मोनो)
• चंक साइज़: छोटे हिस्सों (जैसे, 100ms / 3200 बाइट्स) में भेजें। 256KB से बड़े हिस्सों को रिजेक्ट कर दिया जाएगा।

सर्वर रिस्पॉन्स (JSON इवेंट्स)

जैसे ही आप सर्वर पर बाइनरी ऑडियो स्ट्रीम करेंगे, सर्वर JSON टेक्स्ट फ़्रेम के साथ एसिंक्रोनस रूप से जवाब देगा।

{"status": "connected", "message": "ऑडियो स्ट्रीम करने के लिए तैयार..."}

{"type": "partial", "text": "प्लेटफ़ॉर्म पर आपका स्वागत है"}

{
  "type": "final",
  "text": "मकना प्लेटफ़ॉर्म पर आपका स्वागत है।",
  "words": [
    {"word": "مرحبا", "start_time_ms": 150, "duration_ms": 300},
    {"word": "بك", "start_time_ms": 460, "duration_ms": 200}
  ]
}

स्ट्रीम खत्म करना: When the user stops speaking, send a JSON text frame: {"command": "stop"} to safely close the connection and calculate the final refund.

उदाहरण एकीकरण

# pip install websockets pyaudio
import asyncio
import websockets
import json
import pyaudio
import sys

API_KEY = "YOUR_API_KEY"
URL = "wss://moknah.io/api/v1/stt/ws/?language=ar-SA"

# 16kHz, 16-bit, Mono (100ms chunks)
CHUNK = 1600

async def stream_live_microphone(ws):
    audio = pyaudio.PyAudio()
    stream = audio.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True, frames_per_buffer=CHUNK)

    print("🎤 Microphone is LIVE. Start speaking!")
    loop = asyncio.get_running_loop()

    try:
        while True:
            data = await loop.run_in_executor(None, stream.read, CHUNK, False)
            await ws.send(data)
            await asyncio.sleep(0.001)
    except asyncio.CancelledError:
        await ws.send(json.dumps({"command": "stop"}))
    finally:
        stream.stop_stream()
        stream.close()
        audio.terminate()

async def receive_transcriptions(ws):
    async for message in ws:
        data = json.loads(message)
        if data.get('type') == 'partial':
            sys.stdout.write(f"\r⏳ {data['text']}")
            sys.stdout.flush()
        elif data.get('type') == 'final':
            sys.stdout.write(f"\r✅ {data['text']}\n")
            sys.stdout.flush()

async def main():
    headers = {"Authorization": f"Bearer {API_KEY}"}
    async with websockets.connect(URL, additional_headers=headers) as ws:
        await asyncio.gather(
            asyncio.create_task(stream_live_microphone(ws)),
            asyncio.create_task(receive_transcriptions(ws))
        )

asyncio.run(main())

// 1. Connect to WebSocket
const ws = new WebSocket('wss://moknah.io/api/v1/stt/ws/?api_key=YOUR_API_KEY&language=ar-SA');

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.type === 'partial') {
        console.log("Live:", data.text);
    } else if (data.type === 'final') {
        console.log("Final:", data.text);
    }
};

// 2. Capture Microphone Audio on Connection
ws.onopen = async () => {
    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });

    // Force 16kHz sample rate for the AudioContext
    const audioCtx = new AudioContext({ sampleRate: 16000 });
    const source = audioCtx.createMediaStreamSource(stream);
    const processor = audioCtx.createScriptProcessor(4096, 1, 1);

    processor.onaudioprocess = (e) => {
        if (ws.readyState === WebSocket.OPEN) {
            const float32Data = e.inputBuffer.getChannelData(0);

            // Convert Browser Float32 to Int16 PCM (Required by Server)
            const pcm16 = new Int16Array(float32Data.length);
            for (let i = 0; i < float32Data.length; i++) {
                pcm16[i] = Math.max(-1, Math.min(1, float32Data[i])) * 0x7FFF;
            }

            // Send binary PCM audio chunk to server
            ws.send(pcm16.buffer);
        }
    };

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

// 3. Handle graceful shutdown
function stopRecording() {
    ws.send(JSON.stringify({ command: "stop" }));
}

डिस्कनेक्ट और एरर कोड

अगर कनेक्शन रिजेक्ट या ड्रॉप हो जाता है, तो WebSocket इनमें से किसी एक खास कोड के साथ बंद हो जाएगा: