ElevenLabs और Twilio के साथ 20 मिनट में वॉइस एजेंट बनाएं

एक वॉइस एजेंट इनकमिंग फ़ोन कॉल का जवाब दे सकता है, कॉलर की बात को रीयल टाइम में स्पीच टू टेक्स्ट (STT) से ट्रांसक्राइब कर सकता है, लार्ज लैंग्वेज मॉडल (LLM) से जवाब बना सकता है और टेक्स्ट टू स्पीच (TTS) मॉड्यूल से बोलकर जवाब दे सकता है। ElevenLabs और Twilio के साथ, आप लगभग 20 मिनट में किसी असली फ़ोन नंबर पर काम करने वाला एजेंट तैयार कर सकते हैं।

डेवलपर्स के लिए, इस पूरे स्टैक में स्पीच सिंथेसिस (Flash v2.5) और ट्रांसक्रिप्शन (Scribe v2 Realtime) के लिए ElevenLabs, टेलीफोनी के लिए Twilio, और LLM के रूप में OpenAI या Anthropic शामिल हैं। हालांकि, ये सभी बदले जा सकते हैं, यानी आप जिन कॉम्पोनेंट्स से सबसे परिचित हैं, उन्हें चुनकर इस्तेमाल कर सकते हैं।

यह लेख दिखाता है कि Node.js और Typescript का इस्तेमाल करके 20 मिनट में वॉइस एजेंट कैसे बनाएं। अगर आप ऐसा मैनेज्ड विकल्प चाहते हैं जो कैस्केड को खुद मेंटेन किए बिना टर्न-टेकिंग, रुकावटों और टेलीफोनी को संभाले, तो ElevenAgents. 

वॉइस एजेंट आर्किटेक्चर कैसे काम करता है

कोड लिखने से पहले, यह समझना मददगार होता है कि आपके टेक स्टैक की तीनों सर्विसेज़ कैसे कनेक्ट होती हैं।

• Twilio: फ़ोन कॉल और ऑडियो ट्रांसपोर्ट संभालता है।
• ElevenLabs: Scribe v2 Realtime के ज़रिए STT और Flash v2.5 के ज़रिए TTS संभालता है।
• LLM: टूल कॉलिंग और जवाब लिखना संभालता है।

हर स्टेज एक हल्का एडैप्टर है, इसलिए बाकी हिस्सों को छुए बिना आप किसी एक को दूसरी सर्विस से बदल सकते हैं। उदाहरण के लिए, अपने दूसरे कॉम्पोनेंट्स को फिर से लिखे बिना आप OpenAI LLM को Anthropic से बदल सकते हैं।

फ़ोन कॉल Twilio के ज़रिए आपके सर्वर तक पहुंचती है। Twilio PSTN कॉल का जवाब देता है, आपके सर्वर पर वापस एक WebSocket खोलता है और कॉलर के ऑडियो को base64-एन्कोडेड mu-law फ़्रेम्स की स्ट्रीम के रूप में भेजता है। आपका सर्वर कैस्केड चलाता है और उसी WebSocket पर सिंथेसाइज़ किया गया ऑडियो वापस स्ट्रीम करता है, जिसे Twilio कॉलर को सुनाता है।

वॉइस एजेंट बनाने के लिए आप यह फ़्लो इस्तेमाल करेंगे: 

एक कॉलर आपके Twilio नंबर पर डायल करता है। Twilio आपके वेबहुक से एक TwiML डॉक्यूमेंट लाता है। TwiML, Twilio को आपके WebSocket एंडपॉइंट पर Media Stream खोलने के लिए कहता है। Twilio, base64 mu-law (ulaw_8000) पेलोड वाले JSON इवेंट्स के रूप में इनबाउंड ऑडियो स्ट्रीम करता है। 

