एक रियल-टाइम वॉयस एजेंट कैसे बनाएं

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

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

• अपने प्रोजेक्ट एनवायरनमेंट को सेट अप करें

• Pulse (STT) के साथ ऑडियो इनपुट को कैप्चर और स्ट्रीम करें

• ट्रांसक्रिप्ट को एक लैंग्वेज मॉडल से कनेक्ट करें

• Lightning (TTS) के साथ LLM रिस्पॉन्स को स्पीच में बदलें

• इंटरप्ट हैंडलिंग और टर्न-टेकिंग के साथ लूप को पूरा करें

शुरू करने से पहले आपको क्या चाहिए

कोड को छूने से पहले, बुनियादी चीज़ों को व्यवस्थित कर लें। टूलिंग: Python 3.9+, एक कोड एडिटर, और एक चालू माइक्रोफ़ोन के साथ एक टेस्ट सेटअप। आपको Lightning (TTS), Pulse (STT), और Electron के लिए Smallest.ai के Waves प्लेटफॉर्म तक एपीआई एक्सेस की भी आवश्यकता होगी, साथ ही यदि आप एक बाहरी लैंग्वेज मॉडल का उपयोग करना पसंद करते हैं तो कोई भी कम्पैटिबल LLM एंडपॉइंट। अपेक्षित ज्ञान: एसिंक पायथन, REST कॉल्स करना, और ऑडियो स्ट्रीम के साथ सामान्य सहजता। आपको डीएसपी (DSP) की गहरी समझ की आवश्यकता नहीं है, लेकिन एक व्यावहारिक विवरण को याद रखना मददगार होगा: ऑडियो बाइट्स की एक निरंतर स्ट्रीम के रूप में दिखाई देता है, न कि साफ-सुथरी छोटी फाइलों के रूप में। इसे शुरुआत से ही एक स्ट्रीम की तरह समझें और आप बाद में आने वाली इस निराशाजनक समस्या से बच जाएंगे कि "यह इतना धीमा क्यों चल रहा है?"।

एक रीयल-टाइम वॉयस एजेंट वास्तव में कैसे काम करता है

यह लूप हमेशा एक जैसा रहता है: स्पीच-टू-टेक्स्ट (STT) उपयोगकर्ता की आवाज़ को टेक्स्ट में बदलता है, एक लैंग्वेज मॉडल उस टेक्स्ट से प्रतिक्रिया उत्पन्न करता है, और टेक्स्ट-टू-स्पीच (TTS) उस प्रतिक्रिया को वापस ऑडियो में बदल देता है। कठिन हिस्सा यह है कि लेटेंसी (देरी) बहुत तेज़ी से बढ़ती जाती है। यदि STT को 200ms की आवश्यकता है, LLM को पहला टोकन देने में 400ms लगते हैं, और TTS को पहला ऑडियो उत्पन्न करने में 300ms लगते हैं, तो आप नेटवर्क राउंड ट्रिप्स को गिने बिना ही पहले से ही एक-सेकंड के टाइम-टू-फर्स्ट-ऑडियो (TTFA) के करीब पहुंच रहे हैं।

इसका व्यावहारिक समाधान हर चीज़ को स्ट्रीमिंग-फर्स्ट बनाना है। रिकॉर्डिंग पूरी होने का इंतज़ार करने के बजाय ऑडियो को सीधे STT में स्ट्रीम करें। पूर्ण रूप से पूरा होने का इंतज़ार करने के बजाय जनरेट होते ही LLM से टोकन स्ट्रीम करें। फिर अंत तक पूरे उत्तर को रोके रखने के बजाय, उन टोकन्स को वाक्य के आकार के टुकड़ों में TTS में डालें। यही वह आर्किटेक्चर है जिसे स्ट्रीमिंग-फर्स्ट वॉयस एजेंट डिज़ाइन में वर्णित किया गया है। Smallest.ai के घटक इसमें पूरी तरह फिट बैठते हैं: Pulse स्ट्रीमिंग STT को संभालता है, Electron LLM लेयर को कवर करता है, और Lightning (Waves API के माध्यम से) लो-लेटेंसी TTS को संभालता है।

चरण 1: अपने प्रोजेक्ट एनवायरनमेंट को सेट अप करें

