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

# एजेंट वर्ज़निंग

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

> **Note**
>
> A/B टेस्ट चलाने हैं? लाइव ट्रैफ़िक के साथ एजेंट बदलावों का परीक्षण करने के सुझाए गए वर्कफ़्लो के लिए [एक्सपेरिमेंट्स](/docs/hi/eleven-agents/operate/experiments) देखें।

## ओवरव्यू

वर्ज़निंग सिस्टम प्रदान करता है:

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

> **Note**
>
> किसी एजेंट पर वर्ज़निंग सक्षम होने के बाद इसे बंद नहीं किया जा सकता। मौजूदा एजेंटों पर
> वर्ज़निंग सक्षम करने से पहले इस बात पर विचार करें।

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

### वर्ज़न

वर्ज़न किसी निश्चित समय पर एजेंट के कॉन्फ़िगरेशन का एक अपरिवर्तनीय स्नैपशॉट होता है। हर वर्ज़न की एक यूनिक ID होती है (फ़ॉर्मैट: `agtvrsn_xxxx`) और इसमें शामिल होते हैं:

* `conversation_config` - सिस्टम प्रॉम्प्ट, LLM सेटिंग्स, वॉइस कॉन्फ़िगरेशन, टूल्स, नॉलेज बेस
* `platform_settings` - मूल्यांकन, विजेट, डेटा कलेक्शन और सुरक्षा सेटिंग्स समेत वर्ज़न किया गया सबसेट
* `workflow` - नोड्स और एज के साथ पूरा वर्कफ़्लो डेफ़िनिशन

वर्ज़न किए गए एजेंट में बदलाव सहेजने पर वर्ज़न अपने-आप बन जाते हैं। बनने के बाद किसी वर्ज़न को बदला नहीं जा सकता।

### ब्रांच

ब्रांच, git ब्रांच की तरह, डेवलपमेंट की नाम वाली लाइनें हैं। वे आपको मेन ब्रांच में वापस मर्ज करने से पहले अलग से बदलावों पर काम करने देती हैं।

* हर वर्ज़न किए गए एजेंट में एक **Main** ब्रांच होती है, जिसे डिलीट या आर्काइव नहीं किया जा सकता
* अतिरिक्त ब्रांच सिर्फ़ मेन से नहीं, बल्कि किसी भी मौजूदा ब्रांच के किसी भी वर्ज़न से बनाई जा सकती हैं
* ब्रांच को किसी भी दूसरी ब्रांच में मर्ज किया जा सकता है, और मेन के अलावा अन्य ब्रांच को इसके नवीनतम बदलाव पाने के लिए मेन पर रीबेस किया जा सकता है
* हर ब्रांच में होते हैं: id (`agtbrch_xxxx`), नाम, विवरण और वर्ज़न की सूची
* ब्रांच नामों में ये हो सकते हैं: अक्षर, संख्याएं और `() [] {} - / .` (अधिकतम 140 वर्ण)

### ट्रैफ़िक डिप्लॉयमेंट

ट्रैफ़िक को प्रतिशत के हिसाब से कई ब्रांच में बांटा जा सकता है, जिससे धीरे-धीरे रोलआउट और A/B टेस्टिंग संभव होती है।

* प्रतिशत का कुल योग हमेशा ठीक **100%** होना चाहिए
* ट्रैफ़िक रूटिंग, बातचीत ID के आधार पर **निर्धारक** होती है (एक ही यूज़र हर बार उसी ब्रांच पर जाता है)
* केवल 0% ट्रैफ़िक वाली गैर-आर्काइव ब्रांच को आर्काइव किया जा सकता है

### ड्राफ़्ट

बिना सहेजे बदलाव ड्राफ़्ट के रूप में स्टोर होते हैं, जिससे आप तुरंत नया वर्ज़न बनाए बिना बदलावों पर काम कर सकते हैं।

* ड्राफ़्ट **हर यूज़र और हर ब्रांच के लिए अलग** होते हैं (हर टीम सदस्य का अपना ड्राफ़्ट होता है)
* नया वर्ज़न कमिट होने पर ड्राफ़्ट अपने-आप हटा दिए जाते हैं
* किसी ब्रांच में मर्ज करने पर भी ड्राफ़्ट हटा दिए जाते हैं

## वर्ज़निंग सक्षम करना

