> 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.

# कॉल क्यूइंग

## जानकारी

जब कोई एजेंट या workspace अपनी concurrency limit पर पहुंच जाता है, तो नई कॉल आम तौर पर तुरंत अस्वीकार कर दी जाती हैं। कॉल क्यूइंग चालू होने पर, एजेंट की क्षमता पूरी होने के दौरान आने वाले कॉल करने वालों को होल्ड ऑडियो के साथ लाइन पर रखा जाता है और जगह खाली होते ही उनके आने के क्रम में अपने-आप कनेक्ट कर दिया जाता है।

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

> **Note**
>
> कॉल क्यूइंग तब लागू होती है, जब उपलब्ध सारी क्षमता इस्तेमाल हो रही हो। इसमें उस स्थिति की burst capacity भी शामिल है, जब एजेंट के लिए [burst pricing](/docs/hi/eleven-agents/guides/burst-pricing) चालू हो।

## कॉल क्यूइंग कैसे काम करती है

1. **क्षमता जांच**: कॉल आने पर ElevenAgents जांचता है कि एजेंट और workspace में कोई खाली concurrency slot है या नहीं। अगर है, तो कॉल तुरंत कनेक्ट हो जाती है।
2. **कतार में रखना**: अगर कोई slot उपलब्ध नहीं है, तो कॉल करने वाले को एजेंट की कतार में रखा जाता है और उसे होल्ड ऑडियो सुनाई देता है। कॉल करने वाले के इंतज़ार के दौरान कोई बातचीत शुरू नहीं होती और कोई शुल्क नहीं लगता।
3. **कनेक्शन**: जैसे ही कोई slot खाली होता है, कतार में सबसे आगे मौजूद कॉल करने वाले को कनेक्ट कर दिया जाता है और बातचीत सामान्य रूप से शुरू हो जाती है।
4. **टाइमआउट**: अगर **अधिकतम कतार प्रतीक्षा समय** के भीतर कोई slot खाली नहीं होता, तो कॉल डिस्कनेक्ट कर दी जाती है। टेलीफोनी कॉल सामान्य रूप से काट दी जाती हैं। WebSocket क्लाइंट को status `timed_out` के साथ `queue_status` event मिलता है, जिसके बाद code 4300 के साथ कनेक्शन बंद हो जाता है।

किसी एजेंट के लिए कॉल करने वालों को आने के क्रम में ही कनेक्ट किया जाता है। जब कई एजेंट किसी workspace का concurrency pool साझा करते हैं, तो आम तौर पर लंबे समय से इंतज़ार कर रहे कॉल करने वालों को पहले कनेक्ट किया जाता है।

### कॉल करने वाले को क्या सुनाई देता है

