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

# डायनामिक वेरिएबल्स

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

## परिचय

डायनामिक वेरिएबल्स को आपके एजेंट के कई पहलुओं में जोड़ा जा सकता है:

* व्यवहार और संदर्भ को कस्टमाइज़ करने के लिए **सिस्टम प्रॉम्प्ट**
* अभिवादन को व्यक्तिगत बनाने के लिए **पहले मैसेज**
* यूज़र-विशिष्ट डेटा पास करने के लिए **टूल पैरामीटर और हेडर**

यहां कुछ उदाहरण हैं, जहां डायनामिक वेरिएबल्स उपयोगी होते हैं:

* यूज़र के नाम से **अभिवादन को व्यक्तिगत बनाना**
* जवाबों में **अकाउंट की जानकारी शामिल करना**
* टूल कॉल को **डेटा पास करना**
* सब्सक्रिप्शन टियर के आधार पर **व्यवहार को कस्टमाइज़ करना**
* बातचीत ID या कॉल अवधि जैसी **सिस्टम जानकारी एक्सेस करना**

> **Info**
>
> डायनामिक वेरिएबल्स यूज़र-विशिष्ट डेटा डालने के लिए आदर्श हैं, जिसे आपके एजेंट के
> कॉन्फ़िगरेशन में हार्डकोड नहीं किया जाना चाहिए।

## सिस्टम डायनामिक वेरिएबल्स

आपके एजेंट के पास ये सिस्टम वेरिएबल्स अपने-आप उपलब्ध होते हैं:

* `system__agent_id` - बातचीत शुरू करने वाले एजेंट का यूनिक आइडेंटिफ़ायर (पूरी बातचीत के दौरान स्थिर रहता है)
* `system__current_agent_id` - मौजूदा सक्रिय एजेंट का यूनिक आइडेंटिफ़ायर (एजेंट ट्रांसफर के बाद बदलता है)
* `system__caller_id` - कॉलर का फ़ोन नंबर (सिर्फ़ वॉइस कॉल के लिए)
* `system__called_number` - गंतव्य फ़ोन नंबर (सिर्फ़ वॉइस कॉल के लिए)
* `system__call_duration_secs` - कॉल की अवधि, सेकंड में
* `system__time_utc` - मौजूदा UTC समय (ISO फ़ॉर्मैट)
* `system__time` - तय टाइमज़ोन में मौजूदा समय (मानव-पठनीय फ़ॉर्मैट, जैसे, "Friday, 12:33 12 December 2025")
* `system__timezone` - यूज़र द्वारा दिया गया टाइमज़ोन (tzinfo के लिए मान्य होना चाहिए)
* `system__conversation_id` - ElevenLabs का यूनिक बातचीत आइडेंटिफ़ायर
* `system__call_sid` - कॉल SID (सिर्फ़ twilio कॉल के लिए)
* `system__call_id` - SIP ट्रंक कॉल का यूनिक आइडेंटिफ़ायर (सिर्फ़ SIP ट्रंक कॉल के लिए)
* `system__agent_turns` - इस बातचीत में एजेंट द्वारा लिए गए बातचीत टर्न की कुल संख्या।
* `system__current_agent_turns` - मौजूदा एजेंट द्वारा लिए गए बातचीत टर्न की संख्या। बातचीत किसी दूसरे एजेंट को ट्रांसफर होने पर यह रीसेट हो जाती है।
* `system__current_subagent_turns` - मौजूदा सबएजेंट द्वारा लिए गए बातचीत टर्न की संख्या। वर्कफ़्लो के किसी दूसरे नोड पर जाने पर यह रीसेट हो जाती है।
* `system__is_text_only` - अगर बातचीत सिर्फ़ टेक्स्ट मोड में चल रही है, तो true; अन्यथा false।
* `system__conversation_history` - मौजूदा बातचीत इतिहास का JSON-सीरियलाइज़्ड रूप। इसका आकलन केवल रेफ़रेंस किए जाने के समय होता है। नीचे [फ़ॉर्मैट विवरण](#conversation-history-format) देखें।

सिस्टम वेरिएबल्स:

* रनटाइम कॉन्फ़िगरेशन के बिना उपलब्ध होते हैं
* इनके आगे `system__` लगा होता है (आरक्षित प्रीफ़िक्स)
* बातचीत के दौरान अपने-आप अपडेट होते हैं

> **Warning**
>
> कस्टम डायनामिक वेरिएबल्स में आरक्षित `system__` प्रीफ़िक्स का इस्तेमाल नहीं किया जा सकता।

### बातचीत इतिहास का फ़ॉर्मैट

`system__conversation_history` वेरिएबल में निम्न संरचना वाला JSON ऑब्जेक्ट होता है:

```json
{
  "x-elevenlabs-history": true,
  "entries": [
    { "role": "user", "message": "Hello" },
    { "role": "agent", "message": "Hi, how can I help?" },
    {
      "role": "agent",
      "tool_requests": [{ "tool_name": "lookup_order", "params_as_json": { "order_id": "123" } }]
    },
    {
      "role": "tool",
      "tool_results": [{ "tool_name": "lookup_order", "result_value": "{\"status\": \"shipped\"}" }]
    }
  ]
}
```

हर एंट्री में एक `role` (`"user"`, `"agent"`, या `"tool"`) और इनमें से एक शामिल होता है:

* `message` — टर्न का टेक्स्ट कॉन्टेंट
* `tool_requests` — एजेंट द्वारा किए गए टूल कॉल का एक ऐरे, जिसमें हल किए गए पैरामीटर वैल्यू होते हैं
* `tool_results` — टूल रिस्पॉन्स का एक ऐरे

अगर किसी टूल रिज़ल्ट या पैरामीटर में नेस्टेड बातचीत इतिहास है, तो असीमित रिकर्सिव विस्तार से बचने के लिए उसे प्लेसहोल्डर से रिडैक्ट कर दिया जाता है (जैसे, `[conversation_history (5 turns)]`)।

यह वेरिएबल टूल्स (जैसे वेबहुक, कस्टम LLM) को बातचीत का संदर्भ पास करने या हैंडऑफ़ के दौरान सब-एजेंट प्रॉम्प्ट में बातचीत इतिहास शामिल करने के लिए उपयोगी है।

## सीक्रेट डायनामिक वेरिएबल्स

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

हम इन्हें ऐसे ऑथ टोकन या प्राइवेट ID के लिए इस्तेमाल करने की सलाह देते हैं जिन्हें LLM को नहीं भेजा जाना चाहिए। सीक्रेट डायनामिक वेरिएबल बनाने के लिए, बस डायनामिक वेरिएबल के आगे `secret__` लगाएं।

> **Warning**
>
> सीक्रेट वैल्यू `<REDACTED>` के रूप में रिडैक्ट करके लौटाई जाती हैं, जिसमें पोस्ट-कॉल वेबहुक और
> conversations API भी शामिल हैं। जिन वैल्यू को आपको बातचीत के बाद वापस पढ़ना हो, उनके लिए `secret__`
> प्रीफ़िक्स का इस्तेमाल न करें। उन्हें सामान्य डायनामिक वेरिएबल्स के रूप में पास करें, या कोई गैर-संवेदनशील आइडेंटिफ़ायर पास करें और
> संवेदनशील वैल्यू को अपने सिस्टम पर देखें।

## टूल्स से डायनामिक वेरिएबल्स अपडेट करना

अगर [टूल कॉल](https://elevenlabs.io/docs/eleven-agents/customization/tools) वैध JSON ऑब्जेक्ट लौटाते हैं, तो वे डायनामिक वेरिएबल्स बना या अपडेट कर सकते हैं। क्या एक्सट्रैक्ट करना है, यह तय करने के लिए डॉट नोटेशन से ऑब्जेक्ट पाथ सेट करें। अगर फ़ील्ड या पाथ मौजूद नहीं है, तो कुछ भी अपडेट नहीं होता।

रिस्पॉन्स ऑब्जेक्ट और डॉट नोटेशन का उदाहरण:

* स्टेटस इस पाथ से मेल खाता है: `response.status`
* users ऐरे में पहले यूज़र का ईमेल इस पाथ से मेल खाता है: `response.users.0.email`

**`JSON`**

```JSON title="JSON"
{
  "response": {
    "status": 200,
    "message": "Successfully found 5 users",
    "users": [
      "user_1": {
        "user_name": "test_user_1",
        "email": "test_user_1@email.com"
      }
    ]
  }
}
```

डायनामिक वेरिएबल को पहले यूज़र के ईमेल से अपडेट करने के लिए, असाइनमेंट इस तरह सेट करें।

![क्वेरी पैरामीटर](/docs/_fern-img/95ff0cae8613eafa8bc4312e7cafa39ac0eab34d2fd2b21f0894a30775366110.webp)

असाइनमेंट हर वेबहुक टूल का एक फ़ील्ड हैं, जिसका दस्तावेज़ [यहां](/docs/hi/eleven-agents/api-reference/tools/create#response.body.tool_config.SystemToolConfig.assignments) दिया गया है।

## गाइड

### आवश्यक शर्तें

* एक [ElevenLabs अकाउंट](https://elevenlabs.io)
* कॉन्फ़िगर किया हुआ ElevenLabs कन्वर्सेशनल एजेंट ([यहां बनाएं](/docs/hi/eleven-agents/quickstart))

#### प्रॉम्प्ट में डायनामिक वेरिएबल्स तय करें

अपने इन हिस्सों में डबल कर्ली ब्रेसेस `{{variable_name}}` का इस्तेमाल करके वेरिएबल जोड़ें:

* सिस्टम प्रॉम्प्ट
* पहले मैसेज
* टूल पैरामीटर

![मैसेज में डायनामिक वेरिएबल्स](/docs/_fern-img/84a9870018a436215fe8d6563a47f42b1b45e005c56dffff3b37dbfe8a25adf3.webp)

![मैसेज में डायनामिक वेरिएबल्स](/docs/_fern-img/052ab733ff3ecb2512218c70d82a4337764577b0082cdc4b2fb4415d273d2cbe.webp)

#### टूल्स में डायनामिक वेरिएबल्स तय करें

आप टूल कॉन्फ़िगरेशन में भी डायनामिक वेरिएबल्स तय कर सकते हैं।
नया डायनामिक वेरिएबल बनाने के लिए, वैल्यू टाइप को Dynamic variable पर सेट करें और `+` बटन पर क्लिक करें।

![प्लेसहोल्डर सेट करना](/docs/_fern-img/7da35479f409f1505dc528e78d782d74e226fa51b2a5d3b6ede3929359be8ddd.webp)

![प्लेसहोल्डर सेट करना](/docs/_fern-img/21856929c95fe77b274dc1a849668c144554719cd468a225d110295ae94c7713.webp)

#### प्लेसहोल्डर सेट करें

रनटाइम पर वेरिएबल्स पास किए बिना टेस्टिंग के लिए डिफ़ॉल्ट वैल्यू कॉन्फ़िगर करें।

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

एजेंट के डैशबोर्ड में हर डायनामिक वेरिएबल के लिए डिफ़ॉल्ट वैल्यू सेट करें।

![प्लेसहोल्डर सेट करना](/docs/_fern-img/dbea803919e315240202a3cb355ef7f62f25a5182d9aa99d0916177349c70ae4.webp)

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

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

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

#### \`agent_configs/\<agent-name>.json\` एडिट करें

`conversation_config.agent.dynamic_variables.dynamic_variable_placeholders` सेट करें। हर की वेरिएबल का नाम है; वैल्यू टेस्टिंग के दौरान इस्तेमाल होने वाला प्लेसहोल्डर है:

```json
{
  "conversation_config": {
    "agent": {
      "dynamic_variables": {
        "dynamic_variable_placeholders": {
          "user_name": "Angelo",
          "account_type": "premium"
        }
      }
    }
  }
}
```

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

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

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

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "agent": {
            "dynamic_variables": {
                "dynamic_variable_placeholders": {
                    "user_name": "Angelo",
                    "account_type": "premium",
                }
            }
        },
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    agent: {
      dynamicVariables: {
        dynamicVariablePlaceholders: {
          user_name: "Angelo",
          account_type: "premium",
        },
      },
    },
  },
});
```

#### रनटाइम पर वेरिएबल्स पास करें

बातचीत शुरू करते समय, अपने कोड में डायनामिक वेरिएबल्स दें:

> **Tip**
>
> पक्का करें कि आपके पास नवीनतम [SDK](/docs/hi/eleven-agents/libraries/python) इंस्टॉल हो।

**`Python`**

```python title="Python" focus={10-23} maxLines=25
import os
import signal
from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import Conversation, ConversationInitiationData
from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface

agent_id = os.getenv("AGENT_ID")
api_key = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(api_key=api_key)

dynamic_vars = {
    "user_name": "Angelo",
}

config = ConversationInitiationData(
    dynamic_variables=dynamic_vars
)

conversation = Conversation(
    elevenlabs,
    agent_id,
    config=config,
    # Assume auth is required when API_KEY is set.
    requires_auth=bool(api_key),
    # Use the default audio interface.
    audio_interface=DefaultAudioInterface(),
    # Simple callbacks that print the conversation to the console.
    callback_agent_response=lambda response: print(f"Agent: {response}"),
    callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
    callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
    # Uncomment the below if you want to see latency measurements.
    # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
)

conversation.start_session()

signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())
```

**`JavaScript`**

```javascript title="JavaScript" focus={7-20} maxLines=25
import { Conversation } from '@elevenlabs/client';

