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

Pulse स्पीच टू टेक्स्ट एपीआई क्या है

Pulse, Smallest AI का स्पीच रिकग्निशन मॉडल है। यह दो मोड के माध्यम से ऑडियो को टेक्स्ट में परिवर्तित करता है: प्री-रिकॉर्डेड और रीयल-टाइम।

प्री-रिकॉर्डेड ट्रांसक्रिप्शन ऑडियो फाइलों को स्वीकार करता है और एकल सिंक्रोनस HTTP रिस्पॉन्स में एक पूर्ण ट्रांसक्रिप्ट लौटाता है। यह बैच प्रोसेसिंग, आर्काइव की गई रिकॉर्डिंग और ऐसे किसी भी वर्कफ़्लो के लिए सही विकल्प है जहां आप पूर्ण परिणाम के लिए प्रतीक्षा कर सकते हैं।

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

दोनों मोड एक ही बेस URL साझा करते हैं। प्री-रिकॉर्डेड अनुरोध HTTPS POST के रूप में https://api.smallest.ai/waves/v1/pulse/get_text पर जाते हैं। रीयल-टाइम अनुरोध वेबसोकेट के रूप में wss://api.smallest.ai/waves/v1/pulse/get_text से कनेक्ट होते हैं।

ऑथेंटिकेशन (प्रमाणीकरण)

Smallest AI कंसोल से एक एपीआई की (API key) प्राप्त करें।

export SMALLEST_API_KEY="your-api-key-here"

export SMALLEST_API_KEY="your-api-key-here"

export SMALLEST_API_KEY="your-api-key-here"

प्रत्येक अनुरोध ऑथराइजेशन हेडर में की (key) को ले जाता है।

पाइथन में प्री-रिकॉर्डेड ट्रांसक्रिप्शन

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

import os
import requests
<p>def transcribe(file_path: str, language: str = "en") -> dict:<br>with open(file_path, "rb") as f:<br>audio_data = f.read()</p>
<pre><code>response = requests.post(
    "https://api.smallest.ai/waves/v1/pulse/get_text",
    params={
        "language": language,
        "word_timestamps": "true",
    },
    headers={
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "audio/wav",
    },
    data=audio_data,
)

response.raise_for_status()
return response.json()
</code></pre

import os
import requests
<p>def transcribe(file_path: str, language: str = "en") -> dict:<br>with open(file_path, "rb") as f:<br>audio_data = f.read()</p>
<pre><code>response = requests.post(
    "https://api.smallest.ai/waves/v1/pulse/get_text",
    params={
        "language": language,
        "word_timestamps": "true",
    },
    headers={
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "audio/wav",
    },
    data=audio_data,
)

response.raise_for_status()
return response.json()
</code></pre

import os
import requests
<p>def transcribe(file_path: str, language: str = "en") -> dict:<br>with open(file_path, "rb") as f:<br>audio_data = f.read()</p>
<pre><code>response = requests.post(
    "https://api.smallest.ai/waves/v1/pulse/get_text",
    params={
        "language": language,
        "word_timestamps": "true",
    },
    headers={
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "audio/wav",
    },
    data=audio_data,
)

response.raise_for_status()
return response.json()
</code></pre

एक बात तुरंत ध्यान देने योग्य है: रिस्पॉन्स फ़ील्ड transcription है, न कि transcript। यह अंतर तब मायने रखता है जब आप रिस्पॉन्स हैंडलर का निर्माण कर रहे होते हैं। एक सफल रिस्पॉन्स इस तरह दिखता है।