* Twilio और SIP trunk नंबरों पर कॉल करने वालों को कॉल के दौरान होल्ड ऑडियो सुनाई देता है।
* Widget और browser SDK यूज़र को ब्राउज़र में होल्ड ऑडियो सुनाई देता है। widget (वर्ज़न 0.17.0 या उसके बाद का) प्रतीक्षा संदेश भी दिखाता है और कतार में होने पर टेक्स्ट इनपुट बंद कर देता है।
* Direct WebSocket API क्लाइंट को सामान्य `audio` events के रूप में होल्ड ऑडियो मिलता है, साथ ही अपने UI में प्रतीक्षा स्थिति दिखाने के लिए `queue_status` events भी मिलते हैं। [कतार events हैंडल करना](#handling-queue-events-in-a-custom-websocket-client) देखें।

### बिलिंग और बातचीत की अवधि

कतार में बिताया गया समय **बिल नहीं किया जाता**, एजेंट की **अधिकतम बातचीत अवधि** में नहीं गिना जाता और बातचीत की बताई गई अवधि में शामिल नहीं होता। डैशबोर्ड में बातचीत की जानकारी दिखाती है कि कनेक्ट होने से पहले कॉल करने वाले ने कितनी देर इंतज़ार किया।

## समर्थित चैनल

| चैनल                                         | कॉल क्यूइंग  |
| -------------------------------------------- | ------------ |
| Twilio इनबाउंड कॉल                           | समर्थित      |
| SIP trunk इनबाउंड कॉल                        | समर्थित      |
| Widget और client SDKs (WebSocket और WebRTC)  | समर्थित      |
| Direct WebSocket API                         | समर्थित      |
| आउटबाउंड कॉल और बैच कॉल                      | समर्थित नहीं |
| सिर्फ़ टेक्स्ट वाले एजेंट                    | समर्थित नहीं |
| Genesys, AudioCodes, Exotel, WhatsApp और SMS | समर्थित नहीं |

> **Note**
>
> रोज़ाना की कॉल limit को कतार में नहीं रखा जाता। एजेंट की दैनिक limit से अधिक होने वाली कॉल तुरंत अस्वीकार कर दी जाती है,
> क्योंकि यह limit अगले दिन तक खाली नहीं होती।

## कॉन्फ़िगरेशन

कॉल क्यूइंग को एजेंट के **Security** टैब के **Limits** सेक्शन में, हर एजेंट के लिए अलग से कॉन्फ़िगर किया जाता है।

| सेटिंग                        | विवरण                                                                                                                                                                                                                   | डिफ़ॉल्ट           |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| **कॉल क्यूइंग चालू करें**     | एजेंट की concurrency limit पूरी होने पर कॉल करने वालों को कतार में रखें।                                                                                                                                                | चालू               |
| **अधिकतम कतार प्रतीक्षा समय** | कॉल डिस्कनेक्ट होने से पहले कॉल करने वाला कितनी देर इंतज़ार कर सकता है, सेकंड में। 1 से 1,800 सेकंड (30 मिनट) के बीच।                                                                                                   | 180 सेकंड (3 मिनट) |
| **कस्टम होल्ड ऑडियो**         | कतार में मौजूद कॉल करने वालों के लिए लूप में चलने वाली MP3 या WAV फ़ाइल। अधिकतम 40 MB और 3 मिनट लंबी। कोई फ़ाइल अपलोड न होने पर, कॉल करने वालों को डिफ़ॉल्ट होल्ड टोन सुनाई देती है। इसे डैशबोर्ड या API से अपलोड करें। | डिफ़ॉल्ट होल्ड टोन |

#### डैशबोर्ड से अपडेट करें

#### Limits सेटिंग खोलें

डैशबोर्ड में अपना एजेंट खोलें, **Security** टैब पर जाएं और **Limits** तक स्क्रॉल करें।

#### कॉल क्यूइंग चालू करें

सुनिश्चित करें कि **कॉल क्यूइंग चालू करें** चालू है और **अधिकतम कतार प्रतीक्षा समय** सेट करें।

#### होल्ड ऑडियो अपलोड करें (वैकल्पिक)

**कस्टम होल्ड ऑडियो** के अंतर्गत MP3 या WAV फ़ाइल अपलोड करें। पब्लिश करने से पहले आप डिफ़ॉल्ट होल्ड टोन और अपनी अपलोड की गई क्लिप का प्रीव्यू देख सकते हैं।

#### अपने बदलाव पब्लिश करें

नई सेटिंग लागू करने के लिए **Publish** पर क्लिक करें।

#### CLI से अपडेट करें

#### एजेंट कॉन्फ़िगरेशन प्राप्त करें

```bash
elevenlabs agents pull --agent "<agent-name>"
```

#### \`agent_configs/\<agent-name>.json\` संपादित करें

`platform_settings.queueing_config` सेट करें:

```json
{
  "platform_settings": {
    "queueing_config": {
      "enabled": true,
      "wait_timeout_seconds": 300
    }
  }
}
```

#### अपने बदलाव पुश करें

```bash
elevenlabs agents push --agent "<agent-name>"
```

#### API से अपडेट करें

```python
from dotenv import load_dotenv
from elevenlabs import ElevenLabs
import os

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    platform_settings={
        "queueing_config": {
            "enabled": True,
            "wait_timeout_seconds": 300,
        },
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  platformSettings: {
    queueingConfig: {
      enabled: true,
      waitTimeoutSeconds: 300,
    },
  },
});
```

नए एजेंट में `queueing_config.enabled` को `true` पर सेट करके बनाया जाता है। कॉल क्यूइंग बंद करके एजेंट बनाने के लिए, create request में `queueing_config.enabled` को `false` पर सेट करें।

### API से होल्ड ऑडियो प्रबंधित करना

एजेंट का कस्टम होल्ड ऑडियो सेट करने के लिए MP3 या WAV फ़ाइल अपलोड करें। नई फ़ाइल अपलोड करने पर पिछली फ़ाइल बदल जाती है। API `audio/mpeg` और `audio/wav` content types स्वीकार करता है, इसलिए उदाहरणों में type साफ़ तौर पर सेट किया गया है।

```python
from dotenv import load_dotenv
from elevenlabs import ElevenLabs
import os

load_dotenv()

elevenlabs = ElevenLabs(
api_key=os.getenv("ELEVENLABS_API_KEY"),
)

elevenlabs.conversational_ai.agents.hold_audio.create(
agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
hold_audio_file=("hold-music.mp3", open("hold-music.mp3", "rb"), "audio/mpeg"),
)

```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import fs from "node:fs";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const holdAudioFile = new File([fs.readFileSync("hold-music.mp3")], "hold-music.mp3", {
  type: "audio/mpeg",
});

await elevenlabs.conversationalAi.agents.holdAudio.create("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  holdAudioFile,
});
```

डिफ़ॉल्ट होल्ड टोन पर वापस जाने के लिए कस्टम क्लिप हटाएं:

```python
elevenlabs.conversational_ai.agents.hold_audio.delete(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
)
```

```typescript
await elevenlabs.conversationalAi.agents.holdAudio.delete("agent_7101k5zvyjhmfg983brhmhkd98n6");
```

वर्तमान क्लिप एजेंट पर `platform_settings.queueing_config.hold_audio` के रूप में केवल पढ़ने के लिए उपलब्ध होती है। एजेंट create या update request में `hold_audio` भेजने का कोई असर नहीं होता।

## कस्टम WebSocket क्लाइंट में कतार events हैंडल करना

[WebSocket API](/docs/hi/eleven-agents/libraries/web-sockets) से कनेक्ट किए गए क्लाइंट को कतार में होने के दौरान `queue_status` events मिलते हैं:

```json
{
  "type": "queue_status",
  "queue_status_event": {
    "status": "waiting"
  }
}
```

* `waiting` एक बार भेजा जाता है, `conversation_initiation_metadata` के तुरंत बाद और किसी भी होल्ड ऑडियो से पहले।
* कॉल करने वाला कनेक्ट होने पर `admitted` भेजा जाता है। इसके बाद बातचीत सामान्य रूप से चलती है।
* प्रतीक्षा का समय अधिकतम कतार प्रतीक्षा समय से अधिक होने पर `timed_out` भेजा जाता है। इसके बाद सर्वर code 4300 के साथ कनेक्शन बंद कर देता है।

तुरंत कनेक्ट होने वाली कॉल को कभी भी `queue_status` events नहीं मिलते। यह event हमेशा कतार में मौजूद कॉल करने वालों को भेजा जाता है और एजेंट के `client_events` में इसे चालू करने की ज़रूरत नहीं होती।

होल्ड ऑडियो नियमित `audio` events के रूप में, लगभग एक-सेकंड के chunks में डिलीवर होता है, बशर्ते एजेंट के client events में `audio` शामिल हो। होल्ड ऑडियो को एजेंट की आवाज़ मानने के बजाय प्रतीक्षा स्थिति दिखाने के लिए `queue_status` का इस्तेमाल करें।

> **Info**
>
> `@elevenlabs/client` और `@elevenlabs/react` SDKs में अभी इस event के लिए अलग callback उपलब्ध नहीं है।
> `queue_status` समेत raw server events देखने के लिए `onIncomingEvent` callback का इस्तेमाल करें।

## अक्सर पूछे जाने वाले सवाल

#### क्या कतार में मौजूद कॉल मेरी concurrency limit में गिनी जाती है?

नहीं। कतार में मौजूद कॉल करने वाला, एजेंट से कनेक्ट होने तक कोई concurrency slot नहीं लेता।

#### क्या कॉल करने वाले को कतार में अपनी जगह या अनुमानित प्रतीक्षा समय सुनाई दे सकता है?

फ़िलहाल नहीं। कतार में मौजूद कॉल करने वाले को सिर्फ़ होल्ड ऑडियो सुनाई देता है। कतार में स्थान और प्रतीक्षा समय के अनुमान की घोषणा नहीं की जाती।

#### अगर कॉल करने वाला इंतज़ार के दौरान कॉल काट दे तो क्या होता है?

कॉल करने वाला तुरंत कतार छोड़ देता है और उसके पीछे मौजूद सभी लोग एक स्थान आगे आ जाते हैं। बातचीत के कोई मिनट चार्ज नहीं होते।

#### क्या कॉल क्यूइंग आउटबाउंड कॉल के साथ काम करती है?

नहीं। आउटबाउंड और बैच कॉल सिर्फ़ क्षमता उपलब्ध होने पर की जाती हैं, इसलिए उन्हें कभी कतार में नहीं रखा जाता।