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

एक वॉइस एजेंट इनबाउंड फोन कॉल्स का जवाब दे सकता है, कॉलर की बात को रियल टाइम में ट्रांसक्राइब कर सकता है

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

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

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

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

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

हर स्टेज एक पतला अडैप्टर है, इसलिए आप किसी भी सर्विस को बाकी को छुए बिना बदल सकते हैं। जैसे, आप OpenAI LLM को Anthropic से बदल सकते हैं बिना बाकी कंपोनेंट्स को री-राइट किए।

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

यह है वह फ्लो जिससे आप वॉइस एजेंट बनाएंगे:

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

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

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

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

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

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

ये हैं प्री-रिक्विज़िट्स:

1. Twilio फोन नंबर जिसमें वॉइस कैपेबिलिटी हो: नंबर के साथ-साथ अपना Account SID और Auth Token Twilio कंसोल से नोट कर लें।
2. ElevenLabs API key: यह आपकी ElevenLabs डैशबोर्ड में बनाई जाती है। यह कुंजी xi-api-key हेडर में जाती है और यह सीक्रेट है, इसलिए इसे सिर्फ सर्वर-साइड रखें। देखें
3. LLM API की: यह ट्यूटोरियल 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 मीडिया स्ट्रीम्स प्रोटोकॉल समझना

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

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

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

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

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

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

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

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

वेबहुक जो 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 के साथ।

स्टेप 2: मीडिया स्ट्रीम 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;
    }
  });
});

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

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

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

ये हैं स्टेप्स: कॉल शुरू होते ही 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 है, जिससे कॉलर के खत्म करने और एजेंट के शुरू करने के बीच का गैप छोटा रहता है। बैच वर्शन और पूरी फीचर लिस्ट के लिए देखें स्पीच टू टेक्स्ट डॉक्युमेंटेशन और रियलटाइम स्पीच टू टेक्स्ट प्रोडक्ट पेज।

स्टेप 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
  }
}

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

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

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

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

LLM टोकन्स को सेंटेंस-साइज़ फ्रैगमेंट्स में इकट्ठा करें और हर फ्रैगमेंट पूरा होते ही सिंथेसाइज़ करें, पूरे जवाब का इंतजार न करें। इससे time-to-first-audio कम होता है क्योंकि कॉलर पहली लाइन सुन लेता है जबकि मॉडल दूसरी बना रहा होता है। इनक्रिमेंटल सिंथेसिस पर ज्यादा कंट्रोल के लिए, रियलटाइम 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 हर रिक्वेस्ट को आपके Auth Token से X-Twilio-Signature हेडर में साइन करता है, और आपको हर फेल्ड वेलिडेशन को रिजेक्ट करना चाहिए। सिग्नेचर पूरे 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 की, और TWILIO_AUTH_TOKEN को सीक्रेट्स मैनेजर में रखें, सोर्स में या प्लेनटेक्स्ट env फाइल्स में नहीं। ElevenLabs की को सिर्फ उन्हीं एंडपॉइंट्स तक सीमित करें जिनकी इस सर्विस को जरूरत है और उस पर क्रेडिट कोटा लगाएं ताकि अगर लीक हो जाए तो नुकसान सीमित रहे।

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

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

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

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

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

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

बार्ज-इन और इंटरप्शन हैंडल करें

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

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

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 पहले से ही अपने नॉर्थ अमेरिका, यूरोप और साउथईस्ट एशिया क्लस्टर्स में रूट करता है।

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

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

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

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

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

अब जब 20 मिनट हो गए हैं, आपके पास प्रोडक्शन का हर लेयर तैयार है

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

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

Twilio और ElevenLabs के साथ वॉइस एजेंट बनाने से जुड़े सवाल-जवाब