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

# Détection de la langue

## Vue d’ensemble

L’outil système `language detection` permet à votre agent ElevenLabs de changer sa langue de sortie pour toute langue prise en charge par l’agent.
Cet outil système n’est pas activé automatiquement. Sa description peut être personnalisée selon votre cas d’usage.

> **Note**
>
> Lorsque c’est possible, nous vous recommandons d’activer toutes les langues pour un agent et d’activer l’outil système
> de détection de la langue.

Notre outil de détection de la langue déclenche le changement de langue dans deux cas, tous deux fondés sur la langue et le contenu détectés dans l’audio reçu :

* `detection` si un utilisateur parle dans une langue différente de la langue de sortie actuelle, un changement est déclenché
* `content` si l’utilisateur demande dans la langue actuelle de passer à une nouvelle langue, un changement est déclenché

**Objectif :** basculer automatiquement vers la langue détectée de l'utilisateur au cours des conversations.

**Conditions de déclenchement :** le LLM doit appeler cet outil lorsque :

* L'utilisateur parle dans une langue différente de celle de la conversation en cours
* L'utilisateur demande explicitement à changer de langue
* La conversation nécessite la prise en charge de plusieurs langues

**Paramètres :**

* `reason` (chaîne, obligatoire) : la raison du changement de langue
* `language` (chaîne, obligatoire) : le code de langue vers lequel basculer (doit figurer dans la liste des langues prises en charge)

**Format d'appel de fonction :**

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

**Implémentation :** configurez les langues prises en charge dans les paramètres de l'agent et ajoutez l'outil système de détection de langue. L'agent basculera automatiquement la voix et les réponses pour correspondre aux langues détectées.

## Activation de la détection de la langue

#### Configurer les langues prises en charge

Les langues vers lesquelles l’agent peut basculer doivent être définies dans l’onglet des paramètres `Agent`.

![Langues de l’agent](/docs/_fern-img/633707d54276febd3baa054c4f41b186225b74f606307a46e8262607befc8381.webp)

#### Ajouter l’outil de détection de la langue

Activez la détection de la langue en ajoutant l’outil système préconfiguré aux outils de votre agent dans l’onglet `Agent`.
Cette option est automatiquement disponible lorsque vous sélectionnez `add tool`.

![Outil système](/docs/_fern-img/3d17048ab2bc1a0547c49056abb98f624caf866927ff1714af27f898b06ab18f.webp)

#### Configurer la description de l’outil

Ajoutez une description qui précise quand appeler l’outil

![Description](/docs/_fern-img/3bebc9fe07dba7121bce7793f3793858c710fc8ea1c221347604eb05929271df.webp)

## Limiter le changement au début de la conversation

Dans une longue conversation, une voix en arrière-plan ou un accent inhabituel peut occasionnellement déclencher un changement que
l’appelant n’avait pas demandé. L’activation de `only_at_conversation_start` limite les changements aux deux premiers
tours utilisateur.

Si la langue ne change pas durant ces deux tours, la détection de la langue est désactivée pour le reste
de la conversation : chaque tentative ultérieure échoue et l’agent continue de parler dans la langue actuelle. Si
la langue change pendant cette fenêtre, les changements restent disponibles pour le reste de la
conversation, afin qu’une détection incorrecte puisse toujours être corrigée.

L’option est désactivée par défaut.

#### Mettre à jour via le Dashboard

Sélectionnez l’outil **Détecter la langue** dans l’onglet **Outils**, puis activez **Uniquement au début de la conversation**.

#### Mettre à jour via la CLI

#### Récupérer la configuration de l’agent

```bash
elevenlabs agents pull
```

#### Modifier \`agent_configs/\<agent-name>.json\`

Définissez `only_at_conversation_start` sur l’outil de détection de la langue. Les champs environnants sont
omis ici par souci de concision.

```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
            }
          }
        }
      }
    }
  }
}
```

#### Envoyer vos modifications

```bash
elevenlabs agents push
```

#### Mettre à jour via l’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**
>
> Lorsqu’un changement est bloqué, l’outil renvoie une erreur au LLM en lui demandant de continuer à parler
> dans la langue actuelle. La raison n’est pas communiquée à l’appelant.

## Implémentation de l’API

Lors de la création d’un agent via l’API, vous pouvez ajouter l’outil `language detection` à la configuration de votre agent. Il doit être défini comme outil système :

```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**
>
> Laissez la description vide pour utiliser le prompt de détection de la langue par défaut.