वर्ज़निंग वैकल्पिक है और इसे स्पष्ट रूप से सक्षम करना होता है। आप इसे नया एजेंट बनाते समय या किसी मौजूदा एजेंट पर सक्षम कर सकते हैं।

> **Warning**
>
> एक बार सक्षम होने पर वर्ज़निंग को बंद नहीं किया जा सकता। यह आपके एजेंट में स्थायी बदलाव है।

### एजेंट बनाते समय सक्षम करें

#### डैशबोर्ड से सक्षम करें

डैशबोर्ड में अपना एजेंट खोलें, **Settings** पर जाएं और वर्ज़निंग सक्षम करें। सक्षम होने के बाद ब्रांच, ड्राफ़्ट, वर्ज़न और ट्रैफ़िक डिप्लॉयमेंट मैनेज करने के लिए **Versioning** टैब उपलब्ध हो जाएगा।

#### API से सक्षम करें

```python
from elevenlabs.client import ElevenLabs
from elevenlabs.types import *

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

agent = client.conversational_ai.agents.create(
    conversation_config=ConversationalConfig(
        agent=AgentConfig(
            first_message="Hello! How can I help you today?",
            prompt={"prompt": "You are a helpful assistant."},
        )
    ),
    enable_versioning=True
)

print(f"Agent created with versioning: {agent.agent_id}")
```

```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 you today?',
      prompt: {
        prompt: 'You are a helpful assistant.',
      },
    },
  },
  enableVersioning: true,
});

console.log(`Agent created with versioning: ${agent.agentId}`);
```

### मौजूदा एजेंट पर सक्षम करें

#### डैशबोर्ड से सक्षम करें

डैशबोर्ड में अपना एजेंट खोलें, **Settings** पर जाएं और वर्ज़निंग चालू करें।

#### API से सक्षम करें

```python
agent = client.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    enable_versioning_if_not_enabled=True
)
```

```javascript
const agent = await client.conversationalAi.agents.update('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  enableVersioningIfNotEnabled: true,
});
```

वर्ज़निंग सक्षम करने पर वर्तमान एजेंट कॉन्फ़िगरेशन वाले पहले वर्ज़न के साथ शुरुआती "Main" ब्रांच बनती है।

## ब्रांच के साथ काम करना

### ब्रांच बनाना

ब्रांच सिर्फ़ मेन से नहीं, बल्कि किसी भी ब्रांच के किसी भी वर्ज़न से बनाई जा सकती हैं। आप वैकल्पिक रूप से ऐसे कॉन्फ़िगरेशन बदलाव शामिल कर सकते हैं जो नई ब्रांच के शुरुआती वर्ज़न पर लागू होंगे।

```python
branch = client.conversational_ai.agents.branches.create(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    parent_version_id="agtvrsn_xxxx",
    name="experiment-v2",
    description="Testing new prompt and voice settings"
)

print(f"Created branch: {branch.created_branch_id}")
print(f"Initial version: {branch.created_version_id}")
```

```javascript
const branch = await client.conversationalAi.agents.branches.create('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  parentVersionId: 'agtvrsn_xxxx',
  name: 'experiment-v2',
  description: 'Testing new prompt and voice settings',
});

console.log(`Created branch: ${branch.createdBranchId}`);
console.log(`Initial version: ${branch.createdVersionId}`);

```

### ब्रांच की सूची देखना

```python
branches = client.conversational_ai.agents.branches.list(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6"
)

for branch in branches.branches:
print(f"{branch.name}: {branch.id}")

```

```javascript
const branches = await client.conversationalAi.agents.branches.list('agent_7101k5zvyjhmfg983brhmhkd98n6');

for (const branch of branches.branches) {
  console.log(`${branch.name}: ${branch.id}`);
}

```

### ब्रांच की जानकारी पाना

```python
branch = client.conversational_ai.agents.branches.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)

print(f"Branch: {branch.name}")
print(f"Versions: {len(branch.versions)}")

```

```javascript
const branch = await client.conversationalAi.agents.branches.get('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');

console.log(`Branch: ${branch.name}`);
console.log(`Versions: ${branch.versions.length}`);

```

## बदलाव कमिट करना

वर्ज़निंग सक्षम वाले एजेंट को अपडेट करते समय उस ब्रांच पर नया वर्ज़न बनाने के लिए `branch_id` निर्दिष्ट करें।

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