{<br>"status": "success",<br>"transcription": "Hello, this is a test transcription.",<br>"words": [<br>{"start": 0.48, "end": 1.12, "word": "Hello,"},<br>{"start": 1.12, "end": 1.28, "word": "this"},<br>{"start": 1.28, "end": 1.44, "word": "is"},<br>{"start": 1.44, "end": 2.16, "word": "a"},<br>{"start": 2.16, "end": 2.96, "word": "test"},<br>{"start": 2.96, "end": 3.76, "word": "transcription."}<br>],<br>"utterances": [<br>{"start": 0.48, "end": 3.76, "text": "Hello, this is a test transcription."}<br> ]<br>

{<br>"status": "success",<br>"transcription": "Hello, this is a test transcription.",<br>"words": [<br>{"start": 0.48, "end": 1.12, "word": "Hello,"},<br>{"start": 1.12, "end": 1.28, "word": "this"},<br>{"start": 1.28, "end": 1.44, "word": "is"},<br>{"start": 1.44, "end": 2.16, "word": "a"},<br>{"start": 2.16, "end": 2.96, "word": "test"},<br>{"start": 2.96, "end": 3.76, "word": "transcription."}<br>],<br>"utterances": [<br>{"start": 0.48, "end": 3.76, "text": "Hello, this is a test transcription."}<br> ]<br>

{<br>"status": "success",<br>"transcription": "Hello, this is a test transcription.",<br>"words": [<br>{"start": 0.48, "end": 1.12, "word": "Hello,"},<br>{"start": 1.12, "end": 1.28, "word": "this"},<br>{"start": 1.28, "end": 1.44, "word": "is"},<br>{"start": 1.44, "end": 2.16, "word": "a"},<br>{"start": 2.16, "end": 2.96, "word": "test"},<br>{"start": 2.96, "end": 3.76, "word": "transcription."}<br>],<br>"utterances": [<br>{"start": 0.48, "end": 3.76, "text": "Hello, this is a test transcription."}<br> ]<br>

words एरे आपको प्रति-शब्द समय प्रदान करता है, जो कैप्शन जनरेशन, सबटाइटल ट्रैक्स और कॉन्फिडेंस-आधारित वर्कफ़्लोज़ के लिए उपयोगी है। utterances एरे आपको समय के साथ वाक्य-स्तर के सेगमेंट देता है, जो संरचित कॉल सारांश और पठनीय ट्रांसक्रिप्ट के लिए उपयोगी है।

जब आपका ऑडियो पहले से ही किसी सुलभ स्थान पर होस्ट किया गया हो, तो आप रॉ बाइट्स के बजाय एक URL भेज सकते हैं।

import os<br>import requests<p></p>
<p>def transcribe_from_url(audio_url: str, language: str = "en") -> dict:<br>response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={"language": language, "word_timestamps": "true"},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "application/json",<br>},<br>json={"url": audio_url},<br>)</p>
<pre><code>response.raise_for_status()
return response.json()
</code></pre&/framer-module-translation-text

import os<br>import requests<p></p>
<p>def transcribe_from_url(audio_url: str, language: str = "en") -> dict:<br>response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={"language": language, "word_timestamps": "true"},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "application/json",<br>},<br>json={"url": audio_url},<br>)</p>
<pre><code>response.raise_for_status()
return response.json()
</code></pre&/framer-module-translation-text

import os<br>import requests<p></p>
<p>def transcribe_from_url(audio_url: str, language: str = "en") -> dict:<br>response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={"language": language, "word_timestamps": "true"},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "application/json",<br>},<br>json={"url": audio_url},<br>)</p>
<pre><code>response.raise_for_status()
return response.json()
</code></pre&/framer-module-translation-text

यह तब उपयोगी होता है जब ऑडियो फाइलें S3 या Google Cloud Storage जैसे क्लाउड स्टोरेज में होती हैं, जहां रॉ बाइट्स भेजने के लिए पहले फ़ाइल को स्थानीय रूप से डाउनलोड करना आवश्यक होता है।

नोड में प्री-रिकॉर्डेड ट्रांसक्रिप्शन

node-fetch का उपयोग करके नोड में यही कॉल इस प्रकार है।

const fs = require("fs");<br>const fetch = require("node-fetch");<p></p>
<p>async function transcribe(filePath, language = "en") {<br>const audioData = fs.readFileSync(filePath);</p>
<pre><code>const url = new URL("https://api.smallest.ai/waves/v1/pulse/get_text");
url.searchParams.set("language", language);
url.searchParams.set("word_timestamps", "true");

const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "audio/wav",
    },
    body: audioData,
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>
<p>}</p>

