रीयल-टाइम ऑटोमैटिक स्पीच रिकॉग्निशन एक सीमित क्षमता से निकलकर आधुनिक वॉयस एप्लिकेशन्स का एक मुख्य हिस्सा बन चुका है। चाहे आप लाइव कैप्शनिंग सिस्टम, एक वॉयस असिस्टेंट, एक टेलीफोनी अनुपालन इंजन, या एक संवादात्मक AI वर्कफ़्लो बना रहे हों, आपके real time ASR API की गुणवत्ता यह तय करती है कि आपका प्रोडक्ट उपयोगकर्ताओं को कितना प्रतिक्रियाशील और समझदार महसूस होता है।

यह गाइड आपके एप्लिकेशन्स में Pulse Speech-to-Text (STT) API  को एकीकृत करने के लिए आवश्यक हर चीज़ को कवर करती है। केवल 64 मिलीसेकंड के टाइम टू फर्स्ट ट्रांसक्रिप्ट (TTFT) के साथ, Pulse Speech-to-Text (STT) API को विशेष रूप से लाइव, लेटेंसी-संवेदनशील वर्कलोड के लिए तैयार किया गया है।

हम पूर्ण कोड उदाहरणों के साथ प्रमाणीकरण (authentication), वेबसॉकेट कनेक्शन, ऑडियो एन्कोडिंग, रिस्पॉन्स हैंडलिंग, उन्नत फीचर्स और प्रोडक्शन की सर्वोत्तम प्रथाओं के बारे में जानेंगे।

रीयल-टाइम एएसआर (Real-Time ASR) क्या है और यह क्यों महत्वपूर्ण है?

ऑटोमैटिक स्पीच रिकॉग्निशन (ASR) वह तकनीक है जो बोली जाने वाली ऑडियो को टेक्स्ट में बदलती है। एक real time ASR API इससे भी आगे जाता है; यह ऑडियो के आते ही उसे एक निरंतर स्ट्रीम में प्रोसेस करता है, और पूरी ऑडियो फ़ाइल के अपलोड और विश्लेषण होने का इंतज़ार करने के बजाय मिलीसेकंड के भीतर आंशिक (partial) और अंतिम (final) ट्रांसक्रिप्ट वापस कर देता है।

हाई-लेवल आर्किटेक्चर: वेव्स पल्स एपीआई (Waves Pulse API) प्रक्रिया कैसे काम करती है:

स्ट्रीमिंग एएसआर के लिए मुख्य उपयोग के मामले (Core Use Cases):

• लाइव बातचीत और कॉल एनालिटिक्स

• वॉयस असिस्टेंट और संवादात्मक एजेंट

• लाइव कैप्शनिंग और एक्सेसिबिलिटी

• स्ट्रीमिंग अनुपालन और PII संपादन

पल्स स्पीच-टू-टेक्स्ट (Pulse STT) API क्यों सबसे अलग है?

Pulse STT API को शुरू से ही स्ट्रीमिंग-फर्स्ट वर्कलोड के लिए डिज़ाइन किया गया था। इसकी मुख्य विशेषता इसका 64 ms टाइम टू फर्स्ट ट्रांसक्रिप्ट (TTFT) है - यानी वह समय जब ऑडियो डेटा पहली बार सर्वर पर पहुंचता है और जब पहले ट्रांसक्राइब किए गए शब्द वापस मिलते हैं। यह कई स्थापित क्लाउड STT प्रदाताओं की तुलना में काफी तेज़ है, जिनका TTFT आमतौर पर 200 से 500 ms के बीच होता है।

Pulse STT सीधे अपने ट्रांसक्रिप्शन आउटपुट में स्पीकर डायराइजेशन, वर्ड टाइमस्टैम्प, भावना पहचान (emotion detection), उम्र और लिंग का अनुमान, PII संपादन और न्यूमेरिक फ़ॉर्मेटिंग जैसी उन्नत सुविधाएं भी प्रदान करता है, जिससे अलग से डाउनस्ट्रीम विश्लेषण पाइपलाइनों की आवश्यकता समाप्त हो जाती है।