अपने एजेंट का **Versioning** टैब खोलें, लक्ष्य ब्रांच पर जाएं, कॉन्फ़िगरेशन में बदलाव करें और नया वर्ज़न बनाने के लिए सेव करें।

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

नाम या ID के ज़रिए किसी खास ब्रांच पर पुश करने के लिए `--branch` फ़्लैग पास करें। ब्रांच पहले से मौजूद होनी चाहिए।

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

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

```python
agent = client.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    conversation_config=ConversationalConfig(
        agent=AgentConfig(
            prompt={"prompt": "You are a friendly customer support agent."},
        )
    )
)
```

```javascript
const agent = await client.conversationalAi.agents.update(
  'agent_7101k5zvyjhmfg983brhmhkd98n6',
  {
    conversationConfig: {
      agent: {
        prompt: {
          prompt: 'You are a friendly customer support agent.',
        },
      },
    },
  },
  { branchId: 'agtbrch_xxxx' }
);
```

निर्दिष्ट ब्रांच पर अपने-आप नया वर्ज़न बन जाता है और उस ब्रांच पर उस यूज़र का कोई भी मौजूदा ड्राफ़्ट हटा दिया जाता है।

## ट्रैफ़िक डिप्लॉय करना

ब्रांच में ट्रैफ़िक बांटने के लिए deployments एंडपॉइंट इस्तेमाल करें। इससे धीरे-धीरे रोलआउट और A/B टेस्टिंग संभव होती है।

```python
deployment = client.conversational_ai.agents.deployments.create(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    deployments=[
        {"branch_id": "agtbrch_main", "percentage": 90},
        {"branch_id": "agtbrch_xxxx", "percentage": 10}
    ]
)
```

```javascript
const deployment = await client.conversationalAi.agents.deployments.create('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  deployments: [
    { branchId: 'agtbrch_main', percentage: 90 },
    { branchId: 'agtbrch_xxxx', percentage: 10 },
  ],
});
```

> **Warning**
>
> सभी प्रतिशतों का योग ठीक 100% होना चाहिए। ऐसा न होने पर डिप्लॉयमेंट विफल हो जाएगा।

ट्रैफ़िक रूटिंग बातचीत ID के आधार पर निर्धारक होती है, जिससे एक ही यूज़र हर सेशन में लगातार उसी ब्रांच तक पहुंचता है।

## ब्रांच मर्ज करना

जब आप किसी ब्रांच के बदलावों से संतुष्ट हों, तो उन्हें दूसरी ब्रांच में मर्ज करें। किसी भी गैर-आर्काइव ब्रांच को सिर्फ़ मेन में नहीं, बल्कि किसी भी दूसरी गैर-आर्काइव ब्रांच में मर्ज किया जा सकता है।

> **Note**
>
> किसी ब्रांच के बदलाव मर्ज होने से पहले उनकी समीक्षा करवाने के लिए या ऐसी ब्रांच तक पहुंचने के लिए जिस पर
> आपके पास लिखने की अनुमति नहीं है, सीधे मर्ज करने के बजाय [मर्ज प्रस्ताव](/docs/hi/eleven-agents/operate/merge-proposals) खोलें।

```python
merge = client.conversational_ai.agents.branches.merge(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    source_branch_id="agtbrch_xxxx",
    target_branch_id="agtbrch_main",
    archive_source_branch=True,  # Default: true
    force=False  # Default: false
)
```

```javascript
const merge = await client.conversationalAi.agents.branches.merge('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  targetBranchId: 'agtbrch_main',
  archiveSourceBranch: true, // Default: true
  force: false, // Default: false
});
```

मर्जिंग:

* सोर्स ब्रांच के कॉन्फ़िगरेशन के साथ लक्ष्य ब्रांच पर नया वर्ज़न बनाती है
* वैकल्पिक रूप से सोर्स ब्रांच को आर्काइव करती है (डिफ़ॉल्ट व्यवहार)
* सोर्स ब्रांच से लक्ष्य ब्रांच पर ट्रैफ़िक अपने-आप ट्रांसफ़र करती है

