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

# एनवायरनमेंट वेरिएबल

एनवायरनमेंट वेरिएबल से आप टूल URL, सीक्रेट, हेडर और ऑथ कनेक्शन के लिए हर एनवायरनमेंट की वैल्यू तय कर सकते हैं। एक ही एजेंट और टूल कॉन्फ़िगरेशन आपके सभी एनवायरनमेंट में काम करता है — URL, API key और ऑथेंटिकेशन बातचीत के समय बताए गए एनवायरनमेंट के आधार पर डाइनैमिक रूप से रिज़ॉल्व होते हैं।

## परिचय

एनवायरनमेंट वेरिएबल के बिना, किसी एजेंट को कई एनवायरनमेंट (development, staging, production) में डिप्लॉय करने के लिए हर एनवायरनमेंट हेतु एजेंट और टूल डुप्लिकेट करने पड़ते हैं, फिर उनके कॉन्फ़िगरेशन को मैन्युअली सिंक में रखना पड़ता है। इससे ये समस्याएं होती हैं:

* एनवायरनमेंट के बीच **कॉन्फ़िगरेशन में अंतर**
* डुप्लिकेट एजेंट ID में **बंटे हुए एनालिटिक्स**
* staging से production में जाने पर **प्रमोशन की मुश्किलें**

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

![एनवायरनमेंट वेरिएबल का परिचय](/docs/_fern-img/75bbfad6349ff43d078f62e75f7d3549858897158e55ada3dcdbf261a963b055.webp)

## मुख्य अवधारणाएं

### एनवायरनमेंट वेरिएबल

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

| प्रकार         | विवरण                                                                  | इस्तेमाल का उदाहरण                            |
| -------------- | ---------------------------------------------------------------------- | --------------------------------------------- |
| **स्ट्रिंग**   | साधारण टेक्स्ट वैल्यू, जो हर एनवायरनमेंट में अलग होती हैं              | बेस URL, होस्टनेम, कॉन्फ़िगरेशन वैल्यू        |
| **सीक्रेट**    | वर्कस्पेस सीक्रेट के रेफ़रेंस, हर एनवायरनमेंट के लिए रिज़ॉल्व होते हैं | API key, bearer token, वेबहुक साइनिंग सीक्रेट |
| **ऑथ कनेक्शन** | ऑथ कनेक्शन के रेफ़रेंस, हर एनवायरनमेंट के लिए रिज़ॉल्व होते हैं        | OAuth2 क्रेडेंशियल, JWT कॉन्फ़िगरेशन          |

हर एनवायरनमेंट वेरिएबल में डिफ़ॉल्ट `production` एनवायरनमेंट के लिए वैल्यू होना ज़रूरी है। अतिरिक्त एनवायरनमेंट (जैसे, `staging`, `development`) वैकल्पिक हैं।

### टेम्पलेट सिंटैक्स

URL फ़ील्ड में एनवायरनमेंट वेरिएबल को `{{system__env_<label>}}` सिंटैक्स से रेफ़र करें:

```
https://{{system__env_api_host}}.example.com/v1/text-to-speech
```

`api_host` एनवायरनमेंट वेरिएबल की वैल्यू `api` (production) और `staging.api` (staging) होने पर, यह ऐसे रिज़ॉल्व होता है:

* `production` में: `https://api.example.com/v1/text-to-speech`
* `staging` में: `https://staging.api.example.com/v1/text-to-speech`

यह सिंटैक्स [डायनामिक वेरिएबल](/docs/hi/eleven-agents/customization/personalization/dynamic-variables) के अनुरूप है और वेबहुक टूल तथा MCP सर्वर कनेक्शन के URL फ़ील्ड में काम करता है।

