> This is a page from the ElevenLabs documentation. For an index of the documentation, fetch https://elevenlabs.io/docs/llms.txt.

# Voximplant

> **Warning**
>
> Voximplant इंटीग्रेशन सीमित उपलब्धता में है और इसे हर workspace के लिए अलग से सक्षम किया जाता है। ग्राहक ट्रैफ़िक रूट करने से पहले अपने
> ElevenLabs प्रतिनिधि से संपर्क करें।

## परिचय

Voximplant इंटीग्रेशन, Voximplant Media Streams का उपयोग करके VoxEngine scenario में किसी कॉल को सीधे WebSocket के ज़रिए
ElevenAgents के एजेंट से जोड़ता है। टेलीफ़ोनी Voximplant संभालता है:
वही कॉल डायल या रिसीव करता है और तय करता है कि उसके बाद क्या होगा। बातचीत ElevenAgents संभालता है।
किसी SIP trunk या middleware की ज़रूरत नहीं है।

इनबाउंड और आउटबाउंड कॉल एक ही तरह काम करती हैं: कॉल कनेक्ट होने के बाद, scenario हर कॉल के लिए ElevenLabs पर एक
WebSocket खोलता है। बातचीत खत्म होने पर, ElevenLabs scenario को एक decision event भेजता है, जिसमें बताया जाता है कि कॉलर को किसी इंसान के पास ट्रांसफ़र करना है, कॉल काटनी है या कॉल को timeout मानना है।

## इंटीग्रेशन कैसे काम करता है

1. आपका VoxEngine scenario इनबाउंड कॉल रिसीव करता है या आउटबाउंड कॉल करता है।
2. scenario आपके एजेंट के ElevenLabs endpoint पर WebSocket खोलता है और ElevenLabs API key को bearer token के तौर पर इस्तेमाल करके authentication करता है।
3. scenario किसी भी `customParameters` को पास करते हुए `call.sendMediaTo()` से media stream शुरू करता है।
   ElevenLabs हर parameter को dynamic variable में बदलता है और अपना `start` भेजकर जवाब देता है।
4. Voximplant और ElevenLabs, `media` messages में 8 kHz पर 16-bit linear PCM ऑडियो एक्सचेंज करते हैं।
5. बातचीत खत्म होने पर, ElevenLabs एजेंट के आखिरी वाक्यांश का बाकी हिस्सा, एक
   `elevenlabs-decision` custom event और एक `stop` message भेजता है। इसके बाद scenario WebSocket बंद करता है
   और decision के अनुसार कार्रवाई करता है।

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

शुरू करने से पहले, सुनिश्चित करें कि आपके पास ये चीज़ें हैं:

1. एक application, फोन नंबर या outbound calling, और scenarios एडिट करने की अनुमति वाला Voximplant अकाउंट।
2. Voximplant इंटीग्रेशन सक्षम किया हुआ ElevenLabs workspace।
3. एक ElevenLabs एजेंट और एक अलग API key।

## ElevenLabs कॉन्फ़िगर करें

#### एजेंट बनाएं या चुनें

ElevenAgents में एजेंट बनाएं। अगर कॉल कनेक्ट होते ही उसे बोलना चाहिए, तो उसे पहला संदेश दें। ऑडियो formats इंटीग्रेशन द्वारा सेट होते हैं, इसलिए एजेंट के कॉन्फ़िगर किए गए formats का इस्तेमाल Voximplant कॉल के लिए नहीं होता।

#### End call सक्षम करें

एजेंट को बातचीत खत्म करने देने के लिए **Agent → Tools → System tools** में **End call** सक्षम करें।
कॉल खत्म करते समय एजेंट जो कारण देता है, वह decision के साथ आपके scenario को भेजा जाता है।

#### Voximplant ट्रांसफ़र नियम जोड़ें (वैकल्पिक)

एजेंट को कॉलर को किसी इंसान के पास भेजने देने के लिए, उसे **Transfer to number** system tool दें, जिसमें provider configuration `voximplant` वाला ट्रांसफ़र नियम हो। इस नियम में कोई destination नहीं होता: बातचीत `transfer-to-agent` decision के साथ खत्म होती है और आपका scenario कॉलर को रूट करता है। ट्रांसफ़र नियम API के ज़रिए कॉन्फ़िगर किए जाते हैं। एजेंट पर `PATCH` करके tool जोड़ें:

```bash
curl -X PATCH "https://api.elevenlabs.io/v1/convai/agents/agent_7101k5zvyjhmfg983brhmhkd98n6" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "conversation_config": {"agent": {"prompt": {"built_in_tools": {
      "end_call": {"type": "system", "name": "end_call", "description": "",
                   "params": {"system_tool_type": "end_call"}},
      "transfer_to_number": {
        "type": "system", "name": "transfer_to_number", "description": "",
        "params": {
          "system_tool_type": "transfer_to_number",
          "transfers": [],
          "transfer_rules": [{
            "condition": "the caller asks to speak with a human",
            "provider_configs": [
              {"type": "voximplant", "config": {"type": "voximplant_handoff"}}
            ]
          }]
        }
      }
    }}}}
  }'
```

एजेंट का पूरा `built_in_tools` object भेजें, जिसमें उसके मौजूदा tools भी शामिल हों, जैसे `end_call`।
एजेंट जो option वापस भेजता है, वह तय token `voximplant` होता है, इसलिए हर tool के लिए एक Voximplant नियम काफ़ी है। अन्य providers के लिए कॉन्फ़िगर किए गए फोन नंबर और SIP URIs, Voximplant कॉल पर उपलब्ध नहीं होते।

> **Note**
>
> ट्रांसफ़र नियम API से प्रबंधित सेटिंग हैं। इनका उपयोग करने वाले एजेंट के **Transfer to number** tool को ऊपर बताए अनुसार API से कॉन्फ़िगर और अपडेट करें; dashboard का tool editor हर नंबर की ट्रांसफ़र सूची के साथ काम करता है।

#### अलग API key बनाएं

एजेंट वाले workspace में API key बनाएं और इसे ElevenAgents तक सीमित रखें। केवल Voximplant से कनेक्शन स्वीकार करने के लिए, key के allowed IP addresses को Voximplant के media servers तक सीमित करें, जिनकी सूची Voximplant यहां देता है:
`https://api.voximplant.com/getMediaResources?with_mediaservers`।

#### WebSocket URL नोट करें

scenario एक ऐसे URL से कनेक्ट होता है जिसमें आपकी agent ID होती है:

| Environment    | URL                                                                                                               |
| -------------- | ----------------------------------------------------------------------------------------------------------------- |
| डिफ़ॉल्ट       | `wss://api.elevenlabs.io/v1/convai/conversation/voximplant/agent_7101k5zvyjhmfg983brhmhkd98n6`                    |
| डेटा रेजिडेंसी | `wss://api.<region>.residency.elevenlabs.io/v1/convai/conversation/voximplant/agent_7101k5zvyjhmfg983brhmhkd98n6` |

एजेंट की किसी branch को pin करने के लिए `?branch_id=<branch_id>` जोड़ें।

> **Info**
>
> अगर आपका ElevenLabs अकाउंट किसी isolated residency environment पर है, तो `<region>` को अपने region code से बदलें। उपलब्ध regions के लिए [डेटा रेजिडेंसी](/docs/hi/overview/administration/data-residency) देखें।

## Voximplant सेट अप करें

#### Application बनाएं

