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

# JavaScript SDK

> **Info**
>
> [ElevenAgents ओवरव्यू](/docs/hi/eleven-agents/overview) भी देखें

## इंस्टॉलेशन

पैकेज मैनेजर के ज़रिए अपने प्रोजेक्ट में पैकेज इंस्टॉल करें।

```shell
npm install @elevenlabs/client
# or
yarn add @elevenlabs/client
# or
pnpm install @elevenlabs/client
```

> **Tip**
>
> क्या आप किसी पुराने वर्ज़न से अपग्रेड कर रहे हैं? अपने AI कोडिंग एजेंट के लिए
> `elevenlabs:sdk-migration` स्किल इंस्टॉल करने के लिए `npx skills add elevenlabs/packages` चलाएं। यह इंपोर्ट बदलावों और API
> अपडेट को ऑटोमेट करता है।

## उपयोग

यह लाइब्रेरी मुख्य रूप से साधारण JavaScript प्रोजेक्ट्स में डेवलपमेंट के लिए है, या खास फ्रेमवर्क के लिए बनी लाइब्रेरीज़ के आधार के रूप में इस्तेमाल की जा सकती है।
देखना बेहतर है कि आपके खास फ्रेमवर्क की अपनी लाइब्रेरी उपलब्ध है या नहीं।
हालांकि, आप इस लाइब्रेरी को किसी भी JavaScript-आधारित प्रोजेक्ट में इस्तेमाल कर सकते हैं।

### बातचीत शुरू करें

सबसे पहले, `Conversation.startSession` का उपयोग करके एक नया बातचीत सेशन बनाएं:

```js
const conversation = await Conversation.startSession(options);
```

इससे कनेक्शन स्थापित होगा और ElevenLabs Agents एजेंट से बात करने के लिए माइक्रोफ़ोन का इस्तेमाल शुरू हो जाएगा। बातचीत शुरू करने से पहले अपने ऐप के UI में माइक्रोफ़ोन ऐक्सेस के बारे में बताएं और उसकी अनुमति लें:

```js
// call after explaining to the user why the microphone access is needed
await navigator.mediaDevices.getUserMedia({ audio: true });
```

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

`startSession` को दिए गए विकल्प तय करते हैं कि सेशन कैसे स्थापित होगा। बातचीत सार्वजनिक या निजी एजेंट के साथ शुरू की जा सकती है।

##### सार्वजनिक एजेंट

जिन एजेंट को किसी ऑथेंटिकेशन की ज़रूरत नहीं होती, उनके साथ एजेंट ID का इस्तेमाल करके बातचीत शुरू की जा सकती है। एजेंट ID [ElevenLabs UI](https://elevenlabs.io/app/conversational-ai) से प्राप्त की जा सकती है।

सार्वजनिक एजेंट के लिए, आप सीधे ID का इस्तेमाल कर सकते हैं:

```js
const conversation = await Conversation.startSession({
  agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
});
```

> **Note**
>
> बातचीत के मोड के आधार पर कनेक्शन टाइप अपने-आप चुना जाता है। वॉइस बातचीत में डिफ़ॉल्ट रूप से WebRTC और सिर्फ़ टेक्स्ट वाली बातचीत में WebSocket इस्तेमाल होता है। ज़रूरत पड़ने पर आप साफ़ तौर पर
> `connectionType: 'webrtc'` या `connectionType: 'websocket'` भी बता सकते हैं।

##### निजी एजेंट

अगर बातचीत के लिए ऑथराइज़ेशन चाहिए, तो आपको अपने सर्वर पर एक अलग एंडपॉइंट जोड़ना होगा। यह [ElevenLabs API](https://elevenlabs.io/docs/overview/intro) का इस्तेमाल करके signed url (WebSockets कनेक्शन टाइप के लिए) या conversation token (WebRTC के लिए) मांगेगा और उसे क्लाइंट को वापस भेजेगा।

यहां WebSocket कनेक्शन का एक उदाहरण है:

```js maxLines=0
// Node.js server

app.get("/signed-url", yourAuthMiddleware, async (req, res) => {
  const response = await fetch(
    `https://api.elevenlabs.io/v1/convai/conversation/get-signed-url?agent_id=${process.env.AGENT_ID}`,
    {
      method: "GET",
      headers: {
        // Requesting a signed url requires your ElevenLabs API key
        // Do NOT expose your API key to the client!
        "xi-api-key": process.env.XI_API_KEY,
      },
    }
  );

  if (!response.ok) {
    return res.status(500).send("Failed to get signed URL");
  }

  const body = await response.json();
  res.send(body.signed_url);
});
```

```js
// Client