आपका सर्वर ऑडियो चंक्स को स्ट्रीमिंग ट्रांसक्रिप्शन के लिए Scribe v2 Realtime को फ़ॉरवर्ड करता है। कॉलर का टर्न पूरा होने पर, आप ट्रांसक्रिप्ट LLM को भेजते हैं और फिर Flash v2.5 से ulaw_8000 में जवाब सिंथेसाइज़ करते हैं। आप सिंथेसाइज़ किए गए mu-law फ़्रेम्स को base64-एन्कोड करके WebSocket के ज़रिए Twilio को वापस भेजते हैं और Twilio उन्हें कॉलर को सुनाता है।

Scribe v2 Realtime लगभग 150ms लेटेंसी पर आंशिक ट्रांसक्रिप्शन देता है और Flash v2.5 लगभग 75ms मॉडल इन्फ़रेंस पर चलता है, इसमें नेटवर्क और एप्लिकेशन लेटेंसी शामिल नहीं है। टाइम-टू-फ़र्स्ट-ऑडियो में LLM का योगदान सबसे बड़ा और सबसे कम अनुमानित होता है, और लेटेंसी बजट का अधिकांश हिस्सा यहीं जाता है। अंतर को कम रखने के लिए, हम LLM आउटपुट को टोकन दर टोकन स्ट्रीम करते हैं और मॉडल के वाक्य पूरा करने से पहले ही सिंथेसाइज़ करना शुरू कर देते हैं।

इन विकल्पों के पीछे के मॉडल ट्रेड-ऑफ़ के लिए मॉडल्स ओवरव्यू और लेटेंसी को समझें पर लेख देखें।

वॉइस एजेंट बनाना शुरू करने से पहले आपको क्या चाहिए

इस गाइड में माना गया है कि आपके पास चार चीज़ें तैयार हैं। हर एक को सेट अप करना तेज़ है, लेकिन इनमें से कोई भी न होने पर सर्वर नहीं चल पाएगा।

इन ज़रूरी चीज़ों को जांचें:

1. Voice क्षमता वाला एक Twilio फ़ोन नंबर: Twilio कंसोल से नंबर के साथ अपना Account SID और Auth Token नोट कर लें।
2. ElevenLabs API key: इसे अपने ElevenLabs डैशबोर्ड में बनाएं। यह key xi-api-key हेडर में जाती है और गुप्त होती है, इसलिए इसे केवल सर्वर-साइड पर रखें। API ऑथेंटिकेशन देखें।
3. LLM API key: इस ट्यूटोरियल में Anthropic Claude और OpenAI को एक-दूसरे के बदले इस्तेमाल होने वाले बैकएंड माना गया है, इसलिए इनमें से एक चुनें।
4. लोकल डेवलपमेंट के लिए Ngrok (या कोई भी टनल): Twilio को सार्वजनिक HTTPS और WSS URL के ज़रिए आपके सर्वर तक पहुंचना होता है, और ngrok बिना कुछ डिप्लॉय किए यह सुविधा देता है।

अपने सीक्रेट्स को एनवायरनमेंट वेरिएबल्स के रूप में सेट करें और उन्हें कभी कमिट न करें।

export ELEVENLABS_API_KEY="..."
export ANTHROPIC_API_KEY="..."          # or OPENAI_API_KEY
export TWILIO_AUTH_TOKEN="..."          # used for webhook signature validation
export PUBLIC_HOST="your-subdomain.ngrok.app"

फिर अपने सर्वर के इस्तेमाल वाले पोर्ट पर पॉइंट करने वाली टनल शुरू करें:

ngrok http 8080

Twilio Media Streams प्रोटोकॉल को समझना

Twilio आपको रॉ ऑडियो सॉकेट नहीं देता। इसके बजाय, यह सब कुछ WebSocket पर एक संरचित JSON प्रोटोकॉल में रैप करता है। चार इवेंट टाइप्स और सेंड फ़ॉर्मेट को समझ लेने पर, उसे लिखने से पहले ही Step 2 का WebSocket हैंडलर पूरी तरह समझ आ जाएगा।

