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

# Wykrywanie języka

## Przegląd

Narzędzie systemowe `language detection` pozwala agentowi ElevenLabs przełączyć język odpowiedzi na dowolny język obsługiwany przez agenta.
To narzędzie systemowe nie jest włączane automatycznie. Jego opis możesz dostosować do swojego przypadku użycia.

> **Note**
>
> Gdy to możliwe, zalecamy włączyć dla agenta wszystkie języki oraz narzędzie systemowe
> wykrywania języka.

Nasze narzędzie wykrywania języka uruchamia zmianę języka w dwóch przypadkach, oba zależą od wykrytego języka i treści odebranego audio:

* `detection` — jeśli użytkownik mówi w języku innym niż obecny język odpowiedzi, nastąpi przełączenie
* `content` — jeśli użytkownik poprosi w obecnym języku o zmianę na nowy język, nastąpi przełączenie

**Cel**: Automatyczne przełączanie na wykryty język użytkownika podczas rozmowy.

**Warunki wywołania**: LLM powinien wywołać to narzędzie, gdy:

* Użytkownik mówi w języku innym niż bieżący język rozmowy
* Użytkownik wyraźnie prosi o zmianę języka
* Rozmowa wymaga obsługi wielu języków

**Parametry**:

* `reason` (string, wymagany): Powód zmiany języka
* `language` (string, wymagany): Kod języka, na który ma nastąpić przełączenie (musi znajdować się na liście obsługiwanych języków)

**Format wywołania funkcji**:

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

**Wdrożenie**: Skonfiguruj obsługiwane języki w ustawieniach agenta i dodaj narzędzie systemowe wykrywania języka. Agent automatycznie zmieni głos i odpowiedzi, aby pasowały do wykrytych języków.

## Włączanie wykrywania języka

#### Skonfiguruj obsługiwane języki

Języki, na które agent może się przełączać, musisz zdefiniować na karcie ustawień `Agent`.

![Języki agenta](/docs/_fern-img/633707d54276febd3baa054c4f41b186225b74f606307a46e8262607befc8381.webp)

#### Dodaj narzędzie wykrywania języka

Włącz wykrywanie języka, dodając do narzędzi agenta gotowe narzędzie systemowe na karcie `Agent`.
Opcja jest dostępna automatycznie po wybraniu `add tool`.

![Narzędzie systemowe](/docs/_fern-img/3d17048ab2bc1a0547c49056abb98f624caf866927ff1714af27f898b06ab18f.webp)

#### Skonfiguruj opis narzędzia

Dodaj opis określający, kiedy wywołać narzędzie

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

## Ograniczanie przełączania do początku rozmowy

W długiej rozmowie mowa w tle lub nietypowy akcent mogą czasem wywołać zmianę, której
rozmówca nie zamierzał. Włączenie `only_at_conversation_start` ogranicza przełączanie do dwóch pierwszych
wypowiedzi użytkownika.

Jeśli język nie zmieni się podczas tych dwóch wypowiedzi, wykrywanie języka zostanie wyłączone do końca
rozmowy: każda późniejsza próba się nie powiedzie, a agent będzie nadal mówił w obecnym języku. Jeśli
język zmieni się w tym czasie, przełączanie pozostanie dostępne do końca
rozmowy, więc błędne wykrycie nadal można poprawić.

Opcja jest domyślnie wyłączona.

#### Aktualizacja w panelu

Wybierz narzędzie **Detect language** na karcie **Tools** i włącz **Only at start of conversation**.

#### Aktualizacja przez CLI

#### Pobierz konfigurację agenta

```bash
elevenlabs agents pull
```

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

Ustaw `only_at_conversation_start` w narzędziu wykrywania języka. Dla zwięzłości
pominięto otaczające pola.

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

#### Wyślij zmiany

```bash
elevenlabs agents push
```

#### Aktualizacja przez 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**
>
> Gdy przełączenie jest zablokowane, narzędzie zwraca do LLM błąd z instrukcją, by nadal mówił
> w obecnym języku. Rozmówca nie widzi powodu.

## Implementacja API

Podczas tworzenia agenta przez API możesz dodać narzędzie `language detection` do konfiguracji agenta. Powinno być zdefiniowane jako narzędzie systemowe:

```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**
>
> Pozostaw opis pusty, aby użyć domyślnego promptu wykrywania języka.