एक अच्छा रीयल-टाइम एएसआर एपीआई (Real-Time ASR API) क्या बनाता है?

सभी स्पीच रिकॉग्निशन एपीआई एक ही काम के लिए नहीं बने होते हैं। पॉडकास्ट प्रोसेसिंग के लिए अनुकूलित एक बैच ट्रांसक्रिप्शन एपीआई की इंजीनियरिंग प्राथमिकताएं लाइव वॉयस एजेंटों या टेलीफोनी अनुपालन के लिए डिज़ाइन किए गए एपीआई से बहुत अलग होती हैं। एएसआर प्रदाता चुनने से पहले, यहां वे पहलू दिए गए हैं जो वास्तव में प्रोडक्शन में मायने रखते हैं।

1. टाइम टू फर्स्ट ट्रांसक्रिप्ट (TTFT)

संवादात्मक एप्लिकेशन्स के लिए यह सबसे महत्वपूर्ण मीट्रिक है। TTFT सर्वर पर पहली बार ऑडियो पहुँचने और पहले ट्रांसक्राइब किए गए शब्दों के वापस आने के बीच के समय को मापता है। 200-500ms पर (वह रेंज जिसमें अधिकांश पुराने क्लाउड प्रदाता हैं), एक ध्यान देने योग्य देरी होती है जो एक प्राकृतिक बातचीत के अहसास को तोड़ देती है। 100ms से नीचे, बातचीत वास्तव में रीयल-टाइम महसूस होती है। यही कारण है कि Pulse STT का 64ms TTFT एक इंजीनियरिंग लक्ष्य है, न कि केवल एक मार्केटिंग नंबर - यह वह सीमा है जहां वॉयस एआई केवल एक डेमो जैसा महसूस होना बंद कर देता है और एक वास्तविक प्रोडक्ट की तरह काम करता है।

2. आंशिक बनाम अंतिम ट्रांसक्रिप्ट (Partial vs. Final Transcripts)

एक अच्छा स्ट्रीमिंग एएसआर एपीआई आपको स्पीकर के अपना वाक्य पूरा करने का इंतज़ार नहीं कराता है। यह शब्दों के पहचाने जाने पर आंशिक ट्रांसक्रिप्ट (partial transcripts) वापस करता है, जिससे आपका यूआई (UI) रीयल-टाइम में अपडेट होता है, और फिर स्पीच सेगमेंट पूरा होने पर अंतिम ट्रांसक्रिप्ट (final transcripts) को सबमिट करता है। यह अंतर मायने रखता है: आंशिक ट्रांसक्रिप्ट लाइव डिस्प्ले और कम-लेटेंसी वाले इरादे की पहचान (intent detection) के लिए बेहतरीन हैं; जबकि अंतिम ट्रांसक्रिप्ट वे हैं जिन्हें आप एलएलएम (LLM) को पास करते हैं, डेटाबेस में लिखते हैं, या अनुपालन लॉगिंग के लिए उपयोग करते हैं। एक एपीआई जो केवल अंतिम परिणाम वापस करता है, वह आपको लेटेंसी और विश्वसनीयता में से किसी एक को चुनने के लिए मजबूर करता है।

3. वास्तविक परिस्थितियों में वर्ड एरर रेट (WER)

साफ स्टूडियो ऑडियो पर मापे गए बेंचमार्क WER नंबर प्रोडक्शन के उपयोग के लिए लगभग अर्थहीन हैं। आप यह जानना चाहते हैं कि मॉडल टेलीफोनी ऑडियो (8kHz, mulaw-एन्कोडेड, बैकग्राउंड नॉइज़), गैर-देशी लहजे (non-native accents), विशिष्ट शब्दावली (चिकित्सा, कानूनी, वित्तीय), और वाक्य के बीच में भाषाओं को बदलने (code-switching) पर कैसा प्रदर्शन करता है। किसी प्रदाता को चुनने से पहले, ऐसे ऑडियो पर परीक्षण करें जो आपके वास्तविक वर्कलोड जैसा दिखता हो, न कि किसी चुनिंदा डेटासेट पर।