> **Note**
>
> एनवायरनमेंट वेरिएबल **प्री-कॉल वेबहुक** URL और हेडर (Conversation Initiation Client Data Webhook) में भी समर्थित हैं, और
> **Developers > Webhooks** में कॉन्फ़िगर किए गए **पोस्ट-कॉल वेबहुक** URL में भी। टेम्पलेट बातचीत के एनवायरनमेंट का इस्तेमाल करके रिज़ॉल्व होते हैं, इसलिए
> एक ही वेबहुक कॉन्फ़िगरेशन हर एनवायरनमेंट में अलग एंडपॉइंट को टारगेट कर सकता है। प्री-कॉल वेबहुक के लिए,
> एनवायरनमेंट को फ़ोन नंबर पर पहले से सेट किया जा सकता है या आपके वेबहुक
> जवाब में डाइनैमिक रूप से लौटाया जा सकता है (नीचे [Telephony](#telephony-twilio-and-sip-trunk) देखें)।

> **Note**
>
> URL को किसी भी एनवायरनमेंट वेरिएबल रेफ़रेंस से पहले `https://` से शुरू होना चाहिए। उदाहरण के लिए, `https://   {{ system__env_api_host }}.example.com/v1/data` मान्य है, लेकिन `{{ system__env_api_host }}/v1/data`
> मान्य नहीं है। वैलिडेशन और सुरक्षा के लिए यह ज़रूरी है — एनवायरनमेंट वेरिएबल वैल्यू प्रोटोकॉल को नियंत्रित नहीं कर सकतीं।

### रिज़ॉल्यूशन और फ़ॉलबैक

जब कोई बातचीत किसी खास एनवायरनमेंट में चलती है, तो सिस्टम एनवायरनमेंट वेरिएबल को इस तरह रिज़ॉल्व करता है:

1. मांगे गए एनवायरनमेंट (जैसे, `staging`) की वैल्यू खोजें
2. उस एनवायरनमेंट के लिए कोई वैल्यू न होने पर, **`production` वैल्यू पर फ़ॉलबैक करें**
3. वेरिएबल रिज़ॉल्व न होने पर, टूल कॉल कॉन्फ़िगरेशन एरर के साथ विफल होती है

इस फ़ॉलबैक व्यवहार का मतलब है कि आपको सिर्फ़ उन एनवायरनमेंट के लिए वैल्यू तय करनी है जो production से अलग हैं।

## एनवायरनमेंट वेरिएबल बनाना

> **Note**
>
> एनवायरनमेंट वेरिएबल को अभी ElevenLabs CLI से मैनेज नहीं किया जा सकता — डैशबोर्ड या SDK का इस्तेमाल करें।

#### डैशबोर्ड से बनाएं

ElevenLabs डैशबोर्ड में **Developers > Environment Variables** पर जाएं।

#### एनवायरनमेंट बनाएं

अपने डिप्लॉयमेंट चरणों से मेल खाने वाले एनवायरनमेंट तय करें (जैसे, `eu`, `india`, `staging`)। `production` एनवायरनमेंट डिफ़ॉल्ट रूप से हमेशा उपलब्ध होता है।

#### वेरिएबल बनाएं

**Add variable** पर क्लिक करें और वेरिएबल का टाइप चुनें:

* **String**: लेबल डालें और हर एनवायरनमेंट के लिए वैल्यू सेट करें
* **Secret**: हर एनवायरनमेंट के लिए मौजूदा वर्कस्पेस सीक्रेट चुनें
* **Auth connection**: हर एनवायरनमेंट के लिए मौजूदा ऑथ कनेक्शन चुनें

![वेरिएबल बनाएं](/docs/_fern-img/8ab18d57956167aaa152e10b4d2890b208c8ba826ef0cbbf9082c8e1602f5246.webp)

#### API से बनाएं

#### String

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.environment_variables.create(
    label="api_host",
    type="string",
    values={
        "production": "api",
        "staging": "staging.api",
        "development": "dev.api",
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.environmentVariables.create({
  label: "api_host",
  type: "string",
  values: {
    production: "api",
    staging: "staging.api",
    development: "dev.api",
  },
});
```

#### Secret

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.environment_variables.create(
    label="my_api_key",
    type="secret",
    values={
        "production": {"secret_id": "your-production-secret-id"},
        "staging": {"secret_id": "your-staging-secret-id"},
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.environmentVariables.create({
  label: "my_api_key",
  type: "secret",
  values: {
    production: { secretId: "your-production-secret-id" },
    staging: { secretId: "your-staging-secret-id" },
  },
});
```

#### ऑथ कनेक्शन

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.environment_variables.create(
    label="my_oauth_connection",
    type="auth_connection",
    values={
        "production": {"auth_connection_id": "your-production-auth-connection-id"},
        "staging": {"auth_connection_id": "your-staging-auth-connection-id"},
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.environmentVariables.create({
  label: "my_oauth_connection",
  type: "auth_connection",
  values: {
    production: { authConnectionId: "your-production-auth-connection-id" },
    staging: { authConnectionId: "your-staging-auth-connection-id" },
  },
});
```

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

### वेबहुक टूल URL में

हर एनवायरनमेंट के लिए बेस URL रिज़ॉल्व करने हेतु [वेबहुक टूल](/docs/hi/eleven-agents/customization/tools/webhook-tools) के URL फ़ील्ड में टेम्पलेट सिंटैक्स इस्तेमाल करें।

![टूल URL में एनवायरनमेंट वेरिएबल](/docs/_fern-img/8a9d4a7fbd589565c57f52aa82200c28fe7fcfcc80ff9a3ec41a99ca315a9f50.webp)

उदाहरण के लिए, इस तरह कॉन्फ़िगर किया गया टूल URL:

```
https://{{system__env_api_host}}.example.com/v1/weather?lat={latitude}&lon={longitude}
```

प्रोडक्शन में `https://api.example.com/v1/weather?lat=40.7&lon=-74.0` और स्टेजिंग में `https://staging.api.example.com/v1/weather?lat=40.7&lon=-74.0` पर रिज़ॉल्व होता है।

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

```
https://{{system__env_api_host}}.example.com/{{system__env_api_version}}/weather
```

#### API उदाहरण

**`Python`**

```python title="Python"

from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="your-api-key")

agent = client.conversational_ai.agents.create(
    conversation_config={
        "agent": {
            "first_message": "Hello! How can I help?",
            "prompt": {"prompt": "You are a helpful assistant."},
        },
        "tools": [
            {
                "type": "webhook",
                "name": "get_data",
                "description": "Fetches data from the API",
                "api_schema": {
                    "url": "https://{{system__env_api_host}}.example.com/v1/data",
                    "method": "GET",
                },
            }
        ],
    },
)
```

**`JavaScript`**

```javascript title="JavaScript"
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({ apiKey: "your-api-key" });

const agent = await client.conversationalAi.agents.create({
  conversationConfig: {
    agent: {
      firstMessage: "Hello! How can I help?",
      prompt: { prompt: "You are a helpful assistant." },
    },
    tools: [
      {
        type: "webhook",
        name: "get_data",
        description: "Fetches data from the API",
        apiSchema: {
          url: "https://{{system__env_api_host}}.example.com/v1/data",
          method: "GET",
        },
      },
    ],
  },
});
```

### वेबहुक टूल हेडर में

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

#### API उदाहरण

`request_headers` फ़ील्ड में एनवायरनमेंट वेरिएबल रेफ़रेंस पास करें:

```json
{
  "api_schema": {
    "url": "https://{{system__env_api_host}}.example.com/v1/data",
    "method": "GET",
    "request_headers": {
      "X-Api-Key": { "env_var_label": "my_api_key" }
    }
  }
}
```

### वेबहुक टूल ऑथ कनेक्शन में

ऑथ कनेक्शन (OAuth2, JWT, Basic Auth) भी हर एनवायरनमेंट के लिए रिज़ॉल्व किए जा सकते हैं। यह तब उपयोगी है जब आपके स्टेजिंग और प्रोडक्शन एनवायरनमेंट अलग OAuth क्लाइंट या टोकन एंडपॉइंट इस्तेमाल करते हों।

![एनवायरनमेंट वेरिएबल ऑथ कनेक्शन](/docs/_fern-img/41115e31cac8c55360cb4f5783a4d03cf63ea51a6f5baa2812993d70d7c4a4d5.webp)

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

#### API उदाहरण

`auth_connection` फ़ील्ड में एनवायरनमेंट वेरिएबल का रेफ़रेंस दें:

```json
{
  "api_schema": {
    "url": "https://{{system__env_api_host}}.example.com/v1/data",
    "method": "GET",
    "auth_connection": { "env_var_label": "my_oauth_connection" }
  }
}
```

### MCP सर्वर कनेक्शन में

एनवायरनमेंट वेरिएबल [MCP सर्वर](/docs/hi/eleven-agents/customization/tools/mcp) कनेक्शन के साथ उसी तरह काम करते हैं, जैसे वे वेबहुक टूल के साथ करते हैं। आप इन्हें यहां इस्तेमाल कर सकते हैं:

* **सर्वर URL**: हर एनवायरनमेंट के लिए अलग सर्वर पर पॉइंट करने हेतु MCP सर्वर URL को टेम्पलेट करें
* **रिक्वेस्ट हेडर**: ऑथेंटिकेशन हेडर के लिए सीक्रेट एनवायरनमेंट वेरिएबल इस्तेमाल करें
* **ऑथ कनेक्शन**: OAuth-आधारित MCP सर्वर के लिए ऑथ कनेक्शन एनवायरनमेंट वेरिएबल इस्तेमाल करें

उदाहरण के लिए, इस तरह कॉन्फ़िगर किया गया MCP सर्वर URL:

```
https://{{system__env_mcp_host}}.example.com/mcp
```

एनवायरनमेंट के आधार पर अलग-अलग MCP सर्वर एंडपॉइंट पर रिज़ॉल्व होता है।

### कस्टम LLM कॉन्फ़िगरेशन में

[कस्टम LLM](/docs/hi/eleven-agents/customization/llm/custom-llm) इस्तेमाल करते समय, एनवायरनमेंट वेरिएबल API की और रिक्वेस्ट हेडर को टेम्पलेट कर सकते हैं। इससे आप अलग-अलग एनवायरनमेंट में अलग मॉडल एंडपॉइंट और क्रेडेंशियल इस्तेमाल कर सकते हैं।

कस्टम LLM URL फ़ील्ड उसी `{{system__env_<label>}}` टेम्पलेट सिंटैक्स को सपोर्ट करता है। `api_key` फ़ील्ड एनवायरनमेंट वेरिएबल रेफ़रेंस स्वीकार करता है, ताकि हर एनवायरनमेंट के लिए अलग API की इस्तेमाल हो।

#### API उदाहरण

```json
{
  "conversation_config": {
    "agent": {
      "prompt": { "prompt": "You are a helpful assistant." },
      "llm": {
        "custom_llm": {
          "url": "https://{{system__env_llm_host}}.example.com/v1/chat/completions",
          "model_id": "my-model",
          "api_key": { "env_var_label": "llm_api_key" }
        }
      }
    }
  }
}
```

## एनवायरनमेंट तय करना

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

डैशबोर्ड में टेस्ट करते समय, एजेंट प्रीव्यू के ड्रॉपडाउन से एनवायरनमेंट चुनें:

![एजेंट प्रीव्यू एनवायरनमेंट
सेलेक्टर](/docs/_fern-img/052880e903ac2dc3539a0ed84feef5a3d31cd28c9b1345705c9003796d382803.webp)

### WebSocket

कन्वर्सेशन WebSocket से कनेक्ट करते समय `environment` क्वेरी पैरामीटर पास करें:

```
wss://api.elevenlabs.io/v1/convai/conversation?agent_id=<agent_id>&environment=staging
```

### WebRTC (Signed URL / Token)

WebRTC इस्तेमाल करते समय, कन्वर्सेशन टोकन का अनुरोध करते वक्त `environment` पैरामीटर पास करें:

**`Python`**

```python title="Python"
from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="your-api-key")

token = client.conversational_ai.conversation.get_token(
agent_id="your-agent-id",
environment="staging",
)

```

**`JavaScript`**

```javascript title="JavaScript"
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({ apiKey: "your-api-key" });

const token = await client.conversationalAi.conversation.getToken({
    agentId: "your-agent-id",
    environment: "staging",
});
```

**`cURL`**

```bash title="cURL"
curl "https://api.elevenlabs.io/v1/convai/conversation/token?agent_id=<agent_id>&environment=staging" \
  -H "xi-api-key: $ELEVENLABS_API_KEY"
```

### टेलीफोनी (Twilio और SIP ट्रंक)

फोन नंबर को किसी खास एनवायरनमेंट और किसी खास [एजेंट ब्रांच](/docs/hi/eleven-agents/operate/versioning) से पिन किया जा सकता है। इससे किसी टेस्ट फोन नंबर को ऐसे एजेंट की डेवलपमेंट ब्रांच पर रूट करना आसान होता है, जिसके टूल डेवलपमेंट API के साथ काम करते हैं।

![फोन नंबर एनवायरनमेंट और ब्रांच
सेलेक्टर](/docs/_fern-img/ba83735f5cad2006555eb73a12a520c7c86fa3d576d8f69f481a8c75d315cf1d.webp)

इनबाउंड कॉल के लिए, एनवायरनमेंट इस क्रम में रिज़ॉल्व होता है:

1. आपका सर्वर अगर हर कॉल के लिए डायनामिक रूप से कोई वैल्यू देता है, तो आपके [कन्वर्सेशन इनिशिएशन वेबहुक](/docs/hi/eleven-agents/customization/personalization#conversation-initiation-webhooks) से लौटाई गई `environment` वैल्यू
2. **फोन नंबर** पर स्टोर किया गया एनवायरनमेंट
3. डिफ़ॉल्ट रूप में `production`

यही प्राथमिकता `branch_id` पर भी लागू होती है। प्री-कॉल वेबहुक URL और हेडर, और पोस्ट-कॉल वेबहुक URL, फिर चुने गए एनवायरनमेंट का इस्तेमाल करके `{{system__env_*}}` टेम्पलेट को रिज़ॉल्व करते हैं।

फोन नंबर को एनवायरनमेंट और ब्रांच से पिन करें (`elevenlabs` Python SDK ≥ 2.47.0 या `@elevenlabs/elevenlabs-js` ≥ 2.47.0 आवश्यक है):

**`Python`**

```python title="Python"
import os
from dotenv import load_dotenv
from elevenlabs import ElevenLabs

load_dotenv()

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

elevenlabs.conversational_ai.phone_numbers.update(
    phone_number_id="phnum_8901k4t9z5defmb8vh3e9361y7nj",
    environment="staging",
    branch_id="agtbrch_8901k4t9z5defmb8vh3e9361y7nj",
)
```

**`JavaScript`**

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.phoneNumbers.update("phnum_8901k4t9z5defmb8vh3e9361y7nj", {
  environment: "staging",
  branchId: "agtbrch_8901k4t9z5defmb8vh3e9361y7nj",
});
```

**`cURL`**

```bash title="cURL"
curl -X PATCH "https://api.elevenlabs.io/v1/convai/phone-numbers/phnum_8901k4t9z5defmb8vh3e9361y7nj" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "environment": "staging",
    "branch_id": "agtbrch_8901k4t9z5defmb8vh3e9361y7nj"
  }'
```

आउटबाउंड कॉल के लिए, Twilio या SIP ट्रंक आउटबाउंड एंडपॉइंट के जरिए कॉल शुरू करते समय `environment` फ़ील्ड पास करें।

### React SDK

`useConversation` हुक में या सेशन शुरू करते समय `environment` विकल्प पास करें:

```tsx
import { useConversation } from "@11labs/react";

function Agent() {
  const conversation = useConversation();

  const connect = async () => {
    await conversation.startSession({
      agentId: "your-agent-id",
      environment: "staging",
    });
  };

  return <button onClick={connect}>Start conversation</button>;
}
```

## उदाहरण: मल्टी-एनवायरनमेंट एजेंट

यह उदाहरण एक पूरे सेटअप को दिखाता है, जिसमें एक ही एजेंट डेवलपमेंट, स्टेजिंग और प्रोडक्शन में अलग-अलग API बैकएंड और क्रेडेंशियल का इस्तेमाल करता है।

#### एनवायरनमेंट वेरिएबल बनाएं

डैशबोर्ड या API से तीन एनवायरनमेंट वेरिएबल बनाएं:

| लेबल          | टाइप       | डेवलपमेंट       | स्टेजिंग            | प्रोडक्शन        |
| ------------- | ---------- | --------------- | ------------------- | ---------------- |
| `api_host`    | String     | `dev.api`       | `staging.api`       | `api`            |
| `api_key`     | Secret     | `dev-secret-id` | `staging-secret-id` | `prod-secret-id` |
| `oauth_creds` | ऑथ कनेक्शन | `dev-oauth-id`  | `staging-oauth-id`  | `prod-oauth-id`  |

#### एनवायरनमेंट वेरिएबल रेफ़रेंस के साथ टूल कॉन्फ़िगर करें

टेम्पलेट सिंटैक्स का इस्तेमाल करके अपने वेबहुक टूल सेट अप करें:

* **URL**: `https://{{system__env_api_host}}.example.com/v1/orders`
* **हेडर**: `X-Api-Key` हेडर के लिए `api_key` एनवायरनमेंट वेरिएबल का रेफ़रेंस दें
* **ऑथ**: OAuth ऑथेंटिकेशन के लिए `oauth_creds` एनवायरनमेंट वेरिएबल का रेफ़रेंस दें

#### बातचीत के समय एनवायरनमेंट तय करें

बातचीत शुरू करते समय, टारगेट एनवायरनमेंट पास करें:

**`डेवलपमेंट`**

```python title="डेवलपमेंट"
conversation = client.conversational_ai.conversation.get_signed_url(
    agent_id="your-agent-id",
    environment="development",
)
```

**`स्टेजिंग`**

```python title="स्टेजिंग"
conversation = client.conversational_ai.conversation.get_signed_url(
    agent_id="your-agent-id",
    environment="staging",
)
```

**`प्रोडक्शन (डिफ़ॉल्ट)`**

```python title="प्रोडक्शन (डिफ़ॉल्ट)"
# No environment parameter needed — defaults to production
conversation = client.conversational_ai.conversation.get_signed_url(
    agent_id="your-agent-id",
)
```

#### एनवायरनमेंट के हिसाब से फ़िल्टर करें

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

![एनवायरनमेंट के आधार पर एनालिटिक्स फ़िल्टर करें](/docs/_fern-img/640f45e330a6f58648bb79fb588b580bb1d938e20f46c453b6d0c0efdac04054.webp)

![एनवायरनमेंट के आधार पर बातचीत इतिहास फ़िल्टर करें](/docs/_fern-img/de6cdcdad31761a4e94928ea125503a555635eaf579521096b5f38d5ef931cd0.webp)

### नामकरण की शर्तें

* **लेबल**: सिर्फ़ अल्फ़ान्यूमेरिक कैरेक्टर और अंडरस्कोर (जैसे, `base_url`, `api_key_v2`)
* **एनवायरनमेंट नाम**: लोअरकेस अक्षर से शुरू होना चाहिए और इसमें सिर्फ़ लोअरकेस अक्षर, अंक, अंडरस्कोर और हाइफ़न हो सकते हैं; अधिकतम 64 कैरेक्टर (जैसे, `production`, `staging`, `dev-us-east`)
* हर एनवायरनमेंट वेरिएबल में `production` वैल्यू होना ज़रूरी है

## अगले चरण

#### [वेबहुक टूल](/docs/hi/eleven-agents/customization/tools/webhook-tools)

एनवायरनमेंट के अनुसार URL और ऑथेंटिकेशन के साथ वेबहुक टूल कॉन्फ़िगर करें

#### [MCP सर्वर](/docs/hi/eleven-agents/customization/tools/mcp)

हर एनवायरनमेंट के लिए कॉन्फ़िगरेशन के साथ MCP सर्वर कनेक्ट करें

#### [कस्टम LLM](/docs/hi/eleven-agents/customization/llm/custom-llm)

अलग-अलग एनवायरनमेंट में अलग मॉडल एंडपॉइंट इस्तेमाल करें

#### [वर्ज़निंग](/docs/hi/eleven-agents/operate/versioning)

एनवायरनमेंट वेरिएबल को ब्रांच और ट्रैफ़िक स्प्लिटिंग के साथ इस्तेमाल करें