Twilio के आपके WebSocket से कनेक्ट होने पर, वह JSON टेक्स्ट मैसेज की एक सीरीज़ भेजता है, जिनके चार इवेंट टाइप हो सकते हैं।

connected इवेंट सबसे पहले आता है और पुष्टि करता है कि WebSocket चालू है। मीडिया स्ट्रीम शुरू होने पर start इवेंट एक बार भेजा जाता है; इसमें एक streamSid होता है जिसे आपको स्टोर करना होता है, क्योंकि ऑडियो वापस भेजने के लिए इसकी ज़रूरत होती है। इसमें start.customParameters और start.callSid के तहत कॉल मेटाडेटा भी शामिल होता है। 

media इवेंट बार-बार आता है: media.payload, 8kHz mu-law ऑडियो का base64-एन्कोडेड चंक होता है, हर फ़्रेम 20ms का होता है और कॉलर के ऑडियो के लिए media.track inbound होता है। आखिर में, स्ट्रीम समाप्त होने पर stop भेजा जाता है, आमतौर पर कॉल कटने पर।

ऑडियो वापस चलाने के लिए, आप उसी streamSid और base64 mu-law पेलोड के साथ media टाइप का मैसेज भेजते हैं। पहले से क्यू किए गए ऑडियो को रोकने के लिए, streamSid के साथ clear मैसेज भेजें, जो Twilio के आउटबाउंड बफ़र को खाली कर देता है।

इनबाउंड और आउटबाउंड एन्कोडिंग एक जैसी हैं (ulaw_8000)। हम ElevenLabs टेक्स्ट टू स्पीच से ulaw_8000 रिक्वेस्ट करते हैं और बीच में कोई री-सैंपलिंग किए बिना बाइट्स को सीधे Twilio को फ़ॉरवर्ड करते हैं।

Step 1: TwiML वेबहुक सर्व करें

कॉल आने पर Twilio आपके वेबहुक को HTTP रिक्वेस्ट भेजता है और आप TwiML से जवाब देते हैं, जो कॉल को आपकी Media Stream से जोड़ता है। <Connect><Stream> वर्ब एक द्विदिश WebSocket खोलता है। यहां <Start> की बजाय <Connect> का इस्तेमाल करें: यह स्ट्रीम की अवधि तक कॉल को चालू रखता है और आपको ऑडियो वापस भेजने देता है, जो इस सेटअप का उद्देश्य है।

वेबहुक यह TwiML लौटाता है:

<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Connect>
    <Stream url="wss://your-subdomain.ngrok.app/media" />
  </Connect>
</Response>

Express में, यह एक सिंगल POST हैंडलर है जो होस्ट भरकर डॉक्यूमेंट लौटाता है:

// ... imports and app setup
app.post("/incoming-call", (_req, res) => {
  const twiml = `<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Connect>
    <Stream url="wss://${process.env.PUBLIC_HOST}/media" />
  </Connect>
</Response>`;
  res.type("application/xml").send(twiml);
});

Twilio कंसोल में, नंबर के "A call comes in" वेबहुक को https://your-subdomain.ngrok.app/incoming-call पर HTTP POST के साथ सेट करें।

Step 2: Media Stream WebSocket स्वीकार करें

WebSocket हैंडलर Twilio इवेंट्स पढ़ता है, कैस्केड चलाता है और ऑडियो वापस लिखता है।

हम हर कॉल के लिए थोड़ा स्टेट रखते हैं: streamSid, एक STT कनेक्शन और यह फ़्लैग कि एजेंट अभी बोल रहा है या नहीं। हैंडलर हर इनबाउंड मीडिया फ़्रेम को base64 से डिकोड करता है और रॉ mu-law बाइट्स STT को फ़ॉरवर्ड करता है:

import { WebSocketServer } from "ws";
// ... http server bound to the same port as Express

const wss = new WebSocketServer({ server, path: "/media" });