[Voximplant control panel](https://manage.voximplant.com/applications) में **Applications** खोलें
और **Create application** पर क्लिक करें। इसे कोई नाम दें, उदाहरण के लिए `elevenlabs-agent`, और **Create** पर क्लिक करें।

![Voximplant: Application बनाएं](/docs/_fern-files/_img/29af341fa0a32eaaab444ade8305208121487413c5868597386a973b14fe4fe7.webp)

#### API key को secret के रूप में स्टोर करें

Application में **Secrets** खोलें और **Add secret** पर क्लिक करें। इसका नाम `ELEVENLABS_API_KEY` रखें, एजेंट के workspace के लिए बनाई गई API key को **Value** में पेस्ट करें और **Add secret** पर क्लिक करें।
scenario इसे `VoxEngine.getSecretValue()` से पढ़ता है, इसलिए key कभी scenario code में दिखाई नहीं देती।

![Voximplant: Secret जोड़ें](/docs/_fern-files/_img/ecf8be823bbc15b263e3f4838684a78de3a3594704be0055b443d15ab93e1485.webp)

#### Scenario बनाएं

**Scenarios** खोलें, **Create scenario** पर क्लिक करें, इसका नाम `elevenlabs_agent` रखें, नीचे दिया code पेस्ट करें,
`ELEVENLABS_URL` में agent ID बदलें और **Save** पर क्लिक करें। यह इनबाउंड कॉल रिसीव करता है, उसे एजेंट को स्ट्रीम करता है और बातचीत खत्म होने पर decision के अनुसार कार्रवाई करता है। आउटबाउंड कॉल के लिए, की गई कॉल के `CallEvents.Connected` handler में WebSocket खोलें।

```javascript maxLines=0
const ELEVENLABS_URL =
  "wss://api.elevenlabs.io/v1/convai/conversation/voximplant/agent_7101k5zvyjhmfg983brhmhkd98n6";

VoxEngine.addEventListener(AppEvents.CallAlerting, ({ call }) => {
  call.answer();
  let decision = null;

  const ws = VoxEngine.createWebSocket(ELEVENLABS_URL, {
    headers: [
      {
        name: "Authorization",
        value: `Bearer ${VoxEngine.getSecretValue("ELEVENLABS_API_KEY")}`,
      },
    ],
  });

  ws.addEventListener(WebSocketEvents.OPEN, () => {
    call.sendMediaTo(ws, {
      encoding: WebSocketAudioEncoding.PCM16_8KHZ,
      customParameters: { customer_name: "Ana", task_id: "task-7" },
    });
    ws.sendMediaTo(call);
  });

  ws.addEventListener(WebSocketEvents.MESSAGE, ({ text }) => {
    const message = JSON.parse(text);
    if (message.customEvent === "elevenlabs-decision") {
      decision = message.payload;
      Logger.write(`ElevenLabs decision: ${JSON.stringify(decision)}`);
    }
  });

  ws.addEventListener(WebSocketEvents.CLOSE, (e) => {
    Logger.write(`ElevenLabs socket closed: code=${e.code} reason=${e.reason}`);
    if (decision?.action === "transfer-to-agent") {
      // Route the caller to a human here, for example with VoxEngine.callPSTN().
      call.say("Connecting you to an agent.", { language: VoiceList.Amazon.en_US_Joanna });
      call.addEventListener(CallEvents.PlaybackFinished, () => call.hangup());
      return;
    }
    call.hangup();
  });

  call.addEventListener(CallEvents.Disconnected, () => {
    ws.close();
    VoxEngine.terminate();
  });
});
```

![Voximplant: Editor में scenario](/docs/_fern-files/_img/d2e26165f57cae40fc01e8de28052fef09b2f98bd90c0e1a8779423715f61e2e.webp)

#### कॉल को scenario पर रूट करें

**Routing** खोलें, **Create rule** पर क्लिक करें, इसे नाम दें और `elevenlabs_agent`
scenario असाइन करें। डिफ़ॉल्ट pattern `.*` application की हर कॉल को scenario के ज़रिए भेजता है;
अगर application दूसरी कॉल भी संभालता है, तो इसे किसी फोन नंबर तक सीमित करें। फोन नंबर रूट करने के लिए,
उसे **Numbers** में application से अटैच करें।

![Voximplant: Rule बनाएं](/docs/_fern-files/_img/bc6830b7dcd66dc0b59595456b1197bdcbb9174f15778da7ba9655ba4b93936e.webp)

#### टेस्ट कॉल करें

आप फोन नंबर के बिना browser से application को कॉल कर सकते हैं:

1. **Users** खोलें, **Create user** पर क्लिक करें और पासवर्ड के साथ एक user बनाएं।

   ![Voximplant: नया user](/docs/_fern-files/_img/4754c9234588fd0caa336e1168e207b265557dc4e6a12b1cf8bced1275b8bae6.webp)

2. **Routing** में **Test tools** और फिर **Softphone** पर क्लिक करें। उस user के रूप में sign in करें, microphone access की अनुमति दें, कोई भी destination डालें और कॉल करें। एजेंट अपने पहले संदेश के साथ जवाब देगा।

3. कॉल खत्म होने पर **Call history** खोलें। हर कॉल में कॉल के साथ एक WebSocket leg भी सूचीबद्ध होता है। session देखने के लिए **View log** पर क्लिक करें।

   ![Voximplant: कॉल इतिहास](/docs/_fern-files/_img/4e2416ad3587bb320300173cf679f7c5d7a5e545550b0a647062a79866dac40c.webp)

   Log में ElevenLabs का भेजा हुआ decision, WebSocket close और scenario की अगली कार्रवाई दिखाई देती है।
   इस उदाहरण में कॉलर ने किसी व्यक्ति से बात करने को कहा था, इसलिए decision एजेंट द्वारा दिए कारण के साथ `transfer-to-agent`
   है।

   ![Voximplant: elevenlabs-decision event वाला session log](/docs/_fern-files/_img/f8b4602fa02cfd3c417557377aaa5dd66e2e88a67e7adf4cb037ccae1840f45c.webp)

> **Warning**
>
> `MEDIA_ENDED` पर नहीं, बल्कि `elevenlabs-decision` event पर कार्रवाई करें। ElevenLabs से लगभग एक सेकंड तक ऑडियो न मिलने पर Voximplant `MEDIA_ENDED` trigger करता है, जो बातचीत के बीच में भी हो सकता है।

## Dynamic variables

`customParameters` की हर key उसी नाम की dynamic variable बन जाती है। जो values strings नहीं हैं, उन्हें text में बदला जाता है, उदाहरण के लिए `true` को `"true"` बनाया जाता है। `customParameters` कोई object या JSON-encoded string हो सकता है। `system__` या `integration__` से शुरू होने वाली keys reserved हैं और हटा दी जाती हैं।

## Decision events

बातचीत खत्म होने पर, ElevenLabs अपने `stop` message से पहले ठीक एक decision भेजता है:

```json
{ "customEvent": "elevenlabs-decision", "payload": { "action": "terminate", "reason": "under_18" } }
```

| `action`            | इसे कब भेजा जाता है                                                                                                                                           | `reason`                                                    |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| `transfer-to-agent` | एजेंट ने Voximplant ट्रांसफ़र नियम के साथ **Transfer to number** को कॉल किया।                                                                                 | ट्रांसफ़र के लिए एजेंट द्वारा दिया गया कारण।                |
| `timeout`           | बातचीत चुप्पी के कारण या एजेंट के आखिरी संदेश के बाद timeout हुई, या एजेंट के बोलने का समय छोड़कर, कॉलर की 15 सेकंड की चुप्पी के बाद एजेंट ने कॉल खत्म कर दी। | Timeout संदेश या एजेंट द्वारा दिया गया कारण।                |
| `terminate`         | एजेंट ने **End call** से कॉल खत्म की या बातचीत सामान्य रूप से खत्म हुई।                                                                                       | **End call** के साथ एजेंट द्वारा दिया गया कारण, अगर कोई हो। |
| `unexpected`        | किसी error के कारण बातचीत खत्म हुई।                                                                                                                           | Error का विवरण।                                             |

अगर scenario पहले `stop` भेजता है या WebSocket बंद करता है, उदाहरण के लिए कॉलर के कॉल काटने पर,
ElevenLabs कोई decision नहीं भेजता।

## ऑडियो

Voximplant और ElevenLabs, दोनों दिशाओं में 8 kHz पर 16-bit mono linear PCM एक्सचेंज करते हैं। ElevenLabs
एजेंट के ऑडियो को लगभग real time के हिसाब से भेजता है, इसलिए जब कॉलर एजेंट को बीच में रोकता है, तो बाधित जवाब का अधिकतम लगभग 0.4 सेकंड ही चलता रहता है।

## Authentication errors

जब `Authorization` header मौजूद न हो या गलत format में हो, API key अमान्य हो या कनेक्ट करने वाले IP address से अनुमति न हो, key किसी दूसरे workspace की हो, या key का user authentication enabled एजेंट को access न कर सकता हो, तब ElevenLabs WebSocket को code `1008` और reason `bad auth token` के साथ बंद कर देता है।

## सीमाएं और असमर्थित सुविधाएं

* Client tools और **Play keypad touch tone** system tool समर्थित नहीं हैं। **Transfer to
  number** केवल Voximplant ट्रांसफ़र नियम के ज़रिए काम करता है; कॉलर कहां जाएगा, यह scenario तय करता है।
* अलग first message जैसे configuration overrides scenario से पास नहीं किए जा सकते;
  केवल dynamic variables किए जा सकते हैं।
* Data collection results scenario को नहीं भेजे जाते। इनके लिए
  [post-call webhook](/docs/hi/eleven-agents/workflows/post-call-webhooks) का इस्तेमाल करें।