एक साफ वर्चुअल एनवायरनमेंट से शुरुआत करें और ऑडियो इनपुट, WebSockets, HTTP स्ट्रीमिंग और एनवायरनमेंट कॉन्फ़िगरेशन के लिए आवश्यक डिपेंडेंसी इंस्टॉल करें। अपने टर्मिनल से, इसे रन करें:

python -m venv venv

source venv/bin/activate

# Windows: venv\Scripts\activate

pip install pyaudio websockets httpx python-dotenv smallest-sdk

इसके बाद, अपने प्रोजेक्ट रूट में एक .env फ़ाइल बनाएं और अपनी Waves API की जोड़ें:

WAVES_API_KEY=your_key_here

अपनी सोर्स फाइलों के अंदर सीधे एपीआई कीज़ को हार्डकोड न करें। python-dotenv का उपयोग करके उन्हें रनटाइम पर लोड करें। यह क्रेडेंशियल्स को वर्जन कंट्रोल से दूर रखता है और बाद में की रोटेशन को बहुत आसान बनाता है।

चरण 2: Pulse के साथ ऑडियो इनपुट को कैप्चर और स्ट्रीम करें

WebSocket पर 20ms के ऑडियो फ्रेम्स: सही चंकिंग आकार बफरिंग देरी को न्यूनतम रखता है

माइक्रोफ़ोन स्ट्रीम खोलने के लिए PyAudio का उपयोग करें, फिर आने वाले ऑडियो को 20ms के टुकड़ों (फ्रेम्स) में काटें। 16kHz, 16-बिट मोनो पर, यह प्रति फ्रेम 640 बाइट्स बैठता है। यह आकार जानबूझकर रखा गया है: इससे छोटा करने पर आपको अधिक WebSocket ओवरहेड देना होगा; इससे बड़ा करने पर STT के कुछ उपयोगी करने से पहले ही बफरिंग की देरी शुरू हो जाएगी। प्रत्येक फ्रेम को एक सिंगल परसिस्टेंट WebSocket पर Smallest.ai के Pulse STT एंडपॉइंट पर भेजें ताकि लाइव बातचीत के साथ-साथ ट्रांसक्रिप्शन भी हो सके।

import pyaudio

import asyncio

import websockets

import json

import os

from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('WAVES_API_KEY')

CHUNK = 640 # 20ms at 16kHz

FORMAT = pyaudio.paInt16

CHANNELS = 1

RATE = 16000

async def stream_audio_to_pulse(on_final_transcript):

    p = pyaudio.PyAudio()

    stream = p.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)

    uri = 'wss://waves.smallest.ai/v1/stt/stream'

    async with websockets.connect(

        uri, extra_headers={'Authorization': f'Bearer {API_KEY}'}

    ) as ws:

        async def send_audio():

            while True:

                data = stream.read(CHUNK, exception_on_overflow=False)

                await ws.send(data)

        async def receive_transcripts():

            async for message in ws:

                result = json.loads(message)

                if result.get('is_final'):

                    await on_final_transcript(result['transcript'])

        await asyncio.gather(send_audio(), receive_transcripts())

`is_final` फ़्लैग पर कड़ी नज़र रखें। जब उपयोगकर्ता बात कर रहा होगा तब Pulse आंशिक ट्रांसक्रिप्ट स्ट्रीम करेगा, फिर बातचीत का अंत डिटेक्ट करने पर एक अंतिम (फाइनल) ट्रांसक्रिप्ट को चिह्नित करेगा। LLM को केवल अंतिम ट्रांसक्रिप्ट पर ही ट्रिगर करें। यदि आप आंशिक (पार्शियल) पर ट्रिगर करेंगे, तो आप ओवरलैपिंग अनुरोधों के साथ LLM को परेशान करेंगे और अंत में ऐसा एजेंट बनेगा जो खुद से ही बात करेगा और मुख्य बात को खो देगा।

चरण 3: ट्रांसक्रिप्ट को एक लैंग्वेज मॉडल से कनेक्ट करें

एक बार जब आपके पास अंतिम रूप से तैयार ट्रांसक्रिप्ट हो जाए, तो इसे एक सिस्टम प्रॉम्प्ट के साथ Electron (या किसी कम्पैटिबल LLM एंडपॉइंट) पर भेजें जो एजेंट की भूमिका और दायरे को तय करता है। यहाँ सबसे बड़ी लेटेंसी जीत आसान है: पूरी प्रतिक्रिया के समाप्त होने की प्रतीक्षा करने के बजाय टोकन-दर-टोकन प्रतिक्रिया को स्ट्रीम करें। स्ट्रीमिंग चालू होने पर, आप पहला टोकन मिलते ही लगभग तुरंत ही टीटीएस (TTS) की ओर शब्दों को भेजना शुरू कर सकते हैं।

