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

# Chat-Modus

> **Info**
>
> Im Chat-Modus können Ihre Agents als Chat-Agents agieren, also reine Textgespräche ohne
> Audioein- oder -ausgabe führen. Das ist nützlich, um Chat-Oberflächen zu erstellen, Agents zu testen oder wenn Audio
> nicht erforderlich ist.

## Überblick

Es gibt zwei Hauptwege, um den Chat-Modus zu aktivieren:

1. **Agent-Konfiguration**: Konfigurieren Sie Ihren Agent beim Erstellen über die API für den reinen Textmodus
2. **Laufzeitüberschreibungen**: Verwenden Sie SDK-Überschreibungen, um reine Textgespräche programmatisch zu erzwingen

Dieser Leitfaden behandelt beide Ansätze und die Implementierung des Chat-Modus in verschiedenen SDKs.

## Reine Text-Agents erstellen

Konfigurieren Sie einen Agent für den reinen Textmodus, um ihn als Standard für jedes Gespräch mit diesem Agent festzulegen.

#### Über das Dashboard aktualisieren

Öffnen Sie Ihren Agent im Dashboard, navigieren Sie zum Tab **Advanced** und aktivieren Sie den Schalter **Text only**. Speichern Sie Ihre Änderungen.

#### Über die CLI aktualisieren

#### Agent-Konfiguration abrufen

```bash
elevenlabs agents pull --agent "<agent-name>"
```

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

Legen Sie `conversation_config.conversation.text_only` fest:

```json
{
  "conversation_config": {
    "conversation": {
      "text_only": true
    }
  }
}
```

#### Änderungen übertragen

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

#### Über die API aktualisieren

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "conversation": {"text_only": True},
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    conversation: { textOnly: true },
  },
});
```

> **Info**
>
> Die vollständige API-Referenz und alle verfügbaren Konfigurationsoptionen finden Sie im [Feld text only der Create-Agent-API- Dokumentation](/docs/de/api-reference/agents/create#request.body.conversation_config.conversation.text_only).

## Laufzeitüberschreibungen für den reinen Textmodus

Um den Chat-Modus zur Laufzeit über Überschreibungen zu aktivieren, statt ihn auf Agent-Ebene zu konfigurieren, können Sie die Überschreibung `textOnly` in Ihrer Gesprächskonfiguration verwenden:

```python
from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import Conversation, ConversationInitiationData

# Configure for text-only mode with proper structure
conversation_override = {
    "conversation": {
        "text_only": True
    }
}

config = ConversationInitiationData(
    conversation_config_override=conversation_override
)

conversation = Conversation(
    elevenlabs,
    agent_id,
    requires_auth=bool(api_key),
    config=config,
    # Important: Ensure agent_response callback is set
    callback_agent_response=lambda response: print(f"Agent: {response}"),
    callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
)

conversation.start_session()
```

```javascript
const conversation = await Conversation.startSession({
  agentId: "<your-agent-id>",
  overrides: {
    conversation: {
      textOnly: true,
    },
  },
});
```

Diese Konfiguration stellt Folgendes sicher:

* Es wird keine Audioein- oder -ausgabe verwendet
* Die gesamte Kommunikation erfolgt über Textnachrichten
* Das Gespräch läuft im Modus einer chatähnlichen Oberfläche

## Wichtige Hinweise

> **Warning**
>
> **Kritisch**: Bei Verwendung des Chat-Modus müssen Sie sicherstellen, dass das Ereignis bzw. der Callback `agent_response`
> aktiviert und korrekt konfiguriert ist. Andernfalls werden die Textantworten des Agents nicht an den Benutzer gesendet oder
> angezeigt.

> **Info**
>
> **Sicherheitsüberschreibungen**: Bei Verwendung von Laufzeitüberschreibungen, nicht einer Konfiguration auf Agent-Ebene, müssen Sie
> die Gesprächsüberschreibungen in den Sicherheitseinstellungen Ihres Agents aktivieren. Navigieren Sie zum Tab
> **Security** Ihres Agents und aktivieren Sie die passenden Überschreibungen. Weitere Informationen finden Sie in der [Dokumentation zu Überschreibungen ](/docs/de/eleven-agents/customization/personalization/overrides).

### Zentrale Anforderungen

1. **Agent-Antwortereignis**: Konfigurieren Sie stets den Callback oder Event-Handler `agent_response`, um die Textnachrichten des Agents zu empfangen und anzuzeigen.

2. **Agent-Konfiguration**: Wenn Ihr Agent in den Agent-Einstellungen speziell auf Chat-Modus eingestellt ist, verwendet er automatisch reine Textgespräche, ohne dass eine Überschreibung erforderlich ist.

3. **Keine Audiooberfläche**: Bei Verwendung des reinen Textmodus müssen Sie keine Audiooberflächen konfigurieren oder Mikrofonberechtigungen anfordern.

### Beispiel: Agent-Antworten verarbeiten

```python
def handle_agent_response(response):
    """Critical handler for displaying agent messages"""
    print(f"Agent: {response}")  # Update your UI with the response
    update_chat_ui(response)