class VoiceAgent {
  ...

  async startConversation() {
    try {
        // Request microphone access
        await navigator.mediaDevices.getUserMedia({ audio: true });

        this.conversation = await Conversation.startSession({
            agentId: 'agent_id_goes_here', // Replace with your actual agent ID

            dynamicVariables: {
                user_name: 'Angelo'
            },

            ... add some callbacks here
        });
    } catch (error) {
        console.error('Failed to start conversation:', error);
        alert('Failed to start conversation. Please ensure microphone access is granted.');
    }
  }
}
```

**`Swift`**

```swift title="Swift"
let dynamicVars: [String: DynamicVariableValue] = [
  "customer_name": .string("John Doe"),
  "account_balance": .number(5000.50),
  "user_id": .int(12345),
  "is_premium": .boolean(true)
]

// Create session config with dynamic variables
let config = SessionConfig(
    agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
    dynamicVariables: dynamicVars
)

// Start the conversation
let conversation = try await Conversation.startSession(
    config: config
)
```

**`विजेट`**

```html title="विजेट"
<elevenlabs-convai
  agent-id="agent_7101k5zvyjhmfg983brhmhkd98n6"
  dynamic-variables='{"user_name": "John", "account_type": "premium"}'
></elevenlabs-convai>
```

## पब्लिक Talk-to पेज इंटीग्रेशन

पब्लिक Talk-to पेज URL पैरामीटर के जरिए डायनामिक वेरिएबल्स को सपोर्ट करता है, जिससे एजेंट लिंक शेयर करते समय आप बातचीत को व्यक्तिगत बना सकते हैं। यह वेबसाइट, ईमेल या मार्केटिंग कैंपेन में व्यक्तिगत एजेंट एम्बेड करने के लिए खास तौर पर उपयोगी है।

### URL पैरामीटर के तरीके

पब्लिक Talk-to पेज पर डायनामिक वेरिएबल्स पास करने के दो तरीके हैं:

#### तरीका 1: Base64-एन्कोडेड JSON

`vars` पैरामीटर का इस्तेमाल करके वेरिएबल्स को base64-एन्कोडेड JSON ऑब्जेक्ट के रूप में पास करें:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9
```

