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

5 चरणों में रियल-टाइम वॉयस एजेंट बनाएं: Pulse और Lightning के साथ Smallest.ai Waves API का उपयोग करके लगभग 600ms TTFA प्राप्त करने के लिए STT, LLM टोकन और TTS ऑडियो स्ट्रीम करें।
रीयल-टाइम वॉयस एजेंट बनाना अब "मजेदार प्रोटोटाइप" के चरण से काफी आगे निकल चुका है। 2025 और 2026 में, ये सिस्टम्स कस्टमर सपोर्ट, हेल्थकेयर इंटेक, ई-कॉमर्स और लॉजिस्टिक्स में वास्तविक प्रोडक्शन ट्रैफिक को संभाल रहे हैं। टूल्स अपग्रेड हो चुके हैं, APIs तेज़ हैं, और "काफी अच्छा" होने का मतलब अब केवल उत्तर देना नहीं है: बातचीत के स्वाभाविक प्रवाह को बनाए रखने के लिए इसे पर्याप्त रूप से तेज़ प्रतिक्रिया देने की आवश्यकता है, जिसमें कई प्रोडक्शन सिस्टम्स एक सेकंड से भी कम के एंड-टू-एंड रिस्पॉन्स टाइम का लक्ष्य रखते हैं और बिना किसी रुकावट के इंटरप्रशंस को संभालते हैं। यह ट्यूटोरियल उन डेवलपर्स के लिए है जो एक काम करने योग्य रीयल-टाइम वॉयस एजेंट को शिप करना चाहते हैं, न कि केवल एक ऐसा डेमो जो केवल आदर्श परिस्थितियों में ही काम करता हो।
पाँच चरण आपको एक पूर्ण, कार्यात्मक लूप तक ले जाते हैं: माइक्रोफ़ोन ऑडियो स्पीच-टू-टेक्स्ट में स्ट्रीम होता है, अंतिम ट्रांसक्रिप्ट्स लैंग्वेज मॉडल में जाते हैं, और प्रतिक्रिया न्यूनतम देरी के साथ सिंथेसाइज्ड स्पीच के रूप में वापस आती है। यहाँ सटीक बिल्ड क्रम दिया गया है:
अपना प्रोजेक्ट एनवायरनमेंट सेट करें
Pulse (STT) के साथ ऑडियो इनपुट कैप्चर और स्ट्रीम करें
ट्रांसक्रिप्ट को एक लैंग्वेज मॉडल से कनेक्ट करें
Lightning (TTS) के साथ LLM रिस्पॉन्स को स्पीच में बदलें
इंटरप्ट हैंडलिंग और टर्न-टेकिंग के साथ लूप को पूरा करें
शुरू करने से पहले आपको क्या चाहिए
कोड लिखने से पहले, बुनियादी चीज़ों को व्यवस्थित कर लें। टूल्स: Python 3.9+, एक कोड एडिटर, और काम करने वाले माइक्रोफ़ोन के साथ एक टेस्ट सेटअप। आपको Lightning (TTS), Pulse (STT), और Electron के लिए Smallest.ai के Waves प्लेटफॉर्म के API एक्सेस की भी आवश्यकता होगी, साथ ही यदि आप किसी बाहरी लैंग्वेज मॉडल का उपयोग करना पसंद करते हैं तो कोई भी कम्पैटिबल LLM एंडपॉइंट। अपेक्षित ज्ञान: async Python, 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 की (key) जोड़ें:
WAVES_API_KEY=your_key_here
API कीज़ को अपनी सोर्स फ़ाइलों के अंदर सीधे हार्डकोड न करें। python-dotenv का उपयोग करके उन्हें रनटाइम पर लोड करें। यह क्रेडेंशियल्स को वर्शन कंट्रोल से बाहर रखता है और बाद में की (key) रोटेशन को बहुत आसान बनाता है।
चरण 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: इंटरप्ट हैंडलिंग और टर्न-टेकिंग के साथ लूप को पूरा करें
बार्ज-इन (उपयोगकर्ता द्वारा वाक्य के बीच में टोकने की क्षमता) एक प्रोडक्शन वॉयस एजेंट और एक पॉलिश किए गए डेमो के बीच का अंतर है। इसके बिना, एजेंट लोगों के ऊपर बोलता है, सुधारों को मिस कर देता है, और आपके लेटेंसी नंबर्स बेहतरीन दिखने के बावजूद रोबोटिक लगता है। सबसे सरल पैटर्न यह है कि जब एजेंट बोल रहा हो तब भी माइक्रोफ़ोन की निगरानी जारी रखी जाए। जब आप नई स्पीच का पता लगाते हैं, तो TTS प्लेबैक को रोकें और नए ऑडियो को सीधे Pulse में वापस रूट करें।
कई प्रोडक्ट्स के लिए, एक लाइटवेट एनर्जी-थ्रेशोल्ड VAD पर्याप्त होता है। webrtcvad एक सामान्य विकल्प है क्योंकि यह भारी CPU लागत के बिना फ्रेम-लेवल स्पीच डिटेक्शन प्रदान करता है। जब TTS प्लेबैक शुरू हो तो agent_speaking = True सेट करें और प्लेबैक समाप्त होने पर इसे वापस False कर दें। यदि agent_speaking के True होने पर VAD सक्रिय होता है, तो एक interrupt_event रेज करें जिसे आपका TTS कोरूटीन प्रत्येक ऑडियो चंक लिखने से पहले चेक करता है। प्रोडक्शन ट्यूनिंग (गलत ट्रिगर बनाम प्रतिक्रियाशीलता) के बारे में अधिक जानकारी के लिए वॉयस एक्टिविटी डिटेक्शन प्रोडक्शन गाइड देखें। Smallest.ai के कंपोनेंट्स इस पर सटीक रूप से मैप होते हैं: Pulse स्ट्रीमिंग STT को संभालता है, Electron LLM लेयर को कवर करता है, और Lightning (Waves API के माध्यम से) लो-लेटेंसी TTS को संभालता है।
लेटेंसी बेंचमार्क: प्रत्येक चरण में क्या उम्मीद करें
स्टैक / दृष्टिकोण | STT फर्स्ट-टोकन (ms) | LLM फर्स्ट-टोकन (ms) | TTS फर्स्ट-ऑडियो (ms) | अनुमानित TTFA (ms) | स्ट्रीमिंग | इसके लिए ऑप्टिमाइज़ करता है |
|---|---|---|---|---|---|---|
Smallest.ai (Waves API के माध्यम से Pulse + Electron + Lightning) | 80-150 | 150-300 | 80-180 | 310-630 | हाँ (सभी चरण) | एंड-टू-एंड लेटेंसी, एकीकृत API |
स्ट्रीमिंग STT + थर्ड-पार्टी LLM + स्ट्रीमिंग TTS | 100-200 | 200-500 | 150-300 | 450-1000 | हाँ (सभी चरण) | लचीलापन, मॉडल विकल्प |
स्ट्रीमिंग STT + थर्ड-पार्टी LLM + नॉन-स्ट्रीमिंग TTS | 100-200 | 200-500 | 800-2000 | 1100-2700 | आंशिक | गति की तुलना में सरलता |
नॉन-स्ट्रीमिंग बेसलाइन (बैच STT + पूर्ण LLM + बैच TTS) | 500-1500 | 400-1200 | 1000-3000 | 1900-5700 | नहीं | सरलता, लेटेंसी नहीं |
प्रोडक्शन-ग्रेड एजेंट के लिए, 600ms से कम का एंड-टू-एंड TTFA एक ठोस लक्ष्य है। संवादात्मक टर्न-टेकिंग रिसर्च से पता चलता है कि प्रतिक्रियाएँ लगभग 200-500ms की सीमा में होने पर स्वाभाविक लगती हैं (लेविंसन और टोरेइरा, स्पीच कम्युनिकेशन, 2015)। आप हर हैंडऑफ को स्ट्रीम करके ही उस बजट के करीब पहुँच सकते हैं। तालिका में नॉन-स्ट्रीमिंग बेसलाइन इस नुकसान को स्पष्ट करती है: बैच STT, फुल-कंप्लीशन LLM और बैच TTS केवल देरी ही नहीं जोड़ते, बल्कि वे इसे तब तक बढ़ाते जाते हैं जब तक कि अनुभव अपरिहार्य रूप से धीमा न लगने लगे।
सामान्य गलतियाँ और उनसे कैसे बचें

