रीयल-टाइम में डायलॉग स्ट्रीम करें

टेक्स्ट टू डायलॉग WebSocket (/v1/text-to-dialogue/stream-input) एक ही कनेक्शन को खुला रखता है, जबकि आप डायलॉग लाइनें भेजते हैं और base64-encoded ऑडियो चंक्स पाते हैं। यह सिर्फ़ Eleven v3 डायलॉग मॉडल के लिए है (model_id की शुरुआत eleven_v3 से होनी चाहिए)।

ज़रूरी चीज़ें

• API key वाला ElevenLabs अकाउंट (ऑथेंटिकेशन)।
• API key में Text to Speech परमिशन होनी चाहिए।
• आपकी मशीन पर Python या Node.js इंस्टॉल होना चाहिए।

सेटअप

pip install python-dotenv websockets

एक .env फ़ाइल बनाएं:

ELEVENLABS_API_KEY=your_elevenlabs_api_key_here

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

WebSocket खोलें

model_id और output_format जैसे क्वेरी पैरामीटर के साथ wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input से कनेक्ट करें। API key को xi-api-key हेडर में या पहले JSON मैसेज में भेज सकते हैं (यहां अलग-अलग भाषाओं में एक जैसा पैटर्न रखने के लिए इसे body में दिखाया गया है)।

import asyncio
import base64
import json
import os
from dotenv import load_dotenv
import websockets
load_dotenv()
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
VOICE_ID = "21m00Tcm4TlvDq8ikWAM"
MODEL_ID = "eleven_v3_conversational"
URI = (
    "wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input"
    f"?model_id={MODEL_ID}&output_format=mp3_44100_128"
)

वॉइस रजिस्टर करें और टेक्स्ट स्ट्रीम करें

एक पहला मैसेज भेजें, जिसमें voices (ज़रूरी) और xi_api_key शामिल हो, अगर आपने xi-api-key हेडर सेट नहीं किया है। फिर inputs वाले एक या ज़्यादा फ्रेम भेजें: हर आइटम में text, voice_id और वैकल्पिक new_turn होता है।

सर्वर पर्याप्त कॉन्टेक्स्ट मिलने तक टेक्स्ट को बफ़र करता है (लगभग 40 अक्षर और 8 शब्द), फिर audio चंक्स भेजता है। रिस्पॉन्स फ़ील्ड में snake_case इस्तेमाल होता है (उदाहरण के लिए is_final)।

async def stream_dialogue():
    async with websockets.connect(URI) as websocket:
        await websocket.send(
            json.dumps(
                {
                    "voices": [VOICE_ID],
                    "xi_api_key": ELEVENLABS_API_KEY,
                }
            )
        )
        line = (
            "This is a longer line of dialogue used to exceed the minimum buffer so the model "
            "starts generating streamed audio for the registered voice. "
        )
        await websocket.send(
            json.dumps(
                {
                    "inputs": [
                        {"text": line, "voice_id": VOICE_ID, "new_turn": False},
                    ],
                }
            )
        )
        await websocket.send(json.dumps({"close_socket": True}))
        os.makedirs("output", exist_ok=True)
        out_path = "output/dialogue-ws.mp3"
        with open(out_path, "wb") as audio_file:
            while True:
                raw = await websocket.recv()
                msg = json.loads(raw)
                if msg.get("error"):
                    raise RuntimeError(msg)
                if msg.get("audio"):
                    audio_file.write(base64.b64decode(msg["audio"]))
                if msg.get("is_final"):
                    break
        print(f"Wrote {out_path}")
asyncio.run(stream_dialogue())

close_socket बफ़र किए गए टेक्स्ट को भेजता है, बाकी ऑडियो भेजता है, फिर कनेक्शन बंद होने से पहले is_final: true वाला अंतिम फ्रेम भेजता है। लाइनों के बीच कनेक्शन खुला रखने के लिए, सेशन खत्म होने तक close_socket शामिल न करें; कनेक्शन बंद किए बिना छोटे बफ़र के लिए ऑडियो जनरेट करने हेतु flush इस्तेमाल करें।

स्क्रिप्ट चलाएं

python text-to-dialogue-websocket.py

आपको output/ में एक MP3 फ़ाइल मिलेगी (फ़ाइलनाम ऊपर के उदाहरण जैसा होगा)।

व्यवहार संबंधी नोट्स

बफ़रिंग

TTS WebSocket के chunk_length_schedule के विपरीत, डायलॉग स्ट्रीमिंग पहले आंशिक ऑडियो से पहले निश्चित सर्वर थ्रेशहोल्ड (अक्षर और शब्द संख्या) इस्तेमाल करती है। अगर आप छोटी लाइनें भेजते हैं और देरी सुनाई देती है, तो हर inputs फ्रेम में थोड़ा ज़्यादा टेक्स्ट एक साथ भेजें या सॉकेट बंद किए बिना जनरेशन शुरू करने के लिए flush: true भेजें।

टर्न और वॉइस

जब कोई स्पीकर अपना टर्न पूरा करे, तो new_turn: true सेट करें, ताकि प्रोसोडी साफ़ तौर पर रीसेट हो। inputs एंट्री के बीच voice_id बदलने पर भी नया टर्न शुरू होता है। eleven_v3_conversational के साथ voices में ठीक एक वॉइस रजिस्टर करें; eleven_v3 अधिकतम 10 रजिस्टर्ड वॉइस सपोर्ट करता है।

निष्क्रियता

अगर सर्वर को 20 सेकंड तक कोई क्लाइंट मैसेज नहीं मिलता, तो कनेक्शन बंद हो जाता है। ऑडियो सिंथेसाइज़ किए बिना टाइमर रीसेट करने के लिए {"keep_alive": true} भेजें।

कॉन्करेंसी

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

अलाइनमेंट

उपलब्ध होने पर चंक्स में alignment ऑब्जेक्ट (snake_case टाइमिंग ऐरे) पाने के लिए क्वेरी स्ट्रिंग में sync_alignment=true जोड़ें। API रेफरेंस देखें।

आगे के चरण