wss.on("connection", (ws) => {
  const state = { streamSid: null as string | null, agentSpeaking: false };

  ws.on("message", async (raw) => {
    const event = JSON.parse(raw.toString());
    switch (event.event) {
      case "start":
        state.streamSid = event.start.streamSid;
        await startSttSession(ws, state);
        break;
      case "media":
        await forwardToStt(Buffer.from(event.media.payload, "base64"), state);
        break;
      case "stop":
        await teardown(state);
        ws.close();
        break;
    }
  });
});

Step 3: Scribe v2 Realtime से ट्रांसक्राइब करें

Scribe v2 Realtime स्ट्रीमिंग ऑडियो चंक्स स्वीकार करता है और आंशिक व अंतिम ट्रांसक्रिप्शन लौटाता है। यह सीधे mu-law एन्कोडिंग सपोर्ट करता है, इसलिए हम इसे Twilio के फ़्रेम्स बिना बदले भेजते हैं। 

यह साइलेंस-आधारित सेगमेंटेशन के लिए Voice Activity Detection और सेगमेंट को पूरा करने के लिए मैन्युअल कमिट कंट्रोल भी देता है। फ़ोन एजेंट के लिए, VAD-आधारित सेगमेंटेशन आमतौर पर सही विकल्प है, क्योंकि स्वाभाविक ठहराव इस बात का सबसे भरोसेमंद संकेत है कि कॉलर का टर्न समाप्त हो गया है।

ये स्टेप्स हैं: कॉल शुरू होने पर STT स्ट्रीम खोलें। हर इनबाउंड mu-law चंक पुश करें। अंतिम ट्रांसक्रिप्ट मिलने पर LLM को कॉल करें।

रीयलटाइम STT क्लाइंट इंटरफ़ेस अभी विकसित हो रहा है, इसलिए नीचे दिए गए आकार को एक छोटे TypeScript एडैप्टर (openRealtimeStt) के पीछे रखा गया है, जिसे आप तय फ़ील्ड नेम्स के बजाय लाइव API के हिसाब से लागू करते हैं। onFinal को उस हुक की तरह मानें जो पूरा हुआ कॉलर टर्न अगले स्टेज को सौंपता है।

async function startSttSession(ws, state) {
  // openRealtimeStt is a thin adapter over the realtime STT API:
  // model_id="scribe_v2_realtime", mu-law encoding, 8kHz, VAD on
  // so turns finalize on silence.
  const session = await openRealtimeStt({
    modelId: "scribe_v2_realtime",
    encoding: "ulaw",
    sampleRate: 8000,
  });
  state.stt = session;

  session.onFinal(async (text: string) => {
    if (text.trim()) await handleTurn(ws, state, text);
  });
}

async function forwardToStt(audioBytes, state) {
  if (state.stt) await state.stt.sendAudio(audioBytes);
}

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

Step 4: LLM से जवाब जनरेट करें

यह वह स्टेज है जो जवाब तैयार करता है। LLM बातचीत का इतिहास लेकर असिस्टेंट का टेक्स्ट लौटाता है। जवाब को स्ट्रीम करें ताकि आप पहले वाक्य पर सिंथेसिस शुरू कर सकें।

यहां इसके लिए OpenAI इस्तेमाल किया गया है:

// ... client init: new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
const SYSTEM_PROMPT =
  "You are a concise phone assistant. Keep replies to one or two sentences.";

async function llmReply(history) {
  const stream = await llm.chat.completions.create({
    model: "gpt-4.1-mini",
    stream: true,
    messages: [{ role: "system", content: SYSTEM_PROMPT }, ...history],
  });
  for await (const part of stream) {
    const token = part.choices[0]?.delta?.content;
    if (token) yield token; // incremental tokens
  }
}