> **Note**
>
> अगर सोर्स ब्रांच लक्ष्य ब्रांच से बनाई गई थी (और उसमें लक्ष्य ब्रांच से आगे कोई नया कमिट नहीं है), तो मर्जिंग
> `no_new_changes_to_merge` के साथ विफल होती है। अगर उसे उस लक्ष्य में पहले ही मर्ज किया जा चुका है, तो
> `branch_already_merged` के साथ विफल होती है।

### मर्ज कॉन्फ़्लिक्ट हल करना

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

मर्ज को कमिट करने से पहले उसका परिणाम प्रीव्यू करें, जिसमें ओवरराइड होने वाले सभी फ़ील्ड भी शामिल हों:

```python
preview = client.conversational_ai.agents.branches.preview_merge(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    source_branch_id="agtbrch_xxxx",
    target_branch_id="agtbrch_main",
    force=False
)

print(preview.overridden_fields)
print(preview.conflicts)
```

```javascript
const preview = await client.conversationalAi.agents.branches.previewMerge('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  targetBranchId: 'agtbrch_main',
  force: false,
});

console.log(preview.overriddenFields);
console.log(preview.conflicts);
```

## ब्रांच को मेन पर रीबेस करना

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

```python
client.conversational_ai.agents.branches.rebase(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)
```

```javascript
await client.conversationalAi.agents.branches.rebase('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');
```

रीबेसिंग:

* ब्रांच पर नया वर्ज़न बनाती है, जिसमें मेन के नवीनतम बदलाव शामिल होते हैं
* ब्रांच के अपने बदलाव बनाए रखती है: अगर किसी सेटिंग को ब्रांच और मेन, दोनों में संपादित किया गया है, तो ब्रांच का मान हमेशा रखा जाता है
* अगर ब्रांच में मेन के सभी बदलाव पहले से शामिल हैं, तो `branch_already_up_to_date` के साथ विफल होती है

> **Note**
>
> केवल गैर-मेन ब्रांच को और केवल मेन पर रीबेस किया जा सकता है। मेन ब्रांच को खुद रीबेस करने पर
> `cannot_rebase_main` त्रुटि मिलती है।

रीबेस को कमिट करने से पहले उसका परिणाम प्रीव्यू करें:

```python
preview = client.conversational_ai.agents.branches.preview_rebase(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)

print(preview.overridden_fields)
```

```javascript
const preview = await client.conversationalAi.agents.branches.previewRebase('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');

console.log(preview.overriddenFields);
```

## ब्रांच आर्काइव करना

जिन ब्रांच की अब ज़रूरत नहीं है, उन्हें आर्काइव करें। इससे आपकी ब्रांच सूची व्यवस्थित रहती है।

```python
client.conversational_ai.agents.branches.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    archived=True
)
```

```javascript
await client.conversationalAi.agents.branches.update('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  archived: true,
});
```

> **Warning**
>
> जिस ब्रांच को ट्रैफ़िक आवंटित है, उसे आर्काइव नहीं किया जा सकता। आर्काइव करने से पहले सारा ट्रैफ़िक हटा दें।

`archived=False` सेट करके आर्काइव की गई ब्रांच को फिर से सक्रिय किया जा सकता है।

## वर्ज़न किए गए एजेंट की कॉपी बनाना

किसी एजेंट की कॉपी बनाने पर नया एजेंट बनता है, जिसमें सोर्स एजेंट की केवल मेन ब्रांच नहीं, बल्कि हर गैर-आर्काइव ब्रांच की कॉपी होती है।

```python
duplicate = client.conversational_ai.agents.duplicate(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    name="Copy of my agent"
)

print(duplicate.agent_id)
```

```javascript
const duplicate = await client.conversationalAi.agents.duplicate('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  name: 'Copy of my agent',
});

console.log(duplicate.agentId);
```

कॉपी किए गए एजेंट में:

* मेन ब्रांच, सोर्स एजेंट की मेन ब्रांच के नवीनतम वर्ज़न से बनाई जाती है
* हर दूसरी गैर-आर्काइव ब्रांच उसी नाम और विवरण के साथ, उस ब्रांच के नवीनतम वर्ज़न से शुरू करते हुए फिर से बनाई जाती है
* हर ब्रांच एक ही वर्ज़न से शुरू होती है, क्योंकि वर्ज़न इतिहास कॉपी नहीं होता
* आर्काइव की गई ब्रांच और ड्राफ़्ट कॉपी नहीं होते
* ट्रैफ़िक डिप्लॉयमेंट कॉपी नहीं होते, इसलिए जब तक आप दूसरी ब्रांच पर [ट्रैफ़िक डिप्लॉय](#deploying-traffic) नहीं करते, सारा ट्रैफ़िक मेन ब्रांच पर जाता है

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

## खास वर्ज़न पाना

आप किसी एजेंट को एक खास वर्ज़न या ब्रांच टिप पर पा सकते हैं।

### खास वर्ज़न पर एजेंट पाएं

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    version_id="agtvrsn_xxxx"
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  versionId: 'agtvrsn_xxxx',
});
```

### ब्रांच टिप पर एजेंट पाएं

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  branchId: 'agtbrch_xxxx',
});
```