const response = await fetch("/signed-url", yourAuthHeaders);
const signedUrl = await response.text();

const conversation = await Conversation.startSession({
  signedUrl,
});
```

यहां WebRTC का एक उदाहरण है:

```js maxLines=0
// Node.js server

app.get("/conversation-token", yourAuthMiddleware, async (req, res) => {
  const response = await fetch(
    `https://api.elevenlabs.io/v1/convai/conversation/token?agent_id=${process.env.AGENT_ID}`,
    {
      headers: {
        // Requesting a conversation token requires your ElevenLabs API key
        // Do NOT expose your API key to the client!
        "xi-api-key": process.env.ELEVENLABS_API_KEY,
      },
    }
  );

  if (!response.ok) {
    return res.status(500).send("Failed to get conversation token");
  }

  const body = await response.json();
  res.send(body.token);
});
```

टोकन मिलने के बाद, उसे `startSession` को देने पर WebRTC का उपयोग करके बातचीत शुरू हो जाएगी।

```js
// Client

const response = await fetch("/conversation-token", yourAuthHeaders);
const conversationToken = await response.text();

const conversation = await Conversation.startSession({
  conversationToken,
});
```

#### वैकल्पिक कॉलबैक

`startSession` को दिए गए विकल्पों से वैकल्पिक कॉलबैक भी रजिस्टर किए जा सकते हैं:

* **onConnect** - बातचीत का websocket कनेक्शन स्थापित होने पर कॉल किया जाने वाला हैंडलर।
* **onDisconnect** - बातचीत का websocket कनेक्शन समाप्त होने पर कॉल किया जाने वाला हैंडलर।
* **onMessage** - नया टेक्स्ट मैसेज मिलने पर कॉल किया जाने वाला हैंडलर। ये यूज़र की आवाज़ के अस्थायी या अंतिम ट्रांसक्रिप्शन, या LLM से बने जवाब हो सकते हैं। इसका उपयोग मुख्य रूप से बातचीत के ट्रांसक्रिप्शन को संभालने के लिए होता है।
* **onError** - कोई त्रुटि आने पर कॉल किया जाने वाला हैंडलर।
* **onStatusChange** - कनेक्शन स्टेटस बदलने पर हर बार कॉल किया जाने वाला हैंडलर। ये `connected`, `connecting` और `disconnected` (शुरुआती) हो सकते हैं।
* **onModeChange** - स्टेटस बदलने पर कॉल किया जाने वाला हैंडलर, जैसे एजेंट `speaking` से `listening` पर जाए या उल्टा।
* **onCanSendFeedbackChange** - फ़ीडबैक भेजना उपलब्ध या अनुपलब्ध होने पर कॉल किया जाने वाला हैंडलर।
* **onAudioAlignment** - ऑडियो अलाइनमेंट डेटा मिलने पर कॉल किया जाने वाला हैंडलर, जो एजेंट के भाषण के लिए कैरेक्टर-लेवल टाइमिंग जानकारी देता है।

> **Warning**
>
> किसी एजेंट के लिए सभी क्लाइंट इवेंट डिफ़ॉल्ट रूप से चालू नहीं होते। अगर आपने कॉलबैक चालू किया है लेकिन
> इवेंट नहीं मिल रहे हैं, तो पक्का करें कि आपके ElevenLabs एजेंट के लिए संबंधित इवेंट
> चालू हो। आप इसे ElevenLabs डैशबोर्ड में एजेंट सेटिंग्स के "Advanced" टैब में कर सकते हैं।

#### रिटर्न वैल्यू

`startSession` एक बातचीत इंस्टेंस लौटाता है (`VoiceConversation` या मोड के अनुसार `TextConversation`), जिसका इस्तेमाल सेशन को नियंत्रित करने के लिए किया जा सकता है। सेशन स्थापित न होने पर यह मेथड त्रुटि देगा। ऐसा तब हो सकता है, जब यूज़र माइक्रोफ़ोन ऐक्सेस न दे या कनेक्शन विफल हो जाए।

**endSession**

बातचीत को मैन्युअल रूप से खत्म करने का एक मेथड। यह मेथड बातचीत खत्म कर देगा और websocket से डिस्कनेक्ट कर देगा।
इसके बाद बातचीत इंस्टेंस इस्तेमाल नहीं किया जा सकेगा और उसे सुरक्षित रूप से हटाया जा सकता है।

```js
await conversation.endSession();
```

**getId**

बातचीत ID लौटाने वाला एक मेथड।

```js
const id = conversation.getId();
```

**setVolume**

बातचीत का आउटपुट वॉल्यूम सेट करने का एक मेथड। यह 0 और 1 के बीच volume फ़ील्ड वाला ऑब्जेक्ट लेता है।

```js
await conversation.setVolume({ volume: 0.5 });
```

**getInputVolume / getOutputVolume**

ऐसे मेथड जो मौजूदा इनपुट/आउटपुट वॉल्यूम को `0` से `1` के स्केल पर लौटाते हैं, जहां `0` -100 dB और `1` -30 dB है।

```js
const inputVolume = await conversation.getInputVolume();
const outputVolume = await conversation.getOutputVolume();
```

**sendFeedback**

एजेंट को बाइनरी फ़ीडबैक भेजने का एक मेथड। यह मेथड boolean वैल्यू लेता है, जिसमें `true` सकारात्मक और `false` नकारात्मक फ़ीडबैक दर्शाता है।

फ़ीडबैक हमेशा एजेंट के सबसे हाल के जवाब से जुड़ा होता है और हर जवाब के लिए सिर्फ़ एक बार भेजा जा सकता है।

दिए गए समय पर फ़ीडबैक भेजा जा सकता है या नहीं, यह जानने के लिए आप `onCanSendFeedbackChange` सुन सकते हैं।

```js
conversation.sendFeedback(true); // positive feedback
conversation.sendFeedback(false); // negative feedback
```

**sendContextualUpdate**

एजेंट को संदर्भ से जुड़े अपडेट भेजने का एक मेथड। इसका इस्तेमाल एजेंट को यूज़र की उन कार्रवाइयों के बारे में बताने के लिए किया जा सकता है जो बातचीत से सीधे जुड़ी नहीं हैं, लेकिन एजेंट के जवाबों को प्रभावित कर सकती हैं।

```js
conversation.sendContextualUpdate(
  "User navigated to another page. Consider it for next response, but don't react to this contextual update."
);
```

**sendUserMessage**

एजेंट को टेक्स्ट मैसेज भेजता है।

इसका इस्तेमाल यूज़र को माइक्रोफ़ोन के बजाय मैसेज टाइप करने देने के लिए किया जा सकता है। `sendContextualUpdate` के उलट, इसे यूज़र मैसेज माना जाएगा और एजेंट को बातचीत में अपनी बारी लेने के लिए प्रेरित करेगा।

```js
sendButton.addEventListener("click", (e) => {
  conversation.sendUserMessage(textInput.value);
  textInput.value = "";
});
```

**sendUserActivity**

एजेंट को यूज़र की गतिविधि के बारे में सूचित करता है।

यूज़र की गतिविधि का पता चलने के बाद एजेंट कम से कम 2 सेकंड तक बोलने की कोशिश नहीं करेगा।

इसका इस्तेमाल यूज़र के टाइप करते समय एजेंट को बीच में बोलने से रोकने के लिए किया जा सकता है।

```js
textInput.addEventListener("input", () => {
  conversation.sendUserActivity();
});
```

**setMicMuted**

माइक्रोफ़ोन को म्यूट/अनम्यूट करने का एक मेथड।

```js
// Mute the microphone
conversation.setMicMuted(true);

