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

# Chatmodus

> **Info**
>
> Met de chatmodus kunnen je agents fungeren als chatagents, dus tekstgesprekken voeren zonder
> audio-invoer/-uitvoer. Dit is handig voor het bouwen van chatinterfaces, het testen van agents of wanneer audio
> niet nodig is.

## Overzicht

Er zijn twee manieren om de chatmodus in te schakelen:

1. **Agentconfiguratie**: Configureer je agent voor de modus met alleen tekst wanneer je deze via de API maakt
2. **Runtime-overschrijvingen**: Gebruik SDK-overschrijvingen om tekstgesprekken programmatisch af te dwingen

Deze handleiding behandelt beide benaderingen en hoe je de chatmodus implementeert in verschillende SDK's.

## Agents met alleen tekst maken

Configureer een agent voor de modus met alleen tekst om dit de standaard te maken voor elk gesprek met die agent.

#### Bijwerken via het dashboard

Open je agent in het dashboard, ga naar het tabblad **Advanced** en schakel de optie **Text only** in. Sla je wijzigingen op.

#### Bijwerken via de CLI

#### Haal de agentconfiguratie op

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

#### Bewerk \`agent\_configs/\<agent-name>.json\`

Stel `conversation_config.conversation.text_only` in:

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

#### Push je wijzigingen

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

#### Bijwerken via de API

```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**
>
> Bekijk voor de volledige API-referentie en alle beschikbare configuratieopties het [veld text only in de documentatie voor de Create Agent API ](/docs/nl/api-reference/agents/create#request.body.conversation_config.conversation.text_only).

## Runtime-overschrijvingen voor de modus met alleen tekst

Om de chatmodus tijdens runtime in te schakelen met overschrijvingen (in plaats van deze op agentniveau te configureren), kun je de overschrijving `textOnly` gebruiken in je conversatieconfiguratie:

```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,
    },
  },
});
```

Deze configuratie zorgt ervoor dat:

* Er geen audio-invoer/-uitvoer wordt gebruikt
* Alle communicatie via tekstberichten verloopt
* Het gesprek in een chatachtige interfacemodus verloopt

## Belangrijke opmerkingen

> **Warning**
>
> **Kritiek**: Wanneer je de chatmodus gebruikt, moet je ervoor zorgen dat de event/callback `agent_response` is
> geactiveerd en correct geconfigureerd. Zonder deze worden de tekstreacties van de agent niet naar de gebruiker verzonden of
> weergegeven.

> **Info**
>
> **Beveiligingsoverschrijvingen**: Wanneer je runtime-overschrijvingen gebruikt (geen configuratie op agentniveau), moet je
> de conversatieoverschrijvingen inschakelen in de beveiligingsinstellingen van je agent. Ga naar het tabblad
> **Security** van je agent en schakel de juiste overschrijvingen in. Bekijk voor meer informatie de [documentatie over overschrijvingen ](/docs/nl/eleven-agents/customization/personalization/overrides).

### Belangrijkste vereisten

1. **Agent Response-event**: Configureer altijd de callback `agent_response` of event handler om de tekstberichten van de agent te ontvangen en weer te geven.

2. **Agentconfiguratie**: Als je agent specifiek is ingesteld op de chatmodus in de agentinstellingen, gebruikt deze automatisch tekstgesprekken zonder dat de overschrijving nodig is.

3. **Geen audio-interface**: Wanneer je de modus met alleen tekst gebruikt, hoef je geen audio-interfaces te configureren of microfoonmachtigingen aan te vragen.

### Voorbeeld: reacties van agents verwerken

```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);
    }
  },
});
```

## Tekstberichten versturen

In de chatmodus moet je gebruikersberichten programmatisch versturen in plaats van via audio:

```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?",
});
```

## Voordelen voor gelijktijdigheid

De chatmodus biedt aanzienlijke voordelen voor gelijktijdigheid ten opzichte van spraakgesprekken:

* **Hogere limieten**: Gesprekken met alleen chat hebben 25x hogere limieten voor gelijktijdigheid dan spraakgesprekken
* **Afzonderlijke pool**: Tekstgesprekken gebruiken een speciale gelijktijdigheidspool, onafhankelijk van de limieten voor spraakgesprekken
* **Schaalbaarheid**: Ideaal voor toepassingen met hoge doorvoer, zoals klantenservice, chatbots of geautomatiseerd testen

| Abonnement | Gelijktijdigheid voor spraak | Gelijktijdigheid voor alleen chat |
| ---------- | ---------------------------- | --------------------------------- |
| Free       | 4                            | 100                               |
| Starter    | 6                            | 150                               |
| Creator    | 10                           | 250                               |
| Pro        | 20                           | 500                               |
| Scale      | 30                           | 750                               |
| Business   | 30                           | 750                               |
| Enterprise | Verhoogd                     | Verhoogd (25x)                    |

> **Note**
>
> Tijdens het tot stand brengen van de verbinding worden gesprekken met alleen chat eerst gecontroleerd aan de hand van je totale
> gelijktijdigheidslimiet tijdens het handshakeproces. Zodra de verbinding tot stand is gebracht, worden ze overgezet naar de afzonderlijke
> gelijktijdigheidspool voor alleen chat.

## Gebruiksscenario's

De chatmodus is ideaal voor:

* **Chatinterfaces**: Traditionele chat-UI's bouwen zonder spraak
* **Testen**: Agentlogica testen zonder afhankelijkheden van audio
* **Toegankelijkheid**: Tekstgebaseerde alternatieven bieden aan gebruikers
* **Stille omgevingen**: Wanneer audio-invoer/-uitvoer niet passend is
* **Integratietests**: Geautomatiseerd testen van gesprekken met agents

## Problemen oplossen

### Agent reageert niet

Als de reacties van de agent niet verschijnen:

1. Controleer of de callback `agent_response` correct is geconfigureerd
2. Controleer of de agent is geconfigureerd voor de chatmodus of de overschrijving `textOnly` is ingesteld
3. Zorg dat de WebSocket-verbinding succesvol tot stand is gebracht

## Volgende stappen

* Lees meer over [agentgedrag aanpassen](/docs/nl/eleven-agents/customization/llm)
* Bekijk [clientevents](/docs/nl/eleven-agents/customization/events/client-events) voor geavanceerde interacties
* Bekijk [verificatie instellen](/docs/nl/eleven-agents/customization/authentication) voor beveiligde gesprekken