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

# भाषा पहचान

## परिचय

`language detection` सिस्टम टूल आपके ElevenLabs एजेंट को एजेंट द्वारा समर्थित किसी भी आउटपुट भाषा पर स्विच करने देता है।
यह सिस्टम टूल अपने-आप सक्षम नहीं होता। आपके खास उपयोग के मामले के अनुसार इसका विवरण बदला जा सकता है।

> **Note**
>
> जहाँ संभव हो, हम किसी एजेंट के लिए सभी भाषाएँ और भाषा पहचान सिस्टम टूल सक्षम करने की सलाह देते हैं।

हमारा भाषा पहचान टूल, मिले हुए ऑडियो की पहचानी गई भाषा और सामग्री के आधार पर, दो स्थितियों में भाषा स्विच करता है:

* `detection` अगर यूज़र मौजूदा आउटपुट भाषा से अलग भाषा बोलता है, तो स्विच ट्रिगर होगा
* `content` अगर यूज़र मौजूदा भाषा में नई भाषा पर स्विच करने के लिए कहता है, तो स्विच ट्रिगर होगा

**उद्देश्य**: बातचीत के दौरान यूज़र की पहचानी गई भाषा पर अपने-आप स्विच करना।

**ट्रिगर की शर्तें**: LLM को यह टूल तब कॉल करना चाहिए जब:

* यूज़र मौजूदा बातचीत की भाषा से अलग भाषा में बोलता है
* यूज़र साफ़ तौर पर भाषा बदलने का अनुरोध करता है
* बातचीत के लिए कई भाषाओं का सपोर्ट चाहिए

**पैरामीटर्स**:

* `reason` (string, आवश्यक): भाषा बदलने का कारण
* `language` (string, आवश्यक): जिस भाषा कोड पर स्विच करना है (सपोर्टेड भाषाओं की सूची में होना चाहिए)

**फ़ंक्शन कॉल फ़ॉर्मैट**:

```json
{
  "type": "function",
  "function": {
    "name": "language_detection",
    "arguments": "{\"reason\": \"User requested Spanish\", \"language\": \"es\"}"
  }
}
```

**इम्प्लीमेंटेशन**: एजेंट सेटिंग्स में सपोर्टेड भाषाएं कॉन्फ़िगर करें और भाषा पहचान सिस्टम टूल जोड़ें। एजेंट पहचानी गई भाषाओं से मेल खाने के लिए अपने-आप वॉइस और जवाब बदल देगा।

## भाषा पहचान सक्षम करना

#### समर्थित भाषाएँ कॉन्फ़िगर करें

एजेंट जिन भाषाओं पर स्विच कर सकता है, उन्हें `Agent` सेटिंग्स टैब में तय करना होगा।

![एजेंट भाषाएँ](/docs/_fern-img/633707d54276febd3baa054c4f41b186225b74f606307a46e8262607befc8381.webp)

#### भाषा पहचान टूल जोड़ें

`Agent` टैब में अपने एजेंट के टूल्स में पहले से कॉन्फ़िगर किया गया सिस्टम टूल चुनकर भाषा पहचान सक्षम करें।
`add tool` चुनने पर यह अपने-आप एक विकल्प के रूप में उपलब्ध होता है।

![सिस्टम टूल](/docs/_fern-img/3d17048ab2bc1a0547c49056abb98f624caf866927ff1714af27f898b06ab18f.webp)

#### टूल का विवरण कॉन्फ़िगर करें

ऐसा विवरण जोड़ें जो बताए कि टूल को कब कॉल करना है

![विवरण](/docs/_fern-img/3bebc9fe07dba7121bce7793f3793858c710fc8ea1c221347604eb05929271df.webp)

## बातचीत की शुरुआत तक स्विचिंग सीमित करना

लंबी बातचीत में, बैकग्राउंड में हो रही बातचीत या असामान्य लहजा कभी-कभी ऐसा स्विच ट्रिगर कर सकता है जो
कॉलर का इरादा नहीं था। `only_at_conversation_start` सक्षम करने से स्विचिंग पहले दो यूज़र
टर्न तक सीमित हो जाती है।

अगर उन दो टर्न के दौरान भाषा स्विच नहीं होती, तो बाकी बातचीत के लिए भाषा पहचान अक्षम हो जाती है:
बाद की हर कोशिश विफल होती है और एजेंट मौजूदा भाषा में ही बोलता रहता है। अगर उस समय-सीमा में भाषा
स्विच हो जाती है, तो बाकी बातचीत के लिए भी स्विचिंग उपलब्ध रहती है, इसलिए गलत पहचान को फिर भी
सुधारा जा सकता है।

यह विकल्प डिफ़ॉल्ट रूप से अक्षम होता है।

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

**Tools** टैब में **Detect language** टूल चुनें और **Only at start of conversation** सक्षम करें।

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

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

```bash
elevenlabs agents pull
```

#### \`agent_configs/\<agent-name>.json\` संपादित करें

भाषा पहचान टूल पर `only_at_conversation_start` सेट करें। संक्षिप्तता के लिए, आसपास के फ़ील्ड
यहाँ नहीं दिए गए हैं।

