> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# मल्टी-कॉन्टेक्स्ट WebSocket

> **उन्नत**
>
> इस मल्टी-कॉन्टेक्स्ट WebSocket API का उपयोग करके वॉइस एजेंट ऑर्केस्ट्रेट करना एक जटिल काम है, जिसकी
> सलाह उन्नत डेवलपर्स के लिए दी जाती है। ज़्यादा प्रबंधित समाधान के लिए, हमारे [Agents Platform प्रोडक्ट](/docs/hi/eleven-agents/overview) को देखें, जो इनमें से कई चुनौतियों को आसान बनाता है।

## परिचय

रिस्पॉन्सिव वॉइस एजेंट बनाने के लिए ऑडियो स्ट्रीम को डायनामिक रूप से मैनेज करने, इंटरप्शन को सहजता से संभालने और बातचीत के हर चरण में प्राकृतिक लगने वाली स्पीच बनाए रखने की क्षमता चाहिए। टेक्स्ट टू स्पीच (TTS) के लिए हमारा मल्टी-कॉन्टेक्स्ट WebSocket API खास तौर पर इन्हीं स्थितियों के लिए बनाया गया है।

यह API "कॉन्टेक्स्ट" की अवधारणा जोड़कर हमारी [स्टैंडर्ड TTS WebSocket फ़ंक्शनैलिटी](/docs/hi/eleven-api/guides/how-to/websockets/realtime-tts) को बढ़ाता है। हर कॉन्टेक्स्ट एक ही WebSocket कनेक्शन के भीतर एक स्वतंत्र ऑडियो जनरेशन स्ट्रीम की तरह काम करता है। इससे आप ये काम कर सकते हैं:

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

> **Warning**
>
> मल्टी-कॉन्टेक्स्ट WebSocket API वॉइस एप्लिकेशन के लिए ऑप्टिमाइज़ किया गया है और इसका उद्देश्य एक साथ कई असंबंधित
> ऑडियो स्ट्रीम जनरेट करना नहीं है। इसी को ध्यान में रखते हुए, हर कनेक्शन में अधिकतम 5
> कॉनकरेंट कॉन्टेक्स्ट हो सकते हैं।

यह गाइड आपको मल्टी-कॉन्टेक्स्ट WebSocket से कनेक्ट करने, कॉन्टेक्स्ट मैनेज करने और आकर्षक वॉइस एजेंट बनाने के लिए सर्वोत्तम तरीके अपनाने के बारे में बताएगी।

### सर्वोत्तम तरीके

> **Note**
>
> हमारे मल्टी-कॉन्टेक्स्ट WebSocket API के साथ रिस्पॉन्सिव और असरदार वॉइस एजेंट बनाने के लिए ये सर्वोत्तम तरीके ज़रूरी हैं।

#### एक ही WebSocket कनेक्शन इस्तेमाल करें

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

#### रिस्पॉन्स को चंक्स में स्ट्रीम करें, वाक्य जनरेट करें

लंबे रिस्पॉन्स जनरेट करते समय, टेक्स्ट को छोटे चंक्स में स्ट्रीम करें और पूरे वाक्यों के अंत में `flush: true` फ़्लैग
का इस्तेमाल करें। इससे जनरेट किए गए ऑडियो की क्वालिटी और रिस्पॉन्सिवनेस बेहतर होती है।

#### इंटरप्शन को सहजता से संभालें

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

#### कॉन्टेक्स्ट लाइफ़साइकल मैनेज करें

इस्तेमाल न होने वाले कॉन्टेक्स्ट तुरंत बंद करें। सर्वर हर कनेक्शन पर अधिकतम 5 कॉनकरेंट कॉन्टेक्स्ट
बनाए रख सकता है, लेकिन ज़रूरत न रहने पर आपको कॉन्टेक्स्ट बंद कर देने चाहिए।

#### कॉन्टेक्स्ट टाइमआउट रोकें

कॉन्टेक्स्ट डिफ़ॉल्ट रूप से 20 सेकंड बाद टाइमआउट हो जाते हैं और अपने-आप बंद हो जाते हैं। इनऐक्टिविटी
टाइमआउट एक WebSocket-लेवल पैरामीटर है, जो सभी कॉन्टेक्स्ट पर लागू होता है और ज़रूरत पड़ने पर 180 सेकंड तक
हो सकता है। टाइमआउट घड़ी रीसेट करने के लिए कॉन्टेक्स्ट पर खाली टेक्स्ट मैसेज भेजें।

### इंटरप्शन संभालना