import httpx

SYSTEM_PROMPT = "You are a concise support agent. Answer in 1-2 sentences."

async def stream_llm_response(transcript, on_token):

    async with httpx.AsyncClient() as client:

        async with client.stream(

            "POST",

            "https://waves.smallest.ai/v1/chat/completions",

            headers={"Authorization": f"Bearer {API_KEY}"},

            json={

                "model": "electron",

                "messages": [

                    {"role": "system", "content": SYSTEM_PROMPT},

                    {"role": "user", "content": transcript}

                ],

                "stream": True

            }

        ) as response:

            async for line in response.aiter_lines():

                if line.startswith("data: "):

                    chunk = json.loads(line[6:])

                    token = chunk["choices"][0]["delta"].get("content", "")

                    if token:

                        await on_token(token)

सिस्टम प्रॉम्प्ट को छोटा रखें। हर अतिरिक्त टोकन की कीमत हर टर्न पर चुकानी पड़ती है। 500-टुकड़ों वाले प्रॉम्प्ट से 50-टुकड़ों वाले प्रॉम्प्ट पर जाने से बड़े पैमाने पर फर्स्ट-टोकन लेटेंसी से आसानी से 100ms+ का समय बचाया जा सकता है।

चरण 4: Lightning के साथ LLM रिस्पॉन्स को स्पीच में बदलें

एक-एक शब्द या पूर्ण-प्रतिक्रिया वाले दृष्टिकोणों की तुलना में वाक्य-पूर्ण टुकड़े स्वाभाविकता और लेटेंसी को बेहतर ढंग से संतुलित करते हैं

LLM के स्ट्रीम किए गए टोकन को वाक्य-पूर्ण टुकड़ों में Smallest.ai के Lightning TTS (Waves API के माध्यम से) पर भेजें, न कि एक बार में एक शब्द। शब्द-दर-शब्द सिंथेसिस थोड़ा अजीब लग सकता है क्योंकि मॉडल के पास आवाज़ के उतार-चढ़ाव को आकार देने के लिए पर्याप्त संदर्भ (कॉन्टेक्स्ट) नहीं होता है। पूरी प्रतिक्रिया का इंतज़ार करना दूसरे छोर पर चला जाता है और अंतिम ऑडियो उच्च गुणवत्ता का होने पर भी एजेंट को धीमा महसूस कराता है। विराम चिह्न आपको एक आसान, कम-प्रयास वाला चंकिंग सिग्नल देते हैं: पूर्ण विराम, प्रश्न चिह्न और विस्मयादिबोधक चिह्न।

async def tokens_to_speech(token_queue, audio_output_stream):

    buffer = ''

    async for token in token_queue:

        buffer += token

        if buffer.endswith(('.', '?', '!')):

            await synthesize_and_play(buffer.strip(), audio_output_stream)

            buffer = ''

    if buffer.strip(): # flush any remaining tokens

        await synthesize_and_play(buffer.strip(), audio_output_stream)

async def synthesize_and_play(text, audio_output_stream):

    async with httpx.AsyncClient() as client:

        async with client.stream(

            'POST',

            'https://waves.smallest.ai/v1/tts/stream',

            headers={'Authorization': f'Bearer {API_KEY}'},

            json={'text': text, 'voice': 'default', 'format': 'pcm_16000'}

        ) as response:

            async for chunk in response.aiter_bytes(4096):

                audio_output_stream.write(chunk)

चरण 5: इंटरप्ट हैंडलिंग और टर्न-टेकिंग के साथ लूप को पूरा करें

बाँध-इन (barge-in) यानी वाक्य के बीच में उपयोगकर्ता द्वारा टोकने की क्षमता ही एक प्रोडक्शन वॉयस एजेंट और एक सामान्य डेमो के बीच का अंतर है। इसके बिना, एजेंट लोगों के ऊपर बोलता है, सुधारों को छोड़ देता है, और आपके लेटेंसी आंकड़े अच्छे दिखने पर भी रोबोट जैसा महसूस कराता है। सबसे सरल तरीका यह है कि जब एजेंट बोल रहा हो तब भी माइक्रोफ़ोन पर नज़र रखी जाए। जब आप नई आवाज़ का पता लगाएं, तो TTS प्लेबैक को रोकें और नए ऑडियो को सीधे वापस Pulse में भेजें।