इनमें से प्रत्येक गलती लेटेंसी को बढ़ाती है या बातचीत के लूप को तोड़ती है
पाँच गलतियाँ जो प्रोडक्शन में रीयल-टाइम वॉयस एजेंट्स को लगातार बाधित करती हैं:
TTS को कॉल करने से पहले पूर्ण LLM रिस्पॉन्स की प्रतीक्षा करना। सबसे आम लेटेंसी ट्रैप। इसके बजाय टोकन्स को स्ट्रीम करें और वाक्य की सीमाओं पर चंक करें।
Pulse को बहुत बड़े ऑडियो चंक्स भेजना। एक बार जब आप प्रति चंक ~100ms से अधिक पार कर जाते हैं, तो आप पाइपलाइन में बफरिंग डिले शामिल कर रहे होते हैं। 20ms फ्रेम्स पर ही टिके रहें।
कोई इंटरप्ट हैंडलिंग नहीं होना। यदि उपयोगकर्ता बीच में नहीं बोल सकते हैं, तो एजेंट तेज़ होने पर भी खराब लगेगा। शुरुआत में ही VAD-आधारित बार्ज-इन बनाएं।
API कीज़ को हार्डकोड करना या WebSocket रीकनेक्ट्स को हैंडल न करना। `.env` फ़ाइलों का उपयोग करें और एक्सपोनेंशियल बैकऑफ़ रीकनेक्ट लॉजिक जोड़ें। WebSockets ड्रॉप होते हैं; आपके एजेंट को बिना किसी परेशानी के रीकवर होना चाहिए।
अत्यधिक लंबे सिस्टम प्रॉम्प्ट्स। प्रॉम्प्ट टोकन्स को प्रत्येक टर्न पर प्रोसेस किया जाता है। 50-टोकन प्रॉम्प्ट की तुलना में 500-टोकन का प्रॉम्प्ट बड़े पैमाने पर फर्स्ट-टोकन लेटेंसी में 100ms+ जोड़ सकता है।
यह समस्या जिसे हल करता है और Smallest.ai कहाँ फिट बैठता है