जब कोई यूज़र आपके एजेंट को बीच में रोकता है, तो आपको [मौजूदा कॉन्टेक्स्ट बंद करना चाहिए](/docs/hi/api-reference/text-to-speech/v-1-text-to-speech-voice-id-multi-stream-input#send.Close-Context) और [नया कॉन्टेक्स्ट बनाना चाहिए](/docs/hi/api-reference/text-to-speech/v-1-text-to-speech-voice-id-multi-stream-input#send.Initialise-Context):

```python
async def handle_interruption(websocket, old_context_id, new_context_id, new_response):
    # Close the existing context that was interrupted
    await websocket.send(json.dumps({
        "context_id": old_context_id,
        "close_context": True
    }))
    print(f"Closed interrupted context '{old_context_id}'")

    # Create a new context for the new response
    await send_text_in_context(websocket, new_response, new_context_id)
```

```javascript
function handleInterruption(websocket: WebSocket, oldContextId: string, newContextId: string, newResponse: string) {
  // Close the existing context that was interrupted
  websocket.send(JSON.stringify({
    context_id: oldContextId,
    close_context: true
  }));
  console.log(`Closed interrupted context '${oldContextId}'`);

  // Create a new context for the new response
  sendTextInContext(websocket, newResponse, newContextId);
}
```

### कॉन्टेक्स्ट को सक्रिय रखना

कॉन्टेक्स्ट [डिफ़ॉल्ट रूप से 20 सेकंड की निष्क्रियता](/docs/hi/api-reference/text-to-speech/v-1-text-to-speech-voice-id-multi-stream-input#request.query.inactivity_timeout) के बाद अपने-आप टाइमआउट हो जाते हैं। अगर आपको टेक्स्ट जनरेट किए बिना कॉन्टेक्स्ट सक्रिय रखना है (उदाहरण के लिए, प्रोसेसिंग में देरी के दौरान), तो टाइमआउट घड़ी रीसेट करने के लिए आप खाली टेक्स्ट मैसेज भेज सकते हैं।

```python
async def keep_context_alive(websocket, context_id):
    await websocket.send(json.dumps({
        "context_id": context_id,
        "text": ""
    }))
```

```javascript
function handleInterruption(websocket: WebSocket, contextId: string) {
  // Close the existing context that was interrupted
  websocket.send(JSON.stringify({
    context_id: oldContextId,
    text: ""
  }));
}
```

### WebSocket कनेक्शन बंद करना

जब आपकी बातचीत खत्म हो जाए, तो आप [सॉकेट बंद करके](/docs/hi/api-reference/text-to-speech/v-1-text-to-speech-voice-id-multi-stream-input#send.Close-Socket) सभी कॉन्टेक्स्ट साफ़ कर सकते हैं:

```python
async def end_conversation(websocket):
    # This will close all contexts and close the connection
    await websocket.send(json.dumps({
        "close_socket": True
    }))
    print("Ending conversation and closing WebSocket")`
```

```javascript
function endConversation(websocket: WebSocket) {
  // This will close all contexts and close the connection
  websocket.send(JSON.stringify({
    close_socket: true
  }));
  console.log("Ending conversation and closing WebSocket");
}
```

## पूरा कन्वर्सेशनल एजेंट उदाहरण

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

* API की वाला ElevenLabs अकाउंट (जानें कि [अपनी API की कैसे ढूँढें](/docs/hi/api-reference/authentication))।
* आपकी मशीन पर Python या Node.js (या कोई अन्य JavaScript रनटाइम) इंस्टॉल होना चाहिए।
* WebSocket कम्यूनिकेशन की जानकारी। बुनियादी कॉन्सेप्ट समझने के लिए हम [स्टैंडर्ड WebSocket स्ट्रीमिंग पर हमारी गाइड](/docs/hi/eleven-api/guides/how-to/websockets/realtime-tts) पढ़ने की सलाह देते हैं।

### सेटअप

अपनी चुनी हुई भाषा के लिए ज़रूरी डिपेंडेंसी इंस्टॉल करें:

```python
pip install python-dotenv websockets
```

```javascript
npm install dotenv ws
for TypeScript, you might also want types:
npm install @types/dotenv @types/ws --save-dev
```

अपनी API की स्टोर करने के लिए प्रोजेक्ट डायरेक्टरी में .env फ़ाइल बनाएं:

**`.env`**

```python .env
ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
```

### उदाहरण वॉइस एजेंट

> **Note**
>
> यह कोड उदाहरण के तौर पर दिया गया है और प्रोडक्शन में इस्तेमाल के लिए नहीं है

```python maxLines=100
import os
import json
import asyncio
import websockets
from dotenv import load_dotenv

load_dotenv()
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
VOICE_ID = "your_voice_id"
MODEL_ID = "eleven_flash_v2_5"

WEBSOCKET_URI = f"wss://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}/multi-stream-input?model_id={MODEL_ID}"

async def send_text_in_context(websocket, text, context_id, voice_settings=None):
    """Send text to be synthesized in the specified context."""
    message = {
        "text": text,
        "context_id": context_id,
    }

    # Only include voice_settings for the first message in a context
    if voice_settings:
        message["voice_settings"] = voice_settings

    await websocket.send(json.dumps(message))

async def continue_context(websocket, text, context_id):
    """Add more text to an existing context."""
    await websocket.send(json.dumps({
        "text": text,
        "context_id": context_id
    }))

async def flush_context(websocket, context_id):
    """Force generation of any buffered audio in the context."""
    await websocket.send(json.dumps({
        "context_id": context_id,
        "flush": True
    }))

async def handle_interruption(websocket, old_context_id, new_context_id, new_response):
    """Handle user interruption by closing current context and starting a new one."""
    # Close the existing context that was interrupted
    await websocket.send(json.dumps({
        "context_id": old_context_id,
        "close_context": True
    }))

    # Create a new context for the new response
    await send_text_in_context(websocket, new_response, new_context_id)

async def end_conversation(websocket):
    """End the conversation and close the WebSocket connection."""
    await websocket.send(json.dumps({
        "close_socket": True
    }))

async def receive_messages(websocket):
    """Process incoming WebSocket messages."""
    context_audio = {}
    try:
        async for message in websocket:
            data = json.loads(message)
            context_id = data.get("contextId", "default")

            if data.get("audio"):
                print(f"Received audio for context '{context_id}'")

            if data.get("is_final"):
                print(f"Context '{context_id}' completed")
    except (websockets.exceptions.ConnectionClosed, asyncio.CancelledError):
        print("Message receiving stopped")

async def conversation_agent_demo():
    """Run a complete conversational agent demo."""
    # Connect with API key in headers
    async with websockets.connect(
        WEBSOCKET_URI,
        max_size=16 * 1024 * 1024,
        additional_headers={"xi-api-key": ELEVENLABS_API_KEY}
    ) as websocket:
        # Start receiving messages in background
        receive_task = asyncio.create_task(receive_messages(websocket))

        # Initial agent response
        await send_text_in_context(
            websocket,
            "Hello! I'm your virtual assistant. I can help you with a wide range of topics. What would you like to know about today?",
            "greeting"
        )

        # Wait a bit (simulating user listening)
        await asyncio.sleep(2)

        # Simulate user interruption
        print("USER INTERRUPTS: 'Can you tell me about the weather?'")

        # Handle the interruption by closing current context and starting new one
        await handle_interruption(
            websocket,
            "greeting",
            "weather_response",
            "I'd be happy to tell you about the weather. Currently in your area, it's 72 degrees and sunny with a slight chance of rain later this afternoon."
        )

        # Add more to the weather context
        await continue_context(
            websocket,
            " If you're planning to go outside, you might want to bring a light jacket just in case.",
            "weather_response"
        )

        # Flush at the end of this turn to ensure all audio is generated
        await flush_context(websocket, "weather_response")

        # Wait a bit (simulating user listening)
        await asyncio.sleep(3)

        # Simulate user asking another question
        print("USER: 'What about tomorrow?'")

        # Create a new context for this response
        await send_text_in_context(
            websocket,
            "Tomorrow's forecast shows temperatures around 75 degrees with partly cloudy skies. It should be a beautiful day overall!",
            "tomorrow_weather"
        )

        # Flush and close this context
        await flush_context(websocket, "tomorrow_weather")
        await websocket.send(json.dumps({
            "context_id": "tomorrow_weather",
            "close_context": True
        }))

        # End the conversation
        await asyncio.sleep(2)
        await end_conversation(websocket)

        # Cancel the receive task
        receive_task.cancel()
        try:
            await receive_task
        except asyncio.CancelledError:
            pass

if __name__ == "__main__":
    asyncio.run(conversation_agent_demo())

```

```javascript maxLines=100
// Import required modules
import dotenv from "dotenv";
import fs from "fs";
import WebSocket from "ws";

// Load environment variables
dotenv.config();
const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
const VOICE_ID = "your_voice_id";
const MODEL_ID = "eleven_flash_v2_5";

const WEBSOCKET_URI = `wss://api.elevenlabs.io/v1/text-to-speech/${VOICE_ID}/multi-stream-input?model_id=${MODEL_ID}`;

// Function to send text in a specific context
function sendTextInContext(websocket, text, contextId, voiceSettings = null) {
  const message = {
    text: text,
    context_id: contextId,
  };

  // Only include voice_settings for the first message in a context
  if (voiceSettings) {
    message.voice_settings = voiceSettings;
  }

  websocket.send(JSON.stringify(message));
}

// Function to continue an existing context with more text
function continueContext(websocket, text, contextId) {
  websocket.send(
    JSON.stringify({
      text: text,
      context_id: contextId,
    })
  );
}

// Function to flush a context, forcing generation of buffered audio
function flushContext(websocket, contextId) {
  websocket.send(
    JSON.stringify({
      context_id: contextId,
      flush: true,
    })
  );
}

// Function to handle user interruption
function handleInterruption(websocket, oldContextId, newContextId, newResponse) {
  // Close the existing context that was interrupted
  websocket.send(
    JSON.stringify({
      context_id: oldContextId,
      close_context: true,
    })
  );

  // Create a new context for the new response
  sendTextInContext(websocket, newResponse, newContextId);
}

// Function to end the conversation and close the connection
function endConversation(websocket) {
  websocket.send(
    JSON.stringify({
      close_socket: true,
    })
  );
}

// Function to run the conversation agent demo
async function conversationAgentDemo() {
  // Connect to WebSocket with API key in headers
  const websocket = new WebSocket(WEBSOCKET_URI, {
    headers: {
      "xi-api-key": ELEVENLABS_API_KEY,
    },
    maxPayload: 16 * 1024 * 1024,
  });

  // Set up event handlers
  websocket.on("open", () => {
    // Initial agent response
    sendTextInContext(
      websocket,
      "Hello! I'm your virtual assistant. I can help you with a wide range of topics. What would you like to know about today?",
      "greeting"
    );

    // Simulate wait time (user listening)
    setTimeout(() => {
      // Simulate user interruption
      console.log("USER INTERRUPTS: 'Can you tell me about the weather?'");

      // Handle the interruption
      handleInterruption(
        websocket,
        "greeting",
        "weather_response",
        "I'd be happy to tell you about the weather. Currently in your area, it's 72 degrees and sunny with a slight chance of rain later this afternoon."
      );

      // Add more to the weather context
      setTimeout(() => {
        continueContext(
          websocket,
          " If you're planning to go outside, you might want to bring a light jacket just in case.",
          "weather_response"
        );

        // Flush at the end of this turn
        flushContext(websocket, "weather_response");

        // Simulate wait time (user listening)
        setTimeout(() => {
          // Simulate user asking another question
          console.log("USER: 'What about tomorrow?'");

          // Create a new context for this response
          sendTextInContext(
            websocket,
            "Tomorrow's forecast shows temperatures around 75 degrees with partly cloudy skies. It should be a beautiful day overall!",
            "tomorrow_weather"
          );

          // Flush and close this context
          flushContext(websocket, "tomorrow_weather");
          websocket.send(
            JSON.stringify({
              context_id: "tomorrow_weather",
              close_context: true,
            })
          );

          // End the conversation
          setTimeout(() => {
            endConversation(websocket);
          }, 2000);
        }, 3000);
      }, 500);
    }, 2000);
  });

  // Handle incoming messages
  websocket.on("message", (message) => {
    try {
      const data = JSON.parse(message);
      const contextId = data.contextId || "default";

      if (data.audio) {
        //do stuff
      }

      if (data.is_final) {
        console.log(`Context '${contextId}' completed`);
      }
    } catch (error) {
      console.error("Error parsing message:", error);
    }
  });

  // Handle WebSocket closure
  websocket.on("close", () => {
    console.log("WebSocket connection closed");
  });

  // Handle WebSocket errors
  websocket.on("error", (error) => {
    console.error("WebSocket error:", error);
  });
}

// Run the demo
conversationAgentDemo();
```

## अगले चरण

#### [ElevenAgents](/docs/hi/eleven-agents/quickstart)

पूरे ElevenAgents प्लेटफ़ॉर्म के साथ प्रोडक्शन-रेडी वॉइस एजेंट बनाएं।

#### [ऑडियो स्ट्रीमिंग को समझना](/docs/hi/eleven-api/concepts/audio-streaming)

जानें कि WebSocket स्ट्रीमिंग अंदर से कैसे काम करती है और लेटेंसी पर किन चीज़ों का असर पड़ता है।