// Unmute the microphone
conversation.setMicMuted(false);
```

**changeInputDevice**

चालू वॉइस बातचीत के दौरान ऑडियो इनपुट डिवाइस बदलने देता है। यह मेथड सिर्फ़ वॉइस बातचीत के लिए उपलब्ध है।

> **Note**
>
> WebRTC मोड में इनपुट फ़ॉर्मैट और सैंपल रेट क्रमशः `pcm` और `48000` पर हार्डकोड होते हैं।
> इनपुट डिवाइस बदलते समय इन वैल्यू को बदलने का कोई असर नहीं होता।

```js
const conversation = await Conversation.startSession({
  agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
  // Alternatively you can provide a device ID when starting the session
  // Useful if you want to start the conversation with a non-default device
  inputDeviceId: "a1b2c3d4e5f6",
});

// Change to a specific input device
await conversation.changeInputDevice({
  sampleRate: 16000,
  format: "pcm",
  preferHeadphonesForIosDevices: true,
  inputDeviceId: "a1b2c3d4e5f6",
});
```

डिवाइस ID अमान्य होने पर, उसकी जगह डिफ़ॉल्ट डिवाइस का इस्तेमाल होगा।

**changeOutputDevice**

चालू वॉइस बातचीत के दौरान ऑडियो आउटपुट डिवाइस बदलने देता है। यह मेथड सिर्फ़ वॉइस बातचीत के लिए उपलब्ध है।

> **Note**
>
> WebRTC मोड में आउटपुट फ़ॉर्मैट और सैंपल रेट क्रमशः `pcm` और `48000` पर हार्डकोड होते हैं।
> आउटपुट डिवाइस बदलते समय इन वैल्यू को बदलने का कोई असर नहीं होता।

```js
const conversation = await Conversation.startSession({
  agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
  // Alternatively you can provide a device ID when starting the session
  // Useful if you want to start the conversation with a non-default device
  outputDeviceId: "a1b2c3d4e5f6",
});