const fs = require("fs");<br>const fetch = require("node-fetch");<p></p>
<p>async function transcribe(filePath, language = "en") {<br>const audioData = fs.readFileSync(filePath);</p>
<pre><code>const url = new URL("https://api.smallest.ai/waves/v1/pulse/get_text");
url.searchParams.set("language", language);
url.searchParams.set("word_timestamps", "true");

const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "audio/wav",
    },
    body: audioData,
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>
<p>}</p>

const fs = require("fs");<br>const fetch = require("node-fetch");<p></p>
<p>async function transcribe(filePath, language = "en") {<br>const audioData = fs.readFileSync(filePath);</p>
<pre><code>const url = new URL("https://api.smallest.ai/waves/v1/pulse/get_text");
url.searchParams.set("language", language);
url.searchParams.set("word_timestamps", "true");

const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "audio/wav",
    },
    body: audioData,
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>
<p>}</p>

और रिमोट URL से।

async function transcribeFromUrl(audioUrl, language = "en") {<br>const url = new URL("<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>");<br>url.searchParams.set("language", language);<br>url.searchParams.set("word_timestamps", "true");<p></p>
<pre><code>const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "application/json",
    },
    body: JSON.stringify({ url: audioUrl }),
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>

async function transcribeFromUrl(audioUrl, language = "en") {<br>const url = new URL("<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>");<br>url.searchParams.set("language", language);<br>url.searchParams.set("word_timestamps", "true");<p></p>
<pre><code>const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "application/json",
    },
    body: JSON.stringify({ url: audioUrl }),
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>

async function transcribeFromUrl(audioUrl, language = "en") {<br>const url = new URL("<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>");<br>url.searchParams.set("language", language);<br>url.searchParams.set("word_timestamps", "true");<p></p>
<pre><code>const response = await fetch(url.toString(), {
    method: "POST",
    headers: {
        Authorization: `Bearer ${process.env.SMALLEST_API_KEY}`,
        "Content-Type": "application/json",
    },
    body: JSON.stringify({ url: audioUrl }),
});

if (!response.ok) {
    const error = await response.text();
    throw new Error(`Transcription failed: ${error}`);
}

return response.json();
</code></pre>

वैकल्पिक एनरिचमेंट फीचर्स

सभी एनरिचमेंट फीचर्स उसी एंडपॉइंट पर क्वेरी पैरामीटर हैं। अनुरोध के बारे में कुछ और बदले बिना किसी भी संयोजन को सक्षम करें।

response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={<br>"language": "en",<br>"word_timestamps": "true",<br>"emotion_detection": "true",<br>"age_detection": "true",<br>"gender_detection": "true",<br>"diarization": "true",<br>},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "audio/wav",<br>},<br>data=open("call_recording.wav", "rb").read(),<br>)<p></p

response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={<br>"language": "en",<br>"word_timestamps": "true",<br>"emotion_detection": "true",<br>"age_detection": "true",<br>"gender_detection": "true",<br>"diarization": "true",<br>},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "audio/wav",<br>},<br>data=open("call_recording.wav", "rb").read(),<br>)<p></p