`vars` पैरामीटर में base64-एन्कोडेड JSON होता है:

```json
{ "user_name": "John", "account_type": "premium" }
```

#### तरीका 2: अलग-अलग क्वेरी पैरामीटर

`var_` प्रीफ़िक्स वाले क्वेरी पैरामीटर का इस्तेमाल करके वेरिएबल्स पास करें:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&var_user_name=John&var_account_type=premium
```

### पैरामीटर प्राथमिकता

जब दोनों तरीकों का एक साथ इस्तेमाल किया जाता है, तो टकराव से बचने के लिए अलग-अलग `var_` पैरामीटर base64-एन्कोडेड वेरिएबल्स पर प्राथमिकता लेते हैं:

```
https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKYW5lIn0=&var_user_name=John
```

इस उदाहरण में, `user_name` "Jane" (base64-एन्कोडेड `vars` से) के बजाय "John" (`var_user_name` से) होगा।

### इम्प्लीमेंटेशन उदाहरण

#### JavaScript URL जनरेशन

```javascript
// Method 1: Base64-encoded JSON
function generateTalkToURL(agentId, variables) {
  const baseURL = 'https://elevenlabs.io/app/talk-to';
  const encodedVars = btoa(JSON.stringify(variables));
  return `${baseURL}?agent_id=${agentId}&vars=${encodedVars}`;
}