```json
{
  "conversation_config": {
    "agent": {
      "prompt": {
        "built_in_tools": {
          "language_detection": {
            "type": "system",
            "name": "language_detection",
            "params": {
              "system_tool_type": "language_detection",
              "only_at_conversation_start": true
            }
          }
        }
      }
    }
  }
}
```

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

```bash
elevenlabs agents push
```

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

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "agent": {
            "prompt": {
                "built_in_tools": {
                    "language_detection": {
                        "type": "system",
                        "name": "language_detection",
                        "params": {
                            "system_tool_type": "language_detection",
                            "only_at_conversation_start": True,
                        },
                    }
                }
            }
        }
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    agent: {
      prompt: {
        builtInTools: {
          languageDetection: {
            type: "system",
            name: "language_detection",
            params: {
              systemToolType: "language_detection",
              onlyAtConversationStart: true,
            },
          },
        },
      },
    },
  },
});
```

> **Note**
>
> स्विचिंग ब्लॉक होने पर, टूल LLM को मौजूदा भाषा में बोलते रहने का निर्देश देने वाली एक त्रुटि लौटाता है।
> कारण कॉलर को नहीं बताया जाता।

## API इम्प्लीमेंटेशन

API के ज़रिए एजेंट बनाते समय, आप अपनी एजेंट कॉन्फ़िगरेशन में `language detection` टूल जोड़ सकते हैं। इसे सिस्टम टूल के रूप में परिभाषित किया जाना चाहिए:

```python
from elevenlabs import AgentConfig, ConversationalConfig, ElevenLabs

elevenlabs = ElevenLabs(api_key="YOUR_API_KEY")

# Create language presets
language_presets = {
    "nl": {"overrides": {"agent": {"first_message": "Hoi, hoe gaat het met je?"}}},
    "fi": {"overrides": {"agent": {"first_message": "Hei, kuinka voit?"}}},
    "tr": {"overrides": {"agent": {"first_message": "Merhaba, nasılsın?"}}},
    "ru": {"overrides": {"agent": {"first_message": "Привет, как ты?"}}},
    "pt": {"overrides": {"agent": {"first_message": "Oi, como você está?"}}},
}

response = elevenlabs.conversational_ai.agents.create(
    conversation_config=ConversationalConfig(
        agent=AgentConfig(
            first_message="Hi how are you?",
            prompt={
                "built_in_tools": {
                    "language_detection": {
                        "type": "system",
                        "name": "language_detection",
                        # Optional: customize when the tool should be triggered
                        "description": "",
                        "params": {"system_tool_type": "language_detection"},
                    }
                },
            },
        ),
        language_presets=language_presets,
    ),
)
```

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

const elevenlabs = new ElevenLabsClient({
  apiKey: "YOUR_API_KEY",
});

await elevenlabs.conversationalAi.agents.create({
  conversationConfig: {
    agent: {
      firstMessage: "Hi, how are you?",
      prompt: {
        builtInTools: {
          languageDetection: {
            type: "system",
            name: "language_detection",
            description: "", // Optional: Customize when the tool should be triggered
            params: { systemToolType: "language_detection" },
          },
        },
      },
    },
    languagePresets: {
      nl: { overrides: { agent: { firstMessage: "Hoi, hoe gaat het met je?" } } },
      fi: {
        overrides: { agent: { firstMessage: "Hei, kuinka voit?" } },
        firstMessageTranslation: {
          sourceHash: '{"firstMessage":"Hi how are you?","language":"en"}',
          text: "Hei, kuinka voit?",
        },
      },
      tr: { overrides: { agent: { firstMessage: "Merhaba, nasılsın?" } } },
      ru: { overrides: { agent: { firstMessage: "Привет, как ты?" } } },
      pt: { overrides: { agent: { firstMessage: "Oi, como você está?" } } },
      ar: { overrides: { agent: { firstMessage: "مرحبًا كيف حالك؟" } } },
    },
  },
});
```

```bash
curl -X POST https://api.elevenlabs.io/v1/convai/agents/create \
     -H "xi-api-key: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
  "conversation_config": {
    "agent": {
      "first_message": "Hi how are you?",
      "prompt": {
        "built_in_tools": {
          "language_detection": {
            "type": "system",
            "name": "language_detection",
            "description": "",
            "params": { "system_tool_type": "language_detection" }
          }
        }
      }
    },
    "language_presets": {
      "nl": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "Hoi, hoe gaat het met je?",
            "language": null
          },
          "tts": null
        }
      },
      "fi": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "Hei, kuinka voit?",
            "language": null
          },
          "tts": null
        }
      },
      "tr": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "Merhaba, nasılsın?",
            "language": null
          },
          "tts": null
        }
      },
      "ru": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "Привет, как ты?",
            "language": null
          },
          "tts": null
        }
      },
      "pt": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "Oi, como você está?",
            "language": null
          },
          "tts": null
        }
      },
      "ar": {
        "overrides": {
          "agent": {
            "prompt": null,
            "first_message": "مرحبًا كيف حالك؟",
            "language": null
          },
          "tts": null
        }
      }
    }
  }
}'
```

> **Tip**
>
> डिफ़ॉल्ट भाषा पहचान प्रॉम्प्ट इस्तेमाल करने के लिए विवरण खाली छोड़ दें।