### ड्राफ़्ट बदलाव शामिल करें

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    include_draft=True
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  branchId: 'agtbrch_xxxx',
  includeDraft: true,
});
```

## सेटिंग्स रेफ़रेंस

### वर्ज़न की गई सेटिंग्स

ये सेटिंग्स वर्ज़न और ब्रांच के बीच अलग हो सकती हैं:

| श्रेणी                                | सेटिंग्स                                                                                                                                                                                                                                                                                          |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **बातचीत कॉन्फ़िगरेशन**               | सिस्टम प्रॉम्प्ट, एजेंट व्यक्तित्व, LLM चयन और पैरामीटर, वॉइस सेटिंग्स (TTS मॉडल, वॉइस ID), टूल्स कॉन्फ़िगरेशन, नॉलेज बेस, पहला मैसेज, भाषा सेटिंग्स, टर्न डिटेक्शन, इंटरप्शन सेटिंग्स                                                                                                            |
| **वर्ज़न की गई प्लेटफ़ॉर्म सेटिंग्स** | `evaluation` - मूल्यांकन मानदंड, `widget` - विजेट का स्वरूप और व्यवहार, `data_collection` - स्ट्रक्चर्ड डेटा एक्सट्रैक्शन, `overrides` - बातचीत शुरू करने के ओवरराइड, `workspace_overrides` - वेबहुक्स कॉन्फ़िगरेशन, `testing` - टेस्ट कॉन्फ़िगरेशन, `safety` - गार्डरेल्स (IVC/non-IVC सेटिंग्स) |
| **वर्कफ़्लो**                         | पूरा वर्कफ़्लो डेफ़िनिशन (नोड्स और एज)                                                                                                                                                                                                                                                            |

### प्रति-एजेंट सेटिंग्स

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

| सेटिंग                                  | विवरण                                                         |
| --------------------------------------- | ------------------------------------------------------------- |
| `name`, `tags`                          | एजेंट का नाम और टैग                                           |
| `auth`                                  | ऑथेंटिकेशन सेटिंग्स और अलाउलिस्ट                              |
| `call_limits`                           | कॉन्करेंसी और दैनिक सीमाएं                                    |
| `queueing_config`                       | कॉन्करेंसी सीमा से अधिक कॉलर्स के लिए वेट क्यू और होल्ड ऑडियो |
| `privacy`                               | रिटेंशन सेटिंग्स, ज़ीरो-रिटेंशन मोड और यूज़र मेमोरीज़         |
| `analysis_llm`                          | कॉल के बाद के विश्लेषण के लिए इस्तेमाल होने वाला LLM          |
| `topic_discovery`, `sentiment_analysis` | एजेंट-स्तर की विश्लेषण सेटिंग्स                               |
| `simulation_library`                    | सिमुलेशन लाइब्रेरी सेटिंग्स                                   |
| `alerting`                              | अलर्ट वेबहुक्स और मॉनिटर थ्रेशहोल्ड                           |
| `ban`                                   | बैन स्टेटस (केवल एडमिन)                                       |

> **Warning**
>
> प्रति-एजेंट सेटिंग्स केवल मेन ब्रांच पर बदली जा सकती हैं। अन्य ब्रांच पर डैशबोर्ड इन्हें रीड-ओनली दिखाता है,
> और किसी गैर-मेन ब्रांच पर वर्ज़न पब्लिश करने से इनमें किए गए बदलाव हटा दिए जाते हैं। बाद में ब्रांच को मेन में
> मर्ज करने पर भी ये लागू नहीं होते। इन्हें बदलने के लिए मेन ब्रांच पर जाएं; वहां पब्लिश होने के बाद बदलाव हर ब्रांच पर लागू होगा।

## सर्वोत्तम तरीके

#### ब्रांच बनाने से पहले टेस्ट बनाएं

नई ब्रांच बनाने से पहले अपेक्षित व्यवहार को कैप्चर करने वाले [ऑटोमेटेड टेस्ट](/docs/hi/eleven-agents/customization/agent-testing) सेट अप करें।
इससे एक बेसलाइन बनती है और अपने एक्सपेरिमेंट पर काम करते समय रिग्रेशन जल्दी पकड़ने में मदद मिलती है।

#### वर्णनात्मक ब्रांच नाम इस्तेमाल करें

ऐसे ब्रांच नाम चुनें जो एक्सपेरिमेंट का उद्देश्य साफ़ तौर पर बताएं। आसानी से रेफ़रेंस के लिए फ़ीचर
नाम, हाइपोथीसिस या टिकट नंबर शामिल करें (जैसे, `feature/new-greeting-flow` या
`experiment/shorter-responses`)।

#### ब्रांच के उद्देश्य दस्तावेज़ करें

ब्रांच के विवरण फ़ील्ड में बताएं कि आप किस हाइपोथीसिस का परीक्षण कर रहे हैं, किन मेट्रिक्स से
सफलता तय होगी, और कोई डिपेंडेंसी या विचारणीय बातें। इससे टीम सदस्य सक्रिय एक्सपेरिमेंट समझ पाते हैं।

#### चल रहे काम के लिए ड्राफ़्ट इस्तेमाल करें

बदलावों पर काम करते समय ड्राफ़्ट बार-बार सेव करें। इससे अनावश्यक वर्ज़न बनाए बिना आपका काम सुरक्षित रहता है।
केवल तभी कमिट करें जब आप परीक्षण या डिप्लॉय करने के लिए तैयार हों।

#### छोटे ट्रैफ़िक प्रतिशत से शुरू करें

नई ब्रांच डिप्लॉय करते समय ट्रैफ़िक के 5-10% से शुरू करें। इससे समस्याएं होने पर प्रभाव सीमित रहता है,
फिर भी सार्थक डेटा मिलता है।

#### ट्रैफ़िक बढ़ाने से पहले मुख्य मेट्रिक्स मॉनिटर करें

ब्रांच का प्रदर्शन तुलना करने के लिए [एनालिटिक्स डैशबोर्ड](/docs/hi/eleven-agents/dashboard) इस्तेमाल करें।
कॉल कंप्लीशन रेट, औसत बातचीत अवधि, सफलता मूल्यांकन स्कोर और टूल एक्ज़ीक्यूशन रेट देखें।
मेट्रिक्स के आपकी मेन ब्रांच बेसलाइन के बराबर या उससे बेहतर होने पर ही ट्रैफ़िक बढ़ाएं।

#### ट्रैफ़िक धीरे-धीरे बढ़ाएं

भरोसा बढ़ने पर ट्रैफ़िक को चरणों में बढ़ाएं (10% → 25% → 50% → 100%)। यह तरीका
हर चरण पर प्रदर्शन को सत्यापित करते हुए जोखिम कम करता है।

#### ब्रांच को कम समय तक रखें

कॉन्फ़िगरेशन ड्रिफ़्ट से बचने के लिए सफल एक्सपेरिमेंट तुरंत मर्ज करें। जिन ब्रांच को ज्यादा समय तक
खुला रखना हो, उन्हें समय-समय पर मेन पर रीबेस करें, ताकि वे बहुत अलग न हो जाएं और मर्ज करना कठिन न बने।

## अगले चरण

#### [एक्सपेरिमेंट्स](/docs/hi/eleven-agents/operate/experiments)

ब्रांच और ट्रैफ़िक डिप्लॉयमेंट के साथ A/B टेस्ट चलाएं

#### [टेस्टिंग](/docs/hi/eleven-agents/customization/agent-testing)

अपने एजेंट वर्ज़न के लिए ऑटोमेटेड टेस्ट सेट अप करें

#### [एनालिटिक्स](/docs/hi/eleven-agents/dashboard)

अलग-अलग ब्रांच का प्रदर्शन मॉनिटर करें

#### [CLI](/docs/hi/eleven-agents/operate/cli)

कमांड लाइन से वर्ज़निंग मैनेज करें