// Method 2: Individual parameters
function generateTalkToURLWithParams(agentId, variables) {
  const baseURL = 'https://elevenlabs.io/app/talk-to';
  const params = new URLSearchParams({ agent_id: agentId });

  Object.entries(variables).forEach(([key, value]) => {
    params.append(`var_${key}`, encodeURIComponent(value));
  });

  return `${baseURL}?${params.toString()}`;
}

// Usage
const variables = {
  user_name: "John Doe",
  account_type: "premium",
  session_id: "sess_123"
};

const urlMethod1 = generateTalkToURL("agent_7101k5zvyjhmfg983brhmhkd98n6", variables);
const urlMethod2 = generateTalkToURLWithParams("agent_7101k5zvyjhmfg983brhmhkd98n6", variables);
```

#### Python URL जनरेशन

```python
import base64
import json
from urllib.parse import urlencode, quote

def generate_talk_to_url(agent_id, variables):
    """Generate URL with base64-encoded variables"""
    base_url = "https://elevenlabs.io/app/talk-to"
    encoded_vars = base64.b64encode(json.dumps(variables).encode()).decode()
    return f"{base_url}?agent_id={agent_id}&vars={encoded_vars}"

def generate_talk_to_url_with_params(agent_id, variables):
    """Generate URL with individual var_ parameters"""
    base_url = "https://elevenlabs.io/app/talk-to"
    params = {"agent_id": agent_id}

    for key, value in variables.items():
        params[f"var_{key}"] = value

    return f"{base_url}?{urlencode(params)}"

# Usage
variables = {
    "user_name": "John Doe",
    "account_type": "premium",
    "session_id": "sess_123"
}

url_method1 = generate_talk_to_url("agent_7101k5zvyjhmfg983brhmhkd98n6", variables)
url_method2 = generate_talk_to_url_with_params("agent_7101k5zvyjhmfg983brhmhkd98n6", variables)
```

#### मैन्युअल URL निर्माण

```
# Base64-encoded method
1. Create JSON: {"user_name": "John", "account_type": "premium"}
2. Encode to base64: eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9
3. Add to URL: https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&vars=eyJ1c2VyX25hbWUiOiJKb2huIiwiYWNjb3VudF90eXBlIjoicHJlbWl1bSJ9

# Individual parameters method
1. Add each variable with var_ prefix
2. URL encode values if needed
3. Final URL: https://elevenlabs.io/app/talk-to?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&var_user_name=John&var_account_type=premium
```

## समर्थित टाइप

डायनामिक वेरिएबल्स इन वैल्यू टाइप को सपोर्ट करते हैं:

#### स्ट्रिंग

टेक्स्ट वैल्यू

#### नंबर

संख्यात्मक वैल्यू

#### बूलियन

True/false वैल्यू

## समस्या निवारण

#### वेरिएबल्स बदल नहीं रहे हैं

जांचें कि:

* वेरिएबल के नाम बिल्कुल मेल खाते हों (केस-सेंसिटिव)
* वेरिएबल्स में डबल कर्ली ब्रेसेस हों: `{{ variable_name }}`
* वेरिएबल्स आपके dynamic_variables ऑब्जेक्ट में शामिल हों

#### टाइप एरर

पक्का करें कि:

* वेरिएबल वैल्यू अपेक्षित टाइप से मेल खाती हों
* वैल्यू सिर्फ़ स्ट्रिंग, नंबर या बूलियन हों