कई प्रोडक्ट्स के लिए, एक लाइटवेट एनर्जी-थ्रेशोल्ड VAD पर्याप्त है। webrtcvad एक सामान्य विकल्प है क्योंकि यह भारी सीपीयू लागत के बिना फ्रेम-लेवल स्पीच डिटेक्शन प्रदान करता है। TTS प्लेबैक शुरू होने पर agent_speaking = True सेट करें और प्लेबैक समाप्त होने पर इसे वापस False कर दें। यदि agent_speaking के True होने पर VAD सक्रिय होता है, तो एक interrupt_event उत्पन्न करें जिसे आपका TTS कोरूटीन प्रत्येक ऑडियो चंक को लिखने से पहले जांचता है। प्रोडक्शन ट्यूनिंग (गलत ट्रिगर्स बनाम रिस्पॉन्सिवनेस) के बारे में अधिक जानने के लिए वॉयस एक्टिविटी डिटेक्शन प्रोडक्शन गाइड देखें। Smallest.ai के घटक इसमें पूरी तरह फिट बैठते हैं: Pulse स्ट्रीमिंग STT को संभालता है, Electron LLM लेयर को कवर करता है, और Lightning (Waves API के माध्यम से) लो-लेटेंसी TTS को संभालता है।

लेटेंसी बेंचमार्क: प्रत्येक चरण में क्या उम्मीद करें

एक प्रोडक्शन-ग्रेड एजेंट के लिए, 600ms से कम का एंड-टू-एंड TTFA एक ठोस लक्ष्य है। संवादात्मक टर्न-टेकिंग शोध से पता चलता है कि प्रतिक्रियाएं तब स्वाभाविक लगती हैं जब वे लगभग 200-500ms की सीमा में आती हैं (लेविंसन और टोरेइरा, स्पीच कम्युनिकेशन, 2015)। आप हर हैंडऑफ़ को स्ट्रीम करके ही उस सीमा के करीब पहुँच सकते हैं। तालिका में नॉन-स्ट्रीमिंग बेसलाइन इसके नुकसान को स्पष्ट करती है: बैच STT, फुल-कम्प्लीशन LLM और बैच TTS केवल देरी नहीं जोड़ते हैं, वे इसे तब तक बढ़ाते हैं जब तक कि अनुभव अनिवार्य रूप से धीमा महसूस न होने लगे।

आम गलतियाँ और उनसे कैसे बचें

इनमें से प्रत्येक गलती लेटेंसी को बढ़ाती है या बातचीत के लूप को तोड़ती है

वे पांच गलतियाँ जो प्रोडक्शन में रीयल-टाइम वॉयस एजेंट को लगातार प्रभावित करती हैं:

• TTS कॉल करने से पहले पूरी LLM प्रतिक्रिया का इंतज़ार करना। सबसे आम लेटेंसी जाल। इसके बजाय टोकन स्ट्रीम करें और वाक्य सीमाओं पर चंक करें।

• Pulse को बहुत बड़े ऑडियो चंक्स भेजना। एक बार जब आप प्रति चंक ~100ms से आगे बढ़ जाते हैं, तो आप पाइपलाइन में बफरिंग देरी को बढ़ा रहे होते हैं। 20ms फ्रेम्स पर बने रहें।

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

• एपीआई कीज़ को हार्डकोड करना या WebSocket रीकनेक्ट्स को न संभालना। `.env` फाइलों का उपयोग करें और एक्सपोनेंशियल बैकऑफ रीकनेक्ट लॉजिक जोड़ें। WebSockets डिस्कनेक्ट हो सकते हैं; आपके एजेंट को चुपचाप रिकवर हो जाना चाहिए।

• अत्यधिक लंबे सिस्टम प्रॉम्प्ट। प्रॉम्प्ट टोकन हर टर्न पर प्रोसेस होते हैं। 500-टोकन वाला प्रॉम्प्ट बनाम 50-टोकन वाला प्रॉम्प्ट बड़े पैमाने पर फर्स्ट-टोकन लेटेंसी में 100ms+ जोड़ सकता है।

यह किस समस्या का समाधान करता है और Smallest.ai कहाँ फिट बैठता है

