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

# Chattläge

> **Info**
>
> Chattläge låter dina agenter fungera som chattagenter, dvs. ha textbaserade konversationer utan
> ljudinmatning eller -utmatning. Det är användbart för att bygga chattgränssnitt, testa agenter eller när ljud
> inte behövs.

## Översikt

Det finns två huvudsakliga sätt att aktivera chattläge:

1. **Agentkonfiguration**: Konfigurera agenten för textläge när du skapar den via API:t
2. **Åsidosättningar under körning**: Använd SDK-åsidosättningar för att programmässigt framtvinga textbaserade konversationer

Den här guiden beskriver båda metoderna och hur du implementerar chattläge i olika SDK:er.

## Skapa textbaserade agenter

Konfigurera en agent för textläge för att göra det till standard för varje konversation med agenten.

#### Uppdatera via instrumentpanelen

Öppna din agent på instrumentpanelen, gå till fliken **Advanced** och aktivera reglaget **Text only**. Spara ändringarna.

#### Uppdatera via CLI

#### Hämta agentkonfigurationen

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

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

Ange `conversation_config.conversation.text_only`:

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

#### Skicka dina ändringar

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

#### Uppdatera via API:t

```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**
>
> Fullständig API-referens och alla tillgängliga konfigurationsalternativ finns i [fältet text only i dokumentationen för Create Agent API ](/docs/sv/api-reference/agents/create#request.body.conversation_config.conversation.text_only).

## Åsidosättningar under körning för textläge

Om du vill aktivera chattläge under körning med åsidosättningar (i stället för att konfigurera det på agentnivå) kan du använda åsidosättningen `textOnly` i din konversationskonfiguration:

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

Den här konfigurationen säkerställer att:

* Ingen ljudinmatning eller -utmatning används
* All kommunikation sker via textmeddelanden
* Konversationen fungerar i ett chattliknande gränssnittsläge

## Viktiga anmärkningar

> **Warning**
>
> **Viktigt**: När du använder chattläge måste du se till att händelsen/callbacken `agent_response` är
> aktiverad och korrekt konfigurerad. Annars skickas eller visas inte agentens textsvar
> för användaren.

> **Info**
>
> **Säkerhetsåsidosättningar**: När du använder åsidosättningar under körning (inte konfiguration på agentnivå) måste du
> aktivera konversationsåsidosättningarna i agentens säkerhetsinställningar. Gå till agentens
> flik **Security** och aktivera lämpliga åsidosättningar. Mer information finns i [dokumentationen om åsidosättningar ](/docs/sv/eleven-agents/customization/personalization/overrides).

### Viktiga krav

1. **Händelse för agentsvar**: Konfigurera alltid callbacken eller händelsehanteraren `agent_response` för att ta emot och visa agentens textmeddelanden.

2. **Agentkonfiguration**: Om din agent är inställd på chattläge i agentinställningarna använder den automatiskt textbaserade konversationer utan att åsidosättningen krävs.

3. **Inget ljudgränssnitt**: När du använder textläge behöver du inte konfigurera ljudgränssnitt eller begära mikrofonbehörighet.

### Exempel: Hantera agentsvar

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

## Skicka textmeddelanden

I chattläge behöver du skicka användarmeddelanden programmässigt i stället för via ljud:

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

## Fördelar med samtidighet

Chattläge ger betydande fördelar för samtidighet jämfört med röstkonversationer:

* **Högre gränser**: Konversationer med endast chatt har 25 gånger högre samtidighetsgränser än röstkonversationer
* **Separat pool**: Textkonversationer använder en dedikerad samtidighetspool, oberoende av gränserna för röstkonversationer
* **Skalbarhet**: Perfekt för applikationer med hög genomströmning, som kundsupport, chattbotar eller automatiserade tester

| Plan       | Samtidiga röstkonversationer | Samtidiga chattkonversationer |
| ---------- | ---------------------------- | ----------------------------- |
| Free       | 4                            | 100                           |
| Starter    | 6                            | 150                           |
| Creator    | 10                           | 250                           |
| Pro        | 20                           | 500                           |
| Scale      | 30                           | 750                           |
| Business   | 30                           | 750                           |
| Enterprise | Utökad                       | Utökad (25x)                  |

> **Note**
>
> När anslutningen initieras kontrolleras konversationer med endast chatt först mot din totala
> samtidighetsgräns under handskakningsprocessen och flyttas sedan till den separata samtidighetspoolen för endast chatt
> när anslutningen har upprättats.

## Användningsområden

Chattläge passar perfekt för:

* **Chattgränssnitt**: Bygga traditionella chattgränssnitt utan röst
* **Testning**: Testa agentlogik utan ljudberoenden
* **Tillgänglighet**: Erbjuda textbaserade alternativ för användare
* **Tysta miljöer**: När ljudinmatning eller -utmatning inte är lämplig
* **Integrationstestning**: Automatiserad testning av agentkonversationer

## Felsökning

### Agenten svarar inte

Om agentens svar inte visas:

1. Kontrollera att callbacken `agent_response` är korrekt konfigurerad
2. Kontrollera att agenten är konfigurerad för chattläge eller att åsidosättningen `textOnly` har angetts
3. Se till att WebSocket-anslutningen har upprättats

## Nästa steg

* Läs om [att anpassa agentbeteende](/docs/sv/eleven-agents/customization/llm)
* Utforska [klienthändelser](/docs/sv/eleven-agents/customization/events/client-events) för avancerade interaktioner
* Se [konfigurera autentisering](/docs/sv/eleven-agents/customization/authentication) för säkra konversationer