// Change to a specific output device
await conversation.changeOutputDevice({
  sampleRate: 16000,
  format: "pcm",
  outputDeviceId: "a1b2c3d4e5f6",
});
```

> **Note**
>
> डिवाइस स्विचिंग सिर्फ़ वॉइस बातचीत के लिए काम करती है। अगर कोई खास `deviceId` नहीं दिया गया है, तो
> ब्राउज़र अपने डिफ़ॉल्ट डिवाइस चयन का उपयोग करेगा। आप उपलब्ध डिवाइस को
> [MediaDevices.enumerateDevices()](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices)
> API से सूचीबद्ध कर सकते हैं।

**getInputByteFrequencyData / getOutputByteFrequencyData**

ऐसे मेथड जो मौजूदा इनपुट/आउटपुट फ़्रीक्वेंसी डेटा वाले `Uint8Array` लौटाते हैं। अधिक जानकारी के लिए [AnalyserNode.getByteFrequencyData](https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getByteFrequencyData) देखें।

> **Note**
>
> ये मेथड सिर्फ़ वॉइस बातचीत के लिए उपलब्ध हैं। WebRTC मोड में ऑडियो को `pcm_48000` इस्तेमाल करने के लिए हार्डकोड किया गया है,
> यानी लौटाए गए डेटा का उपयोग करने वाला कोई भी विज़ुअलाइज़ेशन WebSocket कनेक्शन की तुलना में अलग पैटर्न दिखा सकता है।