विभाजित स्टैक्स लेटेंसी को बढ़ाते हैं; एक विशेष रूप से निर्मित एकीकृत पाइपलाइन कमियों को समाप्त करती है
रीयल-टाइम वॉयस एजेंट का कठिन हिस्सा शायद ही कभी अलग से STT, LLM या TTS होता है। यह इनका संयोजन (ग्लू) है। जब आप कई लेटेंसी-सेंसिटिव सेवाओं को एक साथ जोड़ते हैं, तो आप बेमेल ऑडियो फॉर्मेट्स को ठीक करने, अलग-अलग ऑथेंटिकेशन पैटर्न्स को संभालने, वेंडर्स के बीच रूटिंग ओवरहेड को झेलने में लग जाते हैं, और फिर (देर से) पता चलता है कि एक प्रोवाइडर की "स्ट्रीमिंग" दूसरे के साथ ठीक से काम नहीं करती है। अधिकांश मल्टी-प्रोवाइडर स्टैक्स को कभी भी एक सुसंगत रीयल-टाइम सिस्टम की तरह व्यवहार करने के लिए डिज़ाइन ही नहीं किया गया था।
Smallest.ai का Waves API, Pulse, Lightning और Electron उसी सिंगल पाइपलाइन के रूप में चलने के लिए बनाए गए हैं: एक ऑथेंटिकेशन लेयर, सुसंगत स्ट्रीमिंग व्यवहार, और जब आप लूप को एक ही स्टैक के अंदर रखते हैं तो सेवाओं के बीच कम लेटेंसी। यदि आप बुनियादी सेटअप को छोड़ना चाहते हैं, तो Atoms, Smallest.ai का वॉयस और टेक्स्ट एजेंट प्लेटफ़ॉर्म है जो उसी इंफ्रास्ट्रक्चर के शीर्ष पर एक प्रबंधित एजेंट लेयर जोड़ता है जिसे आपने अभी मैन्युअल रूप से वायर किया है। कस्टम बिल्ड का नियंत्रण चुनें या प्रबंधित परिनियोजन की गति, दोनों ही तरह से, अंतर्निहित लूप वही रहता है। अपने पहले एजेंट को चालू करने के लिए Waves API और डेवलपर डॉक्यूमेंटेशन से शुरुआत करें।
आगे क्या बनाएं
इस बिंदु पर आपके पास पूर्ण रीयल-टाइम लूप काम कर रहा है: माइक्रोफ़ोन ऑडियो Pulse में स्ट्रीम होता है, अंतिम ट्रांसक्रिप्ट्स Electron में जाते हैं, टोकन्स वापस स्ट्रीम होते हैं और Lightning के लिए वाक्यों में चंक हो जाते हैं, और VAD-आधारित बार्ज-इन बातचीत को एकतरफा व्याख्यान में बदलने से रोकता है। यहाँ से, अगले पुनरावृत्ति (इट्रेशन्स) वे हैं जो एक कार्यात्मक एजेंट को उपयोग के लिए तैयार (शिपेबल) बनाते हैं। Smallest.ai के वॉयस क्लोनिंग API के साथ डिफ़ॉल्ट आवाज़ को ब्रांडेड आवाज़ से बदलें। इनबाउंड या आउटबाउंड कॉलिंग के लिए WebRTC के माध्यम से उसी पाइपलाइन को एक फ़ोन नंबर पर ले जाएँ। टेलीफोनी तक विस्तार करने से पहले, एजेंट को पहले प्रोडक्शन के लिए पैकेज करना उचित है। टेलीफोनी और प्रोडक्शन मजबूती के लिए इन-हाउस क्षमता के बिना टीमें किसी बाहरी टीम को भी शामिल कर सकती हैं, जैसे कि Relinns, जो AI वॉयस एजेंट डेवलपमेंट सेवाएं प्रदान करती है। एक ठोस कंटेनर डिप्लॉयमेंट सेटअप आपके एनवायरनमेंट को देव और प्रोडक्शन में सुसंगत रखता है, और कॉल वॉल्यूम बढ़ने पर हॉरिजॉन्टल स्केलिंग को सीधा बनाता है। यदि आपके पास स्पीच-टू-स्पीच उपयोग का मामला है जिसमें बीच में टेक्स्ट की आवश्यकता नहीं है, तो Hydra विशिष्ट अनुप्रयोगों के लिए एक कम-लेटेंसी वाला मार्ग प्रदान करता है। और यदि आप किसी विशेष वर्कफ़्लो के लिए निर्माण कर रहे हैं, तो मल्टी-एजेंट वॉयस डैशबोर्ड ट्यूटोरियल और ई-कॉमर्स के लिए AI वॉयस एजेंट गाइड दिखाते हैं कि टीमें इस आधार को प्रोडक्शन डिप्लॉयमेंट्स में कैसे विस्तारित करती हैं। यदि आप एक काम करने वाले प्रोटोटाइप से प्रोडक्शन वॉयस एजेंट की ओर बढ़ने के लिए तैयार हैं, तो यह देखने के लिए कि Smallest.ai आपके आर्किटेक्चर और डिप्लॉयमेंट आवश्यकताओं में कैसे फिट बैठता है, एक डेमो बुक करें।
अक्सर पूछे जाने वाले प्रश्न
किस लेटेंसी (विलंबता) लक्ष्य से एक रियल-टाइम वॉयस एजेंट स्वाभाविक महसूस होता है?
क्या मैं अलग-अलग एसटीटी (STT) और टीटीएस (TTS) वेंडर्स के साथ झंझट किए बिना वेव्स एपीआई (Waves API) पर वॉयस एजेंट बना सकता हूँ?
जब एजेंट बोल रहा हो और उपयोगकर्ता बात करना शुरू कर दे, तो व्यवधान कैसे काम करना चाहिए?
रीयल-टाइम वॉयस एजेंटों के लिए कौन सी भाषाएं और फ्रेमवर्क सबसे उपयुक्त हैं?
क्या मैं एजेंट को किसी सामान्य आवाज़ के बजाय एक कस्टमाइज़्ड या क्लोन की गई आवाज़ दे सकता हूँ?