config = ConversationInitiationData(
    conversation_config_override={"conversation": {"text_only": True}}
)

conversation = Conversation(
  elevenlabs,
  agent_id,
  config=config,
  callback_agent_response=handle_agent_response,
)

conversation.start_session()
```

```javascript
const conversation = await Conversation.startSession({
  agentId: "<your-agent-id>",
  overrides: {
    conversation: {
      textOnly: true,
    },
  },
  // Critical: Handle agent responses
  onMessage: (message) => {
    if (message.type === "agent_response") {
      console.log("Agent:", message.text);
      // Display in your UI
      displayAgentMessage(message.text);
    }
  },
});
```

## Textnachrichten senden

Im Chat-Modus müssen Sie Benutzernachrichten programmatisch statt über Audio senden:

```python
# Send a text message to the agent
conversation.send_user_message("Hello, how can you help me today?")
```

```javascript
// Send a text message to the agent
conversation.sendUserMessage({
  text: "Hello, how can you help me today?",
});
```

## Vorteile bei der Parallelität

Der Chat-Modus bietet gegenüber Sprachgesprächen deutliche Vorteile bei der Parallelität:

* **Höhere Limits**: Reine Chat-Gespräche haben 25-mal höhere Parallelitätslimits als Sprachgespräche
* **Separater Pool**: Textgespräche verwenden einen dedizierten Parallelitätspool, unabhängig von den Limits für Sprachgespräche
* **Skalierbarkeit**: Ideal für Anwendungen mit hohem Durchsatz wie Kundensupport, Chatbots oder automatisierte Tests

| Plan       | Sprachparallelität | Reine Chat-Parallelität |
| ---------- | ------------------ | ----------------------- |
| Free       | 4                  | 100                     |
| Starter    | 6                  | 150                     |
| Creator    | 10                 | 250                     |
| Pro        | 20                 | 500                     |
| Scale      | 30                 | 750                     |
| Business   | 30                 | 750                     |
| Enterprise | Erhöht             | Erhöht (25x)            |

> **Note**
>
> Während des Verbindungsaufbaus werden reine Chat-Gespräche zunächst während des Handshake-Prozesses anhand Ihres gesamten
> Parallelitätslimits geprüft und nach Herstellung der Verbindung in den separaten Pool für reine Chat-Gespräche
> übertragen.

## Anwendungsfälle

Der Chat-Modus ist ideal für:

* **Chat-Oberflächen**: Klassische Chat-UIs ohne Sprache erstellen
* **Tests**: Agent-Logik ohne Audioabhängigkeiten testen
* **Barrierefreiheit**: Textbasierte Alternativen für Benutzer bereitstellen
* **Stille Umgebungen**: Wenn Audioein- oder -ausgabe nicht geeignet ist
* **Integrationstests**: Automatisierte Tests von Agent-Gesprächen

## Fehlerbehebung

### Agent antwortet nicht

Wenn die Antworten des Agents nicht angezeigt werden:

1. Prüfen Sie, ob der Callback `agent_response` korrekt konfiguriert ist
2. Prüfen Sie, ob der Agent für den Chat-Modus konfiguriert ist oder die Überschreibung `textOnly` festgelegt wurde
3. Stellen Sie sicher, dass die WebSocket-Verbindung erfolgreich hergestellt wurde

## Nächste Schritte

* Erfahren Sie mehr über die [Anpassung des Agent-Verhaltens](/docs/de/eleven-agents/customization/llm)
* Entdecken Sie [Client-Ereignisse](/docs/de/eleven-agents/customization/events/client-events) für erweiterte Interaktionen
* Informationen zu sicheren Gesprächen finden Sie unter [Authentifizierung einrichten](/docs/de/eleven-agents/customization/authentication)