ऊपर दिया गया मॉडल ID, gpt-4.1-mini, कम लेटेंसी वाले विकल्प का एक उदाहरण है; Anthropic में claude-haiku-4-5 इसका तुलनीय विकल्प है। दोनों में से कोई भी प्रोवाइडर उसी llmReply कॉन्ट्रैक्ट को बैक कर सकता है; फ़ंक्शन की बॉडी बदलें और बाकी एजेंट अपरिवर्तित रहेगा।

सिस्टम प्रॉम्प्ट जवाब की लंबाई सीमित करता है, जो फ़ोन पर महत्वपूर्ण है: लंबे जवाब धीमे लगते हैं और उन्हें स्वाभाविक रूप से बीच में रोकना मुश्किल होता है।

Step 5: ulaw_8000 में Flash TTS से सिंथेसाइज़ करें

अब टेक्स्ट को ऐसे ऑडियो में बदलना है जिसे Twilio चला सके। outputFormat: "ulaw_8000" के साथ Flash v2.5 रिक्वेस्ट करें, ताकि बाइट्स Twilio की अपेक्षित एन्कोडिंग से मेल खाएं। फिर ऑडियो स्ट्रीम करें और हर चंक को media इवेंट के रूप में WebSocket पर वापस फ़ॉरवर्ड करें।

पूरे जवाब का इंतज़ार करने के बजाय, LLM टोकन्स को वाक्य-आकार के हिस्सों में जमा करें और हर हिस्सा पूरा होने पर उसे सिंथेसाइज़ करें। इससे टाइम-टू-फ़र्स्ट-ऑडियो कम होता है, क्योंकि मॉडल के दूसरा वाक्य बनाते समय कॉलर पहला वाक्य सुनता है। इंक्रीमेंटल सिंथेसिस पर ज्यादा नियंत्रण के लिए, रीयलटाइम TTS WebSocket गाइड बताती है कि टेक्स्ट को एक खुले सिंथेसिस सॉकेट में कैसे भेजें; नीचे दिया HTTP स्ट्रीमिंग तरीका सरल है और छोटे बातचीत वाले टर्न्स के लिए पर्याप्त है।

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const eleven = new ElevenLabsClient(); // reads ELEVENLABS_API_KEY
const VOICE_ID = "JBFqnCBsd6RMkjVDRZzb"; // George, a default voice

async function speak(ws, state, text: string) {
  state.agentSpeaking = true;
  const stream = await eleven.textToSpeech.stream(VOICE_ID, {
    text,
    modelId: "eleven_flash_v2_5",
    outputFormat: "ulaw_8000",
  });
  for await (const chunk of stream) {
    if (!state.agentSpeaking) break; // interrupted by barge-in
    ws.send(
      JSON.stringify({
        event: "media",
        streamSid: state.streamSid,
        media: { payload: Buffer.from(chunk).toString("base64") },
      })
    );
  }
  state.agentSpeaking = false;
}

अपने AI वॉइस एजेंट को प्रोडक्शन के लिए मज़बूत बनाएं

ऊपर दिए गए पांच स्टेप्स के बाद, आपके पास एक काम करने वाला एजेंट है। लेकिन यह प्रोडक्शन डिप्लॉयमेंट के समान नहीं है। 

एजेंट को असली फ़ोन लाइन पर लगाने से पहले आपको कई बातों का ध्यान रखना होगा।

Twilio वेबहुक सिग्नेचर सत्यापित करें

आपका वेबहुक URL जानने वाला कोई भी व्यक्ति उस पर POST कर सकता है, इसलिए सबसे पहले यह पुष्टि करें कि रिक्वेस्ट वास्तव में Twilio से आई है। Twilio हर रिक्वेस्ट पर X-Twilio-Signature हेडर में आपके Auth Token से साइन करता है और जो भी सत्यापन में विफल हो, उसे आपको अस्वीकार करना चाहिए। सिग्नेचर पूरे URL और POST पैरामीटर्स पर कैलकुलेट होता है, इसलिए आपको इसे Twilio की तरह ही कैलकुलेट करना होगा।

Twilio का हेल्पर आपके लिए यह करता है:

import twilio from "twilio";

app.post("/incoming-call", express.urlencoded({ extended: false }), (req, res) => {
  const url = `https://${process.env.PUBLIC_HOST}/incoming-call`;
  const valid = twilio.validateRequest(
    process.env.TWILIO_AUTH_TOKEN!,
    req.header("X-Twilio-Signature") || "",
    url,
    req.body
  );
  if (!valid) return res.sendStatus(403);
  // ... return TwiML as before
});

सीक्रेट्स को सही तरीके से मैनेज करें

ELEVENLABS_API_KEY, LLM key और TWILIO_AUTH_TOKEN को सीक्रेट्स मैनेजर में रखें, सोर्स में नहीं और न ही रेपो में कमिट की गई प्लेनटेक्स्ट env फ़ाइलों में। ElevenLabs key को केवल इस सर्विस के लिए ज़रूरी एंडपॉइंट्स तक सीमित रखें और उसे क्रेडिट कोटा दें, ताकि लीक होने पर नुकसान सीमित रहे। 

Enterprise प्लान में आप IP व्हाइटलिस्टिंग से किसी key को खास IP रेंज तक सीमित भी कर सकते हैं। यह सर्वर API key सीधे इस्तेमाल करता है, क्योंकि key कभी आपके बैकएंड से बाहर नहीं जाती; अगर कोई ऑडियो लॉजिक ब्राउज़र या मोबाइल क्लाइंट में ले जाया जाए, तो आप सिंगल-यूज़ टोकन्स पर स्विच करेंगे, ताकि key क्लाइंट-साइड पर कभी एक्सपोज़ न हो।

कनकरेंसी लिमिट को समझें

हर प्लान की कनकरेंसी लिमिट अलग-अलग मॉडल फैमिलीज़ के लिए अलग होती है और यह लिमिट गिनती है कि एक ही समय में कितनी रिक्वेस्ट्स सक्रिय रूप से ऑडियो जनरेट कर रही हैं।

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

फिर भी अनुमान लगाने के बजाय उपलब्ध क्षमता पर नज़र रखें। ElevenLabs के रिस्पॉन्स current-concurrent-requests और maximum-concurrent-requests हेडर्स दिखाते हैं; उन्हें लॉग करें और अधिकतम सीमा के करीब पहुंचने पर अलर्ट करें। लिमिट पार होने पर, रिक्वेस्ट्स प्राथमिकता के आधार पर क्यू में जाती हैं, जिससे आमतौर पर करीब 50ms जुड़ते हैं, और लगातार ओवरलोड होने पर HTTP 429 मिलता है। 

HTTP 429 रिस्पॉन्स को कम समय के बैकऑफ़ के साथ हैंडल करें। अगर ये जारी रहें, तो प्राइसिंग पेज पर अपग्रेड करके या Enterprise ग्राहकों के लिए अपने अकाउंट मैनेजर के ज़रिए लिमिट बढ़ाएं।

बार्ज-इन और रुकावटों को संभालें

एजेंट के बोलते समय बात शुरू करने वाला कॉलर चाहता है कि एजेंट रुक जाए। इसे बार्ज-इन कहते हैं और इसे सही तरीके से संभालना एजेंट को स्क्रिप्टेड के बजाय स्वाभाविक महसूस कराने का एक अहम हिस्सा है।

एजेंट के प्लेबैक के दौरान STT VAD सिग्नल से कॉलर की आवाज़ पहचानें। पहचान होने पर दो काम करें। पहला, TTS चंक्स फ़ॉरवर्ड करना बंद करें, जिसे speak में मौजूद agentSpeaking फ़्लैग पहले ही लूप तोड़कर संभालता है। दूसरा, Twilio को clear मैसेज भेजें, ताकि उसकी तरफ पहले से क्यू किया गया ऑडियो हट जाए।

function interrupt(ws, state) {
  state.agentSpeaking = false;
  ws.send(JSON.stringify({ event: "clear", streamSid: state.streamSid }));
}

