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

# Mode chat

> **Info**
>
> Le mode chat permet à vos agents d’agir comme des agents de chat, c’est-à-dire de tenir des conversations uniquement textuelles, sans entrée ni sortie audio. Il est utile pour créer des interfaces de chat, tester des agents ou lorsque l’audio n’est pas nécessaire.

## Vue d’ensemble

Il existe deux principales façons d’activer le mode chat :

1. **Configuration de l’agent** : configurez votre agent en mode texte uniquement lors de sa création via l’API
2. **Remplacements au moment de l’exécution** : utilisez des remplacements SDK pour imposer des conversations uniquement textuelles par programmation

Ce guide présente les deux approches et explique comment implémenter le mode chat dans différents SDK.

## Création d’agents uniquement textuels

Configurez un agent en mode texte uniquement pour en faire le comportement par défaut de chaque conversation avec cet agent.

#### Mettre à jour via le Dashboard

Ouvrez votre agent dans le Dashboard, accédez à l’onglet **Advanced**, puis activez le bouton **Text only**. Enregistrez vos modifications.

#### Mettre à jour via la CLI

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

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

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

Définissez `conversation_config.conversation.text_only` :

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

#### Envoyer vos modifications

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

#### Mettre à jour via l’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**
>
> Pour consulter la référence complète de l’API et toutes les options de configuration disponibles, consultez le [champ text only de la documentation de l’API Create Agent](/docs/fr/api-reference/agents/create#request.body.conversation_config.conversation.text_only).

## Remplacements au moment de l’exécution pour le mode texte uniquement

Pour activer le mode chat au moment de l’exécution à l’aide de remplacements, plutôt qu’en le configurant au niveau de l’agent, vous pouvez utiliser le remplacement `textOnly` dans votre configuration de conversation :

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

Cette configuration garantit que :

* Aucune entrée ni sortie audio n’est utilisée
* Toutes les communications passent par des messages texte
* La conversation fonctionne dans un mode d’interface de type chat

## Notes importantes

> **Warning**
>
> **Critique** : lorsque vous utilisez le mode chat, vous devez vous assurer que l’événement/rappel `agent_response` est activé et correctement configuré. Sans cela, les réponses textuelles de l’agent ne seront ni envoyées ni affichées à l’utilisateur.

> **Info**
>
> **Remplacements de sécurité** : lorsque vous utilisez des remplacements au moment de l’exécution, et non une configuration au niveau de l’agent, vous devez activer les remplacements de conversation dans les paramètres de sécurité de votre agent. Accédez à l’onglet **Security** de votre agent et activez les remplacements appropriés. Pour en savoir plus, consultez la [documentation sur les remplacements](/docs/fr/eleven-agents/customization/personalization/overrides).

### Exigences clés

1. **Événement de réponse de l’agent** : configurez toujours le rappel ou gestionnaire d’événement `agent_response` afin de recevoir et d’afficher les messages texte de l’agent.

2. **Configuration de l’agent** : si votre agent est spécifiquement défini en mode chat dans les paramètres de l’agent, il utilisera automatiquement des conversations uniquement textuelles sans nécessiter de remplacement.

3. **Aucune interface audio** : en mode texte uniquement, vous n’avez pas besoin de configurer d’interfaces audio ni de demander des autorisations de microphone.

### Exemple : gérer les réponses de l’agent

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

## Envoi de messages texte

En mode chat, vous devez envoyer les messages utilisateur par programmation plutôt que par 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?",
});
```

## Avantages en matière de requêtes simultanées

Le mode chat offre d’importants avantages en matière de requêtes simultanées par rapport aux conversations vocales :

* **Limites plus élevées** : les conversations uniquement textuelles bénéficient de limites de requêtes simultanées 25 fois plus élevées que les conversations vocales
* **Pool distinct** : les conversations textuelles utilisent un pool de requêtes simultanées dédié, indépendant des limites des conversations vocales
* **Évolutivité** : idéal pour les applications à haut débit telles que le support client, les chatbots ou les tests automatisés

| Forfait    | Requêtes simultanées vocales | Requêtes simultanées en chat uniquement |
| ---------- | ---------------------------- | --------------------------------------- |
| Free       | 4                            | 100                                     |
| Starter    | 6                            | 150                                     |
| Creator    | 10                           | 250                                     |
| Pro        | 20                           | 500                                     |
| Scale      | 30                           | 750                                     |
| Business   | 30                           | 750                                     |
| Enterprise | Augmentées                   | Augmentées (25x)                        |

> **Note**
>
> Lors de l’établissement de la connexion, les conversations uniquement textuelles sont d’abord vérifiées par rapport à votre limite totale de requêtes simultanées pendant le processus de handshake, puis transférées vers le pool distinct de requêtes simultanées pour le chat une fois la connexion établie.

## Cas d’utilisation

Le mode chat est idéal pour :

* **Interfaces de chat** : créer des interfaces de chat traditionnelles sans voix
* **Tests** : tester la logique de l’agent sans dépendances audio
* **Accessibilité** : proposer des alternatives textuelles aux utilisateurs
* **Environnements silencieux** : lorsque l’entrée ou la sortie audio n’est pas appropriée
* **Tests d’intégration** : automatiser les tests des conversations de l’agent

## Résolution des problèmes

### L’agent ne répond pas

Si les réponses de l’agent n’apparaissent pas :

1. Vérifiez que le rappel `agent_response` est correctement configuré
2. Vérifiez que l’agent est configuré pour le mode chat ou que le remplacement `textOnly` est défini
3. Assurez-vous que la connexion WebSocket est établie avec succès

## Prochaines étapes

* Découvrez comment [personnaliser le comportement de l’agent](/docs/fr/eleven-agents/customization/llm)
* Explorez les [événements client](/docs/fr/eleven-agents/customization/events/client-events) pour des interactions avancées
* Consultez la [configuration de l’authentification](/docs/fr/eleven-agents/customization/authentication) pour sécuriser vos conversations