response = requests.post(<br>"<a href="https://api.smallest.ai/waves/v1/pulse/get_text" data-framer-link="Link:{"url":"https://api.smallest.ai/waves/v1/pulse/get_text","type":"url"}">https://api.smallest.ai/waves/v1/pulse/get_text</a>",<br>params={<br>"language": "en",<br>"word_timestamps": "true",<br>"emotion_detection": "true",<br>"age_detection": "true",<br>"gender_detection": "true",<br>"diarization": "true",<br>},<br>headers={<br>"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",<br>"Content-Type": "audio/wav",<br>},<br>data=open("call_recording.wav", "rb").read(),<br>)<p></p

प्रत्येक फीचर के बारे में एक संक्षिप्त टिप्पणी जिसे सक्षम करना उचित है।

Word timestamps आपको हर शब्द के लिए शुरू और समाप्त होने का समय देते हैं। इसे सक्षम करना आसान है और बाद में इसका सटीक रूप से पुनर्निर्माण करना कठिन है। किसी भी ऐसे उपयोग के मामले के लिए इसे डिफ़ॉल्ट रूप से सक्षम करें जहां ट्रांसक्रिप्ट का समय मायने रखता है।

Utterances आपको समय के साथ वाक्य-स्तर के सेगमेंट देते हैं। कैप्शन प्रदर्शित करने, प्लेबैक सिंक करने और संरचित बातचीत रिकॉर्ड संग्रहीत करने के लिए उपयोगी।

Diarization ट्रांसक्रिप्ट को वक्ताओं के अनुसार अलग करता है। कॉल रिकॉर्डिंग या मीटिंग ट्रांसक्रिप्ट जैसे बहु-वक्ता ऑडियो के लिए, यह टेक्स्ट की एक दीवार को एक वर्गीकृत बातचीत में बदल देता है।

Emotion detection पांच मुख्य भावना प्रकारों में तीव्रता संकेतकों के साथ प्रत्येक सेगमेंट का भावनात्मक टोन लौटाता है। ग्राहक सेवा के संदर्भों में, एक कॉलर क्या कहता है और कैसे कहता है, इसके बीच का अंतर अक्सर शब्दों से अधिक मायने रखता है।

Age and gender detection प्रति वक्ता जनसांख्यिकीय अनुमान लौटाते हैं। ये संभाव्य संकेत हैं जो समग्र रूप से अच्छा प्रदर्शन करते हैं। व्यक्तिगत परिणामों को तथ्यों के बजाय केवल संकेत के रूप में मानें।

सटीकता, वर्ड एरर रेट (WER) और उन्हें क्या प्रभावित करता है

वर्ड एरर रेट (WER) ट्रांसक्रिप्शन सटीकता के लिए मानक मीट्रिक है। यह आउटपुट में उन शब्दों के प्रतिशत को मापता है जो संदर्भ ट्रांसक्रिप्ट से भिन्न होते हैं। 5% के WER का अर्थ है कि लगभग बीस शब्दों में से एक शब्द गलत है। स्वच्छ स्टूडियो ऑडियो पर, आधुनिक मॉडल आमतौर पर 3 से 5 प्रतिशत सटीकता प्राप्त करते हैं। शोर वाले फोन कॉल पर, वही मॉडल 15 से 20 प्रतिशत त्रुटि उत्पन्न कर सकता है।

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

आपके वास्तविक उपयोगकर्ताओं का प्रतिनिधित्व करने वाले ऑडियो के साथ परीक्षण करना किसी भी प्रकाशित बेंचमार्क की तुलना में अधिक जानकारीपूर्ण है। स्वच्छ अंग्रेजी ब्रॉडकास्ट ऑडियो पर 3% का WER आपको इस बारे में कुछ नहीं बताता कि मॉडल मुंबई या साओ पाउलो की कॉल सेंटर रिकॉर्डिंग के साथ क्या करेगा।

सैंपल रेट पर: सटीकता 16kHz से नीचे काफी गिर जाती है। यदि आपकी पाइपलाइन पुराने टेलीफोनी इंफ्रास्ट्रक्चर से 8kHz ऑडियो उत्पन्न कर रही है, तो भेजने से पहले इसे 16kHz पर रीसैंपल करना ओवरहेड के लायक है।

भाषा समर्थन

language क्वेरी पैरामीटर में ISO 639-1 भाषा कोड पास करें। ऐसे ऑडियो के लिए जहां वक्ता बातचीत के बीच में भाषाओं को बदलते हैं, स्वचालित भाषा पहचान और स्विचिंग के लिए language=multi का उपयोग करें।

उच्च-संसाधन वाली भाषाएँ कम-संसाधन वाली भाषाओं की तुलना में कम त्रुटि दर प्राप्त करती हैं। यदि आपके उपयोगकर्ता किसी विशिष्ट भाषा समुदाय में केंद्रित हैं, तो समग्र WER आंकड़ों के बजाय उस समुदाय के ऑडियो नमूनों के विरुद्ध परीक्षण करें।

रीयल-टाइम स्ट्रीमिंग ट्रांसक्रिप्शन

बैच ट्रांसक्रिप्शन वापस लौटने से पहले पूरा होने पर काम करता है। रीयल-टाइम ट्रांसक्रिप्शन ऑडियो के आने के दौरान लगातार वापस लौटकर काम करता है। वह अंतर इसके साथ आपके निर्माण के तरीके को पूरी तरह से बदल देता है।

रीयल-टाइम एपीआई वेबसोकेट पर wss://api.smallest.ai/waves/v1/pulse/get_text से कनेक्ट होता है। ऑडियो 4096 बाइट्स के रॉ बाइनरी फ्रेम के रूप में जाता है। ट्रांसक्रिप्ट इवेंट एक is_final फ़्लैग के साथ JSON संदेशों के रूप में वापस आते हैं जो आपको बताता है कि परिणाम अनंतिम है या अंतिम।

जब आप वेबसोकेट स्थापित करते हैं तो कनेक्शन पैरामीटर URL क्वेरी पैरामीटर के रूप में जाते हैं।

const API_KEY = process.env.SMALLEST_API_KEY;<p></p>
<p>const url = new URL("wss://api.smallest.ai/waves/v1/pulse/get_text");<br>url.searchParams.append("language", "en");<br>url.searchParams.append("encoding", "linear16");<br>url.searchParams.append("sample_rate", "16000");<br>url.searchParams.append("word_timestamps", "true");</p>
<p>const ws = new WebSocket(url.toString(), {<br>headers: {<br>Authorization: <code>Bearer ${API_KEY}</code>,<br>},<br>});</p>
<p>ws.onopen = () => {<br>console.log("Connected to Pulse STT");<br>};</p>
<p>ws.onmessage = (event) => {<br>const data = JSON.parse(event.data);<br>if (data.is_final) {<br>console.log("\n[FINAL]", data.transcript);<br>console.log("[FULL SESSION]", data.full_transcript);<br>} else {<br>process.stdout.write(<code>\r${data.transcript}</code>);<br>}<br>};</p>
<p>function sendAudioChunk(audioBuffer) {<br>if (ws.readyState === WebSocket.OPEN) {<br>ws.send(audioBuffer);<br>}<br>}</p>

const API_KEY = process.env.SMALLEST_API_KEY;<p></p>
<p>const url = new URL("wss://api.smallest.ai/waves/v1/pulse/get_text");<br>url.searchParams.append("language", "en");<br>url.searchParams.append("encoding", "linear16");<br>url.searchParams.append("sample_rate", "16000");<br>url.searchParams.append("word_timestamps", "true");</p>
<p>const ws = new WebSocket(url.toString(), {<br>headers: {<br>Authorization: <code>Bearer ${API_KEY}</code>,<br>},<br>});</p>
<p>ws.onopen = () => {<br>console.log("Connected to Pulse STT");<br>};</p>
<p>ws.onmessage = (event) => {<br>const data = JSON.parse(event.data);<br>if (data.is_final) {<br>console.log("\n[FINAL]", data.transcript);<br>console.log("[FULL SESSION]", data.full_transcript);<br>} else {<br>process.stdout.write(<code>\r${data.transcript}</code>);<br>}<br>};</p>
<p>function sendAudioChunk(audioBuffer) {<br>if (ws.readyState === WebSocket.OPEN) {<br>ws.send(audioBuffer);<br>}<br>}</p>

const API_KEY = process.env.SMALLEST_API_KEY;<p></p>
<p>const url = new URL("wss://api.smallest.ai/waves/v1/pulse/get_text");<br>url.searchParams.append("language", "en");<br>url.searchParams.append("encoding", "linear16");<br>url.searchParams.append("sample_rate", "16000");<br>url.searchParams.append("word_timestamps", "true");</p>
<p>const ws = new WebSocket(url.toString(), {<br>headers: {<br>Authorization: <code>Bearer ${API_KEY}</code>,<br>},<br>});</p>
<p>ws.onopen = () => {<br>console.log("Connected to Pulse STT");<br>};</p>
<p>ws.onmessage = (event) => {<br>const data = JSON.parse(event.data);<br>if (data.is_final) {<br>console.log("\n[FINAL]", data.transcript);<br>console.log("[FULL SESSION]", data.full_transcript);<br>} else {<br>process.stdout.write(<code>\r${data.transcript}</code>);<br>}<br>};</p>
<p>function sendAudioChunk(audioBuffer) {<br>if (ws.readyState === WebSocket.OPEN) {<br>ws.send(audioBuffer);<br>}<br>}</p>

प्रत्येक इवेंट के लिए रिस्पॉन्स इन फ़ील्ड्स को ले जाता है।

{<br>"session_id": "sess_12345abcde",<br>"transcript": "Hello, how are you?",<br>"full_transcript": "Hello, how are you?",<br>"is_final": true,<br>"is_last": false,<br>"language": "en"<br>

{<br>"session_id": "sess_12345abcde",<br>"transcript": "Hello, how are you?",<br>"full_transcript": "Hello, how are you?",<br>"is_final": true,<br>"is_last": false,<br>"language": "en"<br>

{<br>"session_id": "sess_12345abcde",<br>"transcript": "Hello, how are you?",<br>"full_transcript": "Hello, how are you?",<br>"is_final": true,<br>"is_last": false,<br>"language": "en"<br>

transcript में वर्तमान सेगमेंट होता है। full_transcript में पूरे सत्र के लिए संचयी (cumulative) ट्रांसक्रिप्ट होती है। जब is_final ट्रू (true) हो, तो अपने चल रहे सत्र लॉग को बनाए रखने के लिए full_transcript का उपयोग करें।

माइक्रोफ़ोन कैप्चर के लिए websockets और sounddevice का उपयोग करने वाला पाइथन समकक्ष।

import asyncio<br>import json<br>import os<br>import websockets<br>import sounddevice as sd<p></p>
<p>SAMPLE_RATE = 16000<br>CHUNK_BYTES = 4096</p>
<p>async def stream_microphone():<br>url = (<br>"wss://api.smallest.ai/waves/v1/pulse/get_text"<br>f"?language=en&encoding=linear16&sample_rate={SAMPLE_RATE}&word_timestamps=true"<br>)<br>headers = {"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}"}</p>
<pre><code>async with websockets.connect(url, extra_headers=headers) as ws:
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time, status):
        loop.call_soon_threadsafe(audio_queue.put_nowait, bytes(indata))

    with sd.RawInputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="int16",
        blocksize=CHUNK_BYTES // 2,
        callback=audio_callback,
    ):
        async def send_audio():
            while True:
                chunk = await audio_queue.get()
                await ws.send(chunk)

        async def receive_events():
            async for message in ws:
                data = json.loads(message)
                if data.get("is_final"):
                    print(f"\n[FINAL] {data['transcript']}")
                else:
                    print(f"\r{data['transcript']}", end="", flush=True)

        await asyncio.gather(send_audio(), receive_events())
</code></pre&/framer-module-translation-text

import asyncio<br>import json<br>import os<br>import websockets<br>import sounddevice as sd<p></p>
<p>SAMPLE_RATE = 16000<br>CHUNK_BYTES = 4096</p>
<p>async def stream_microphone():<br>url = (<br>"wss://api.smallest.ai/waves/v1/pulse/get_text"<br>f"?language=en&encoding=linear16&sample_rate={SAMPLE_RATE}&word_timestamps=true"<br>)<br>headers = {"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}"}</p>
<pre><code>async with websockets.connect(url, extra_headers=headers) as ws:
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time, status):
        loop.call_soon_threadsafe(audio_queue.put_nowait, bytes(indata))

    with sd.RawInputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="int16",
        blocksize=CHUNK_BYTES // 2,
        callback=audio_callback,
    ):
        async def send_audio():
            while True:
                chunk = await audio_queue.get()
                await ws.send(chunk)

        async def receive_events():
            async for message in ws:
                data = json.loads(message)
                if data.get("is_final"):
                    print(f"\n[FINAL] {data['transcript']}")
                else:
                    print(f"\r{data['transcript']}", end="", flush=True)

        await asyncio.gather(send_audio(), receive_events())
</code></pre&/framer-module-translation-text

import asyncio<br>import json<br>import os<br>import websockets<br>import sounddevice as sd<p></p>
<p>SAMPLE_RATE = 16000<br>CHUNK_BYTES = 4096</p>
<p>async def stream_microphone():<br>url = (<br>"wss://api.smallest.ai/waves/v1/pulse/get_text"<br>f"?language=en&encoding=linear16&sample_rate={SAMPLE_RATE}&word_timestamps=true"<br>)<br>headers = {"Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}"}</p>
<pre><code>async with websockets.connect(url, extra_headers=headers) as ws:
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time, status):
        loop.call_soon_threadsafe(audio_queue.put_nowait, bytes(indata))

    with sd.RawInputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="int16",
        blocksize=CHUNK_BYTES // 2,
        callback=audio_callback,
    ):
        async def send_audio():
            while True:
                chunk = await audio_queue.get()
                await ws.send(chunk)

        async def receive_events():
            async for message in ws:
                data = json.loads(message)
                if data.get("is_final"):
                    print(f"\n[FINAL] {data['transcript']}")
                else:
                    print(f"\r{data['transcript']}", end="", flush=True)

        await asyncio.gather(send_audio(), receive_events())
</code></pre&/framer-module-translation-text

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

await ws.send(json.dumps({"type": "finalize"}))

await ws.send(json.dumps({"type": "finalize"}))

await ws.send(json.dumps({"type": "finalize"}))

बैच बनाम रीयल-टाइम: निर्णय लेने वाले कारक

मोड के बीच चुनाव इस बात पर निर्भर करता है कि आपका एप्लिकेशन पूर्ण परिणाम के लिए प्रतीक्षा कर सकता है या ऑडियो आने के दौरान ही आंशिक परिणाम की आवश्यकता है।

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

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

दोनों मोड अलग-अलग रिस्पॉन्स स्ट्रक्चर भी लौटाते हैं, और निर्माण करने से पहले इसकी योजना बनाना उचित है। प्री-रिकॉर्डेड transcription, words, और utterances के साथ एक सिंगल JSON ऑब्जेक्ट लौटाता है। रीयल-टाइम इवेंट्स का एक स्ट्रीम लौटाता है जहां प्रत्येक संदेश में transcript, full_transcript, और is_final होता है। यदि आपका रिस्पॉन्स हैंडलर उन्हें एक समान मानता है, तो आपको साइलेंट बग्स का सामना करना पड़ेगा।

अगले कदम

Smallest AI कुकबुक देखें, जो Smallest AI के APIs के साथ निर्माण करने के लिए वास्तविक दुनिया के उदाहरणों और ट्यूटोरियल का एक व्यापक संग्रह है, जिसमें बुनियादी ट्रांसक्रिप्शन, वॉयस एजेंट और उन्नत फीचर्स शामिल हैं।

स्पीच-टू-टेक्स्ट उदाहरण:

1. शुरुआत करना: पाइथन और जावास्क्रिप्ट के लिए बुनियादी ट्रांसक्रिप्शन उदाहरण

2. जार्विस वॉयस असिस्टेंट: वेक वर्ड डिटेक्शन, एलएलएम रीज़निंग और टीटीएस इंटीग्रेशन के साथ पूर्ण ऑलवेज-ऑन असिस्टेंट

3. मीटिंग नोट्स बॉट: बुद्धिमान वक्ता पहचान और संरचित नोट जनरेशन के साथ स्वचालित मीटिंग ट्रांसक्रिप्शन

4. इमोशन एनालाइज़र: इंटरैक्टिव चार्ट्स के साथ बातचीत के दौरान वक्ता की भावनाओं को विज़ुअलाइज़ करें

एपीआई संदर्भ: Pulse STT क्विकस्टार्ट, प्री-रिकॉर्डेड एपीआई, रीयल-टाइम वेबसोकेट एपीआई