अगर आप clear छोड़ देते हैं, तो भेजना बंद करने के बाद भी Twilio बफ़र किया हुआ ऑडियो चलाता रहता है, जिससे एजेंट कॉलर के ऊपर बोलता हुआ लगता है।

लॉग करें, मॉनिटर करें और सहजता से विफल हों

हर स्टेज को इंस्ट्रूमेंट करें, ताकि कॉल धीमी लगने पर आप लेटेंसी का स्रोत पहचान सकें। अंतिम ट्रांसक्रिप्ट से पहले LLM टोकन तक, पहले LLM टोकन से पहले TTS बाइट तक और पहले TTS बाइट से Twilio को भेजे गए फ़्रेम तक के अंतर को मापें। आपको दिखेगा कि आपकी अधिकांश बदलती हुई लेटेंसी LLM स्टेज में होती है; STT और TTS स्टेज तुलनात्मक रूप से स्थिर हैं।

फिर आंशिक विफलता की योजना बनाएं। LLM टाइम आउट हो सकता है, STT स्ट्रीम ड्रॉप हो सकती है और इंटरनेट पर ElevenLabs तक नेटवर्क राउंड-ट्रिप भौगोलिक स्थिति के आधार पर करीब 20 से 200ms तक बदलता है। अपना सर्वर केवल ElevenLabs के नहीं, बल्कि अपने कॉलर्स के भी पास रखें, क्योंकि ElevenLabs पहले से अपने उत्तरी अमेरिका, यूरोप और दक्षिण-पूर्व एशिया क्लस्टर्स में सबसे नज़दीकी क्लस्टर तक रूट करता है। 

किसी स्टेज के विफल होने पर कॉलर को चुप्पी में न छोड़ें: एक छोटा फ़ॉलबैक वाक्य ("माफ़ कीजिए, क्या आप फिर से कह सकते हैं?") सिंथेसाइज़ करें और कॉल चालू रखें। हर स्टेज को timeout और try/catch में रैप करें, ताकि एक विफल टर्न पूरा WebSocket बंद न कर दे।

शिप करने से पहले कुछ और डिफ़ॉल्ट्स सेट करना अच्छा रहेगा:

• जैसा दिखाया गया है, सिस्टम प्रॉम्प्ट में जवाब की लंबाई सीमित रखें, ताकि टर्न छोटे रहें और उन्हें बीच में रोका जा सके। 
• कन्वर्सेशन हिस्ट्री को सीमित रखें, ताकि लंबी कॉल्स में LLM कॉन्टेक्स्ट असीमित रूप से न बढ़े। 
• अटके हुए सेशंस को चुपचाप कनकरेंसी लेने से रोकने के लिए अधिकतम कॉल अवधि सेट करें।

जिन हिस्सों को आप नियंत्रित कर सकते हैं उन्हें और ट्यून करने के लिए, लेटेंसी डॉक्यूमेंट बताता है कि टाइम-टू-फ़र्स्ट-ऑडियो कहां से आता है, मॉडल्स ओवरव्यू स्पीड और क्वालिटी के ट्रेड-ऑफ़ समझाता है, और रीयलटाइम TTS WebSocket गाइड बताती है कि इंक्रीमेंटल टेक्स्ट इनपुट से सिंथेसिस लेटेंसी को और कैसे कम करें।

ElevenAPI के साथ प्रोडक्शन-रेडी वॉइस एजेंट बनाएं

अब 20 मिनट पूरे हो गए हैं और आपके पास प्रोडक्शन वॉइस एजेंट की हर लेयर है। Twilio टेलीफोनी संभालता है, Scribe v2 Realtime ट्रांसक्राइब करता है, LLM जवाब जनरेट करता है और Flash v2.5 उसी WebSocket पर बोलकर जवाब देता है। 

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

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

Twilio और ElevenLabs से वॉइस एजेंट बनाने के FAQ