खंडित स्टैक लेटेंसी को बढ़ाते हैं; एक विशेष रूप से निर्मित एकीकृत पाइपलाइन कमियों को दूर करती है

एक रीयल-टाइम वॉयस एजेंट का सबसे कठिन हिस्सा शायद ही कभी अलग से STT, LLM या TTS होता है। यह उन्हें जोड़ने वाली कड़ी है। जब आप कई लेटेंसी-सेंसिटिव सेवाओं को एक साथ जोड़ते हैं, तो आप अंत में बेमेल ऑडियो फॉर्मेट्स को ठीक करने, अलग-अलग ऑथेंटिकेशन पैटर्न्स को संभालने, वेंडर्स के बीच राउटिंग ओवरहेड को झेलने में लग जाते हैं, और फिर (देर से) पता चलता है कि एक प्रदाता की “स्ट्रीमिंग” दूसरे के साथ ठीक से काम नहीं कर रही है। अधिकांश मल्टी-प्रोवाइडर स्टैक को कभी भी एक सुसंगत रीयल-टाइम सिस्टम की तरह व्यवहार करने के लिए डिज़ाइन नहीं किया गया था।

Smallest.ai के Waves API, Pulse, Lightning और Electron को उसी सिंगल पाइपलाइन के रूप में चलाने के लिए बनाया गया है: एक ऑथेंटिकेशन लेयर, सुसंगत स्ट्रीमिंग व्यवहार, और जब आप लूप को एक ही स्टैक के अंदर रखते हैं तो कम इंटर-सर्विस लेटेंसी। यदि आप प्लंबिंग को छोड़ना चाहते हैं, तो Atoms Smallest.ai का वॉयस और टेक्स्ट एजेंट प्लेटफ़ॉर्म है जो उसी इंफ्रास्ट्रक्चर के ऊपर एक प्रबंधित एजेंट लेयर जोड़ता है जिसे आपने अभी मैन्युअल रूप से वायर किया है। कस्टम बिल्ड का नियंत्रण चुनें या प्रबंधित परिनियोजन (डिप्लॉयमेंट) की गति, दोनों ही तरीकों से अंतर्निहित लूप एक जैसा ही रहता है। अपने पहले एजेंट को चालू करने के लिए Waves API और डेवलपर दस्तावेज़ों से शुरुआत करें।

आगे क्या बनाएं

इस बिंदु पर आपके पास पूरा रीयल-टाइम लूप काम कर रहा है: माइक्रोफ़ोन ऑडियो Pulse में स्ट्रीम होता है, फाइनल ट्रांसक्रिप्ट Electron में जाते हैं, टोकन वापस स्ट्रीम होते हैं और Lightning के लिए वाक्यों में चंक हो जाते हैं, और VAD-आधारित बार्ज-इन बातचीत को एकतरफा लेक्चर बनने से रोकता है। यहाँ से, अगले बदलाव वे हैं जो एक काम करने वाले एजेंट को उपयोग के लिए तैयार एजेंट में बदलते हैं। डिफ़ॉल्ट आवाज़ को Smallest.ai के वॉयस क्लोनिंग एपीआई के साथ एक ब्रांडेड आवाज़ से बदलें। इनबाउंड या आउटबाउंड कॉलिंग के लिए WebRTC के माध्यम से उसी पाइपलाइन को एक फोन नंबर पर ले जाएं। यदि आपके पास कोई स्पीच-टू-स्पीच उपयोग का मामला है जिसमें बीच में टेक्स्ट की आवश्यकता नहीं है, तो Hydra विशिष्ट अनुप्रयोगों के लिए कम-लेटेंसी वाला मार्ग प्रदान करता है। और यदि आप किसी विशेष वर्कफ़्लो की ओर बढ़ रहे हैं, तो मल्टी-एजेंट वॉयस डैशबोर्ड ट्यूटोरियल और ई-कॉमर्स के लिए एआई वॉयस एजेंट गाइड दिखाते हैं कि टीमें इस आधार को प्रोडक्शन डिप्लॉयमेंट में कैसे विस्तारित करती हैं। यदि आप एक वर्किंग प्रोटोटाइप से प्रोडक्शन वॉयस एजेंट पर जाने के लिए तैयार हैं, तो यह देखने के लिए डेमो बुक करें कि Smallest.ai आपके आर्किटेक्चर और डिप्लॉयमेंट आवश्यकताओं में कैसे फिट बैठता है।