4. नेटिव एनरिचमेंट बनाम अलग से जोड़ी गई पाइपलाइनें

कई एएसआर प्रदाता आपको केवल ट्रांसक्राइब किया गया टेक्स्ट देते हैं और कुछ नहीं, जिससे आपको स्पीकर डायराइजेशन, PII संपादन, भावना विश्लेषण, या वर्ड-लेवल टाइमस्टैम्प के लिए अलग-अलग सेवाओं को जोड़ने का काम खुद करना पड़ता है। हर अतिरिक्त सेवा लेटेंसी, लागत और विफलता की संभावना को बढ़ाती है। एक अच्छी तरह से डिज़ाइन किया गया रीयल-टाइम एएसआर एपीआई इन क्षमताओं को मूल रूप से स्ट्रीमिंग पाथ में ही शामिल करता है ताकि आपको वह सब कुछ एक ही JSON रिस्पॉन्स में मिल जाए जिसकी आपको आवश्यकता है - ट्रांसक्रिप्ट, स्पीकर आईडी, टाइमस्टैम्प, भावनाएं - बिना किसी बहु-चरणीय पाइपलाइन को बनाए।

5. ऑडियो फ़ॉर्मेट और कोडेक लचीलापन (Codec Flexibility)

आपका ऑडियो स्रोत आपके कोडेक को निर्धारित करता है। ब्राउज़र-आधारित एप्लिकेशन आमतौर पर WebRTC के माध्यम से Opus उत्पन्न करते हैं। PSTN टेलीफोनी 8kHz पर mulaw पर चलती है। आंतरिक मीटिंग टूल अक्सर 16kHz या उससे अधिक पर linear16 कैप्चर करते हैं। एक एएसआर एपीआई जो केवल एक फ़ॉर्मेट स्वीकार करता है, वह आपको अपने सर्वर पर ऑडियो को ट्रांसकोड करने के लिए मजबूर करता है, जिससे एक भी शब्द की पहचान होने से पहले सीपीयू का ओवरहेड और लेटेंसी बढ़ जाती है। linear16, mulaw, alaw और Opus/OGG के लिए समर्थन एक प्रोडक्शन-ग्रेड स्ट्रीमिंग एपीआई के लिए बुनियादी आवश्यकता है।

6. सेशन मैनेजमेंट और कनेक्शन विश्वसनीयता

लंबे समय तक चलने वाली कॉल या मल्टी-टर्न वॉयस एजेंट सेशन के लिए, आपके वेबसॉकेट कनेक्शन को केवल कुछ सेकंड के लिए ही नहीं, बल्कि एक समय में कई मिनटों तक सक्रिय और स्थिर रहने की आवश्यकता होती है। एक अच्छा एपीआई लगातार चलने वाले सेशन के लिए डिज़ाइन किया गया है - यह शांति (silence) को आसानी से संभालता है, समय से पहले सेगमेंट को बंद नहीं करता है, और स्पष्ट रीकनेक्शन प्रक्रिया प्रदान करता है ताकि आपका एप्लिकेशन ट्रांसक्रिप्ट संदर्भ खोए बिना टूटे हुए कनेक्शन को आसानी से बहाल कर सके।

7. बहुभाषी और कोड-स्विचिंग समर्थन

वैश्विक एप्लिकेशन्स में प्रति सेशन केवल एक ही भाषा मान लेने की सुविधा नहीं होती है। उपयोगकर्ता वाक्य के बीच में हिंदी और अंग्रेजी बदलते रहते हैं। सहायता एजेंट एक ही शिफ्ट के भीतर कई भाषाओं में कॉल करने वालों को सेवाएं देते हैं। एक एएसआर एपीआई जो आपसे कनेक्शन के समय एक निश्चित भाषा घोषित करने की मांग करता है, वह इन मामलों में विफल हो जाएगा। ऑटो-डिटेक्शन और स्ट्रीम के बीच में भाषा बदलना अंतरराष्ट्रीय उत्पादों के लिए केवल एक अतिरिक्त सुविधा नहीं है - यह एक आवश्यकता है।

Waves Pulse STT API को इन सभी बाधाओं को ध्यान में रखकर बनाया गया था। इस गाइड का बाकी हिस्सा आपको दिखाता है कि इसे वास्तविक कोड के साथ ठीक से कैसे एकीकृत किया जाए, ताकि आप अपने खुद के वर्कलोड पर इन दावों का परीक्षण कर सकें।

पल्स एसटीटी (Pulse STT) API के साथ शुरुआत करना

चरण 1: अपनी API की (Key) बनाएं

Waves API के सभी अनुरोधों को एक API की से जुड़े बियरर (Bearer) टोकन के साथ प्रमाणित किया जाता है।

1. Smallest AI कंसोल एपीआई कीज़ पेज पर जाएं।

2. साइन अप करें या अपने अकाउंट में लॉग इन करें।

3. Create New API Key पर क्लिक करें, इसे एक विवरणात्मक नाम दें, और जेनरेट की गई की को तुरंत कॉपी कर लें (यह दोबारा नहीं दिखाई जाएगी)।

4. इसे एक एनवायरनमेंट वेरिएबल के रूप में एक्सपोर्ट करें:

चरण 2: बियरर टोकन के साथ प्रमाणित करें

Waves API के प्रत्येक अनुरोध में बियरर टोकन के रूप में फ़ॉर्मेट की गई आपकी की के साथ एक ऑथराइज़ेशन हेडर शामिल होना चाहिए:

वेबसॉकेट कनेक्शन के लिए, इसे wss:// कनेक्शन स्थापित करते समय कनेक्शन हेडर के हिस्से के रूप में पास किया जाता है।

पायथन बैच ट्रांसक्रिप्शन उदाहरण (Python Batch Transcription Example)

import os
import requests

API_KEY = os.getenv("SMALLEST_API_KEY")
audio_file = "meeting_recording.wav"

url = "https://waves-api.smallest.ai/api/v1/pulse/get_text"
params = {
    "model": "pulse",
    "language": "en",
    "word_timestamps": "true",
    "diarize": "true",
    "emotion_detection": "true"
}
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "audio/wav"
}

with open(audio_file, "rb") as f:
    audio_data = f.read()

response = requests.post(url, params=params, headers=headers, data=audio_data)
result = response.json()

print("Transcription:", result.get("transcription"))

for word in result.get("words", []):
    speaker = word.get("speaker", "N/A")
    print(f"  [Speaker {speaker}] [{word['start']:.2f}s - {word['end']:.2f}s] {word['word']}")

if "emotions" in result:
    print("\nEmotions detected:")
    for emotion, score in result["emotions"].items():
        if score > 0.1:
            print(f"  {emotion}: {score:.1%}")

import os
import requests

API_KEY = os.getenv("SMALLEST_API_KEY")
audio_file = "meeting_recording.wav"

url = "https://waves-api.smallest.ai/api/v1/pulse/get_text"
params = {
    "model": "pulse",
    "language": "en",
    "word_timestamps": "true",
    "diarize": "true",
    "emotion_detection": "true"
}
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "audio/wav"
}

with open(audio_file, "rb") as f:
    audio_data = f.read()

response = requests.post(url, params=params, headers=headers, data=audio_data)
result = response.json()

print("Transcription:", result.get("transcription"))

for word in result.get("words", []):
    speaker = word.get("speaker", "N/A")
    print(f"  [Speaker {speaker}] [{word['start']:.2f}s - {word['end']:.2f}s] {word['word']}")

if "emotions" in result:
    print("\nEmotions detected:")
    for emotion, score in result["emotions"].items():
        if score > 0.1:
            print(f"  {emotion}: {score:.1%}")

import os
import requests

API_KEY = os.getenv("SMALLEST_API_KEY")
audio_file = "meeting_recording.wav"

url = "https://waves-api.smallest.ai/api/v1/pulse/get_text"
params = {
    "model": "pulse",
    "language": "en",
    "word_timestamps": "true",
    "diarize": "true",
    "emotion_detection": "true"
}
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "audio/wav"
}

with open(audio_file, "rb") as f:
    audio_data = f.read()

response = requests.post(url, params=params, headers=headers, data=audio_data)
result = response.json()

print("Transcription:", result.get("transcription"))

for word in result.get("words", []):
    speaker = word.get("speaker", "N/A")
    print(f"  [Speaker {speaker}] [{word['start']:.2f}s - {word['end']:.2f}s] {word['word']}")

if "emotions" in result:
    print("\nEmotions detected:")
    for emotion, score in result["emotions"].items():
        if score > 0.1:
            print(f"  {emotion}: {score:.1%}")

यह उदाहरण स्पीकर पहचान और भावना विश्लेषण के साथ पूर्ण बैच ट्रांसक्रिप्शन को दर्शाता है। कोड एक WAV फ़ाइल को पढ़ता है, सभी उपलब्ध फीचर्स को कॉन्फ़िगर करता है, और शब्द-स्तर के विवरण और भावनात्मक संदर्भ सहित संपूर्ण API रिस्पॉन्स को प्रोसेस करता है।

आउटपुट:

वेबसॉकेट कार्यान्वयन (WebSocket Implementation): रीयल टाइम एएसआर एपीआई से जुड़ना

Pulse STT real time ASR API को वेबसॉकेट कनेक्शन के माध्यम से यहाँ एक्सेस किया जाता है: wss://waves-api.smallest.ai/api/v1/pulse/get_text

कॉन्फ़िगरेशन पैरामीटर्स को वेबसॉकेट यूआरएल पर क्वेरी स्ट्रिंग पैरामीटर्स के रूप में पास किया जाता है, न कि किसी अलग JSON इनिशियलाइज़ेशन संदेश में। जैसे ही आप सॉकेट खोलते हैं, आपकी भाषा, एन्कोडिंग, सैंपल रेट और फीचर फ़्लैग कनेक्शन यूआरएल में शामिल हो जाते हैं।

पायथन वेबसॉकेट कनेक्शन उदाहरण

यहाँ बताया गया है कि websockets पायथन लाइब्रेरी का उपयोग करके कैसे कनेक्ट किया जाए:

# file name: websocket.py
import asyncio
import json
import os
import websockets

API_KEY = os.environ.get("SMALLEST_API_KEY")

async def transcribe_stream():
    # Build the WebSocket URL with query parameters
    params = {
        "language": "en",
        "encoding": "linear16",
        "sample_rate": "16000",
        "word_timestamps": "true",
    }
    query_string = "&".join(f"{k}={v}" for k, v in params.items())
    uri = f"wss://waves-api.smallest.ai/api/v1/pulse/get_text?{query_string}"

    # Connect with Bearer token authentication header
    headers = {"Authorization": f"Bearer {API_KEY}"}

    async with websockets.connect(uri, extra_headers=headers) as ws:
        print("Connected to Pulse STT")

        # Launch concurrent tasks: send audio & receive transcripts
        send_task = asyncio.create_task(send_audio(ws))
        recv_task = asyncio.create_task(receive_transcripts(ws))

        await asyncio.gather(send_task, recv_task)

async def send_audio(ws):
    """Read audio from a source and stream it to the WebSocket."""
    with open("audio_16k_mono.raw", "rb") as f:
        while True:
            chunk = f.read(4096) # Recommended chunk size
            if not chunk:
                break
            await ws.send(chunk)
            await asyncio.sleep(0.05) # Pace stream to simulate real-time

async def receive_transcripts(ws):
    """Receive and process transcript responses from the server."""
    async for message in ws:
        response = json.loads(message)
        if response.get("transcript"):
            status = "FINAL" if response.get("is_final") else "PARTIAL"
            lang = response.get("language", "unknown")
            print(f"[{status}] ({lang}): {response['transcript']}")
            
            # Access word timestamps if enabled
            if "words" in response:
                for word in response["words"]:
                    print(f"  {word['word']}: {word['start']:.2f}s - {word['end']:.2f}s")

asyncio.run(transcribe_stream())

# file name: websocket.py
import asyncio
import json
import os
import websockets

API_KEY = os.environ.get("SMALLEST_API_KEY")

async def transcribe_stream():
    # Build the WebSocket URL with query parameters
    params = {
        "language": "en",
        "encoding": "linear16",
        "sample_rate": "16000",
        "word_timestamps": "true",
    }
    query_string = "&".join(f"{k}={v}" for k, v in params.items())
    uri = f"wss://waves-api.smallest.ai/api/v1/pulse/get_text?{query_string}"

    # Connect with Bearer token authentication header
    headers = {"Authorization": f"Bearer {API_KEY}"}

    async with websockets.connect(uri, extra_headers=headers) as ws:
        print("Connected to Pulse STT")

        # Launch concurrent tasks: send audio & receive transcripts
        send_task = asyncio.create_task(send_audio(ws))
        recv_task = asyncio.create_task(receive_transcripts(ws))

        await asyncio.gather(send_task, recv_task)

async def send_audio(ws):
    """Read audio from a source and stream it to the WebSocket."""
    with open("audio_16k_mono.raw", "rb") as f:
        while True:
            chunk = f.read(4096) # Recommended chunk size
            if not chunk:
                break
            await ws.send(chunk)
            await asyncio.sleep(0.05) # Pace stream to simulate real-time

async def receive_transcripts(ws):
    """Receive and process transcript responses from the server."""
    async for message in ws:
        response = json.loads(message)
        if response.get("transcript"):
            status = "FINAL" if response.get("is_final") else "PARTIAL"
            lang = response.get("language", "unknown")
            print(f"[{status}] ({lang}): {response['transcript']}")
            
            # Access word timestamps if enabled
            if "words" in response:
                for word in response["words"]:
                    print(f"  {word['word']}: {word['start']:.2f}s - {word['end']:.2f}s")

asyncio.run(transcribe_stream())

# file name: websocket.py
import asyncio
import json
import os
import websockets

API_KEY = os.environ.get("SMALLEST_API_KEY")

async def transcribe_stream():
    # Build the WebSocket URL with query parameters
    params = {
        "language": "en",
        "encoding": "linear16",
        "sample_rate": "16000",
        "word_timestamps": "true",
    }
    query_string = "&".join(f"{k}={v}" for k, v in params.items())
    uri = f"wss://waves-api.smallest.ai/api/v1/pulse/get_text?{query_string}"

    # Connect with Bearer token authentication header
    headers = {"Authorization": f"Bearer {API_KEY}"}

    async with websockets.connect(uri, extra_headers=headers) as ws:
        print("Connected to Pulse STT")

        # Launch concurrent tasks: send audio & receive transcripts
        send_task = asyncio.create_task(send_audio(ws))
        recv_task = asyncio.create_task(receive_transcripts(ws))

        await asyncio.gather(send_task, recv_task)

async def send_audio(ws):
    """Read audio from a source and stream it to the WebSocket."""
    with open("audio_16k_mono.raw", "rb") as f:
        while True:
            chunk = f.read(4096) # Recommended chunk size
            if not chunk:
                break
            await ws.send(chunk)
            await asyncio.sleep(0.05) # Pace stream to simulate real-time

async def receive_transcripts(ws):
    """Receive and process transcript responses from the server."""
    async for message in ws:
        response = json.loads(message)
        if response.get("transcript"):
            status = "FINAL" if response.get("is_final") else "PARTIAL"
            lang = response.get("language", "unknown")
            print(f"[{status}] ({lang}): {response['transcript']}")
            
            # Access word timestamps if enabled
            if "words" in response:
                for word in response["words"]:
                    print(f"  {word['word']}: {word['start']:.2f}s - {word['end']:.2f}s")

asyncio.run(transcribe_stream())

आउटपुट:

स्ट्रीमिंग ऑडियो: फ़ॉर्मेट, सैंपल रेट और चंक साइज (Chunk Sizes)

अपने ऑडियो फ़ॉर्मेट को सही ढंग से कॉन्फ़िगर करना बेहद ज़रूरी है। घोषित encoding/sample_rate और वास्तविक ऑडियो डेटा के बीच विसंगति के कारण सटीकता कम हो जाएगी या प्रक्रिया पूरी तरह विफल हो जाएगी।

समर्थित ऑडियो एन्कोडिंग (Supported Audio Encodings)

• linear16: 16-बिट, लिटिल-एंडियन, साइन किया हुआ PCM (सामान्य उद्देश्य, उच्चतम गुणवत्ता)

• linear32: 32-बिट, लिटिल-एंडियन, फ्लोटिंग-पॉइंट PCM (उच्च-सटीकता पाइपलाइन)

• alaw: ए-लॉ (A-law) कंपेंडेड PCM (8-बिट) (यूरोपीय टेलीफोनी)

• mulaw: म्यू-लॉ (μ-law) कंपेंडेड PCM (8-बिट) (उत्तरी अमेरिकी PSTN/VoIP)

• opus / ogg_opus: ओपस (Opus) कंप्रेस्ड ऑडियो (WebRTC, ब्राउज़र, कम बैंडविड्थ)

समर्थित सैंपल रेट (Supported Sample Rates)

रीयल टाइम एएसआर एपीआई 8,000 Hz से 48,000 Hz तक के सैंपल रेट स्वीकार करता है:

• 8,000 Hz — मानक टेलीफोनी (PSTN, VoIP)

• 16,000 Hz — अधिकांश वॉयस/स्पीच एप्लिकेशन्स के लिए अनुशंसित

• 24,000 Hz+ — उच्च गुणवत्ता/स्टूडियो कैप्चर

अनुशंसित चंक साइज (Recommended Chunk Size)

ऑडियो स्ट्रीमिंग करते समय, अनुशंसित चंक साइज 4,096 बाइट्स है। छोटे चंक लेटेंसी को कम किए बिना ओवरहेड बढ़ाते हैं; बड़े चंक अनावश्यक बफरिंग देरी पैदा करते हैं।

एपीआई रिस्पॉन्स को संभालना (Handling API Responses)

Pulse STT API द्वारा लौटाया गया प्रत्येक संदेश एक JSON ऑब्जेक्ट होता है।

मुख्य रिस्पॉन्स स्कीमा (Core Response Schema)

{  "session_id": "sess_12345abcde",  "transcript": "Hello, how are you?",  "is_final": true,  "is_last": false,  "language": "en"}

{  "session_id": "sess_12345abcde",  "transcript": "Hello, how are you?",  "is_final": true,  "is_last": false,  "language": "en"}

{  "session_id": "sess_12345abcde",  "transcript": "Hello, how are you?",  "is_final": true,  "is_last": false,  "language": "en"}

• आंशिक ट्रांसक्रिप्ट (is_final: false): स्पीकर के बोलते रहने के दौरान मिलने वाले मध्यवर्ती परिणाम। लाइव यूआई डिस्प्ले को अपडेट करने के लिए बेहतरीन हैं।

• अंतिम ट्रांसक्रिप्ट (is_final: true): पूरे हो चुके स्पीच सेगमेंट के पुख्ता परिणाम। इन्हें डेटाबेस में लिखने या एलएलएम (LLM) को पास करने के लिए सुरक्षित माना जाता है।

रीयल टाइम एएसआर एपीआई (Real Time ASR API) की उन्नत विशेषताएं

Pulse STT उन्नत सुविधाओं को सीधे स्ट्रीमिंग पाथ में उपलब्ध कराता है।

1. स्पीकर डायराइजेशन (Speaker Diarization)

diarize=true जोड़कर पहचानें कि किसी भी समय कौन बोल रहा है। words एरे और utterances एरे दोनों में एक पूर्णांक speaker आईडी और एक speaker_confidence स्कोर शामिल होगा।

2. वर्ड और सेंटेंस टाइमस्टैम्प (Word & Sentence Timestamps)

• word_timestamps=true: प्रत्येक शब्द के शुरू और समाप्त होने का समय जेनरेट करता है (SRT/VTT जैसे सबटाइटल ट्रैक के लिए महत्वपूर्ण)।

• sentence_timestamps=true: शब्दों को पठनीय वाक्य खंडों (utterance segments) में एकत्रित करता है।

3. भाषा पहचान और बहुभाषी समर्थन

मल्टी-स्पीकर स्ट्रीम्स के लिए जहाँ भाषा पहले से ज्ञात नहीं है, Pulse STT स्ट्रीम के बीच में ऑटो-डिटेक्शन का समर्थन करता है। भाषा पैरामीटर को multi या auto पर सेट करें। एपीआई बिना सेशन को रीस्टार्ट किए आसानी से भाषाओं के बीच (जैसे, अंग्रेजी से स्पेनिश से हिंदी) बदल जाएगा।

सर्वोत्तम प्रथाएं और प्रदर्शन अनुकूलन (Performance Optimization)

अपने रीयल टाइम एएसआर एपीआई से सबसे कम लेटेंसी और उच्चतम सटीकता प्राप्त करने के लिए, इन दिशानिर्देशों का पालन करें:

• इष्टतम ऑडियो कॉन्फ़िगरेशन (Optimal Audio Configuration):

  • वॉयस असिस्टेंट/मीटिंग्स: sample_rate=16000 पर encoding=linear16 का उपयोग करें।

  • टेलीफोनी/PSTN: ट्रांसकोडिंग ओवरहेड से बचने के लिए sample_rate=8000 पर encoding=mulaw का उपयोग करें।

  • ब्राउज़र/WebRTC: अपने सर्वर पर डीकंप्रेशन चक्रों को छोड़ने के लिए encoding=opus का उपयोग करें।

• स्ट्रीमिंग दर (Streaming Rate): ऑडियो चंक्स को लगभग सामान्य प्लेबैक दर (हर 50-100 ms में) पर भेजें। रीयल-टाइम से तेज़ी से डेटा भेजने से बैकप्रेशर बन सकता है; बहुत धीमे भेजने से स्पीच सेगमेंट समय से पहले बंद हो सकते हैं।

• ऑडियो गुणवत्ता: हमेशा ऑडियो को मोनो (mono) (सिंगल चैनल) के रूप में रिकॉर्ड करें। एएसआर मॉडल मोनो स्पीच पर ही प्रशिक्षित होते हैं। जब भी संभव हो कैप्चर लेयर (जैसे ब्राउज़र MediaDevices या RNNoise) पर नॉइज़ सप्रेशन का उपयोग करें।

• कनेक्शन सक्रिय रखें: 64ms TTFT लक्ष्य की तुलना में कनेक्शन सेटअप ओवरहेड काफी महत्वपूर्ण होता है। प्रत्येक वाक्य के बीच सॉकेट को खोलने/बंद करने के बजाय पूरे सेशन के दौरान अपना वेबसॉकेट कनेक्शन खुला रखें।

अगले कदम

Pulse STT API एक उद्देश्य-निर्मित real time ASR API है जो तेज़, सटीक और सुविधा संपन्न स्ट्रीमिंग ट्रांसक्रिप्शन प्रदान करता है। इसका सिंगल-एंडपॉइंट डिज़ाइन बहु-स्तरीय स्पीच इंटेलिजेंस पाइपलाइनों को बनाने और बनाए रखने की आवश्यकता को समाप्त करता है।

क्या आप निर्माण शुरू करने के लिए तैयार हैं?

1. कुकबुक एक्सप्लोर करें: Smallest AI कुकबुक में रीयल-टाइम माइक्रोफ़ोन ट्रांसक्रिप्शन, टेलीफोनी एकीकरण और वॉयस एजेंटों के लिए रेडी-टू-डिप्लॉय उदाहरण शामिल हैं।

2. सुविधाओं के साथ प्रयोग करें: बेहतरीन बातचीत विश्लेषण अनलॉक करने के लिए अपने यूआरएल में diarize=true और sentence_timestamps=true जोड़कर देखें।

कम्युनिटी से जुड़ें: आप जो कुछ भी बना रहे हैं उसे साझा करने के लिए डिस्कॉर्ड सर्वर में Smallest AI टीम और अन्य डेवलपर्स से जुड़ें!