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

# Echtzeitüberwachung

Die Echtzeitüberwachung ermöglicht die Live-Beobachtung von Agentenunterhaltungen über WebSocket sowie die Fernsteuerung aktiver Anrufe. Diese Funktion bietet Echtzeit-Einblick in Unterhaltungsereignisse und ermöglicht Eingriffe über Steuerbefehle.

> **Note**
>
> Diese Funktion ist nur für Enterprise verfügbar.

## Überblick

Überwachungssitzungen streamen Unterhaltungsereignisse in Echtzeit, einschließlich Transkripten, Agentenantworten und Korrekturen. Sie können auch Steuerbefehle senden, um Anrufe zu beenden, an Telefonnummern weiterzuleiten oder während aktiver Chatunterhaltungen die menschliche Übernahme zu aktivieren.

## WebSocket-Endpunkt

Verbinden Sie sich über den Überwachungsendpunkt mit einer Live-Unterhaltung:

```
wss://api.elevenlabs.io/v1/convai/conversations/{conversation_id}/monitor
```

Ersetzen Sie `{conversation_id}` durch die ID der Unterhaltung, die Sie überwachen möchten.

## Authentifizierung

Für die Authentifizierung ist Folgendes erforderlich:

* **API-Schlüsselberechtigungen**: Ihr API-Schlüssel muss den Bereich `ElevenLabs Agents Write` haben
* **Workspace-Zugriff**: Sie benötigen `EDITOR`-Zugriff auf den Workspace des Agenten
* **Header-Format**: Übermitteln Sie Ihren API-Schlüssel über den Header `xi-api-key`

### Beispielverbindung

```javascript
const ws = new WebSocket('wss://api.elevenlabs.io/v1/convai/conversations/conv_123/monitor', {
  headers: {
    'xi-api-key': 'your_api_key_here',
  },
});
```

```python
import websockets
import asyncio

async def monitor_conversation():
    uri = "wss://api.elevenlabs.io/v1/convai/conversations/conv_123/monitor"
    headers = {
        "xi-api-key": "your_api_key_here"
    }

    async with websockets.connect(uri, extra_headers=headers) as websocket:
        # Connection established
        pass
```

## Konfiguration

Aktivieren Sie die Funktion in den Einstellungen Ihres Agenten, bevor Sie Unterhaltungen überwachen:

### Zu den Agenteneinstellungen wechseln

Öffnen Sie die Konfigurationsseite Ihres Agenten im Dashboard.

### Überwachung aktivieren

Aktivieren Sie im Bereich „Erweiterte Einstellungen“ die Option „Überwachung“.

![Umschalter für die Überwachung in den Agenteneinstellungen](/docs/_fern-img/1a4b5507a39ddf6a517772b8c01ede5f7d12429175fdf89e04c8ba910f646f8e.webp)

### Ereignisse auswählen

Wählen Sie die Ereignisse aus, die Sie überwachen möchten. Eine vollständige Liste der verfügbaren Ereignisse finden Sie unter [Client-Ereignisse](/docs/de/eleven-agents/customization/events/client-events).

> **Warning**
>
> Die folgenden Ereignisse können nicht überwacht werden: VAD-Scores, Metriken für die Zugwahrscheinlichkeit und Pings.

> **Info**
>
> Die Unterhaltung muss aktiv sein, bevor Sie sich zur Überwachung verbinden können. Sie können eine
> Unterhaltung nicht überwachen, bevor sie beginnt.

## Steuerbefehle

Senden Sie JSON-Befehle über WebSocket, um die Unterhaltung zu steuern:

#### Anruf beenden

Beendet die aktive Unterhaltung sofort.

```javascript
// End the active conversation
ws.send(JSON.stringify({
  command_type: "end_call"
}));
```

```python
import json

# End the active conversation
await websocket.send(json.dumps({
    "command_type": "end_call"
}))
```

#### An Telefonnummer weiterleiten

Leitet den Anruf an eine angegebene Telefonnummer weiter.

```javascript
// Transfer to a phone number
ws.send(JSON.stringify({
  command_type: "transfer_to_number",
  parameters: {
    phone_number: "+1234567890"
  }
}));
```

```python
import json

# Transfer to a phone number
await websocket.send(json.dumps({
    "command_type": "transfer_to_number",
    "parameters": {
        "phone_number": "+1234567890"
    }
}))
```

> **Note**
>
> Das Systemtool `transfer_to_number` muss bereits im Agenten konfiguriert sein.

#### Kontextaktualisierung in Echtzeit

Fügen Sie der aktiven Unterhaltung Kontext oder Anweisungen hinzu, damit der Agent die neuen
Informationen in seinen Antworten verwenden kann.

```javascript
// Send a contextual update to the agent
ws.send(JSON.stringify({
  command_type: "contextual_update",
  parameters: {
    contextual_update: "<your update text>"
  }
}));
```

```python
import json

# Send a contextual update to the agent
await websocket.send(json.dumps({
    "command_type": "contextual_update",
    "parameters": {
        "contextual_update": "<your update text>"
    }
}))
```

#### Menschliche Übernahme aktivieren

Wechseln Sie bei Chatunterhaltungen vom KI-Agenten in den Modus für menschliche Operatoren.

```javascript
// Enable human takeover
ws.send(JSON.stringify({
  command_type: "enable_human_takeover"
}));
```

```python
import json

# Enable human takeover
await websocket.send(json.dumps({
    "command_type": "enable_human_takeover"
}))
```

#### Nachricht als Mensch senden

Senden Sie dem Nutzer in Chatunterhaltungen eine Nachricht als menschlicher Operator.

```javascript
// Send a message as a human operator
ws.send(JSON.stringify({
  command_type: "send_human_message",
  parameters: {
    text: "How can I help you?"
  }
}));
```

```python
import json

# Send a message as a human operator
await websocket.send(json.dumps({
    "command_type": "send_human_message",
    "parameters": {
        "text": "How can I help you?"
    }
}))
```

#### Menschliche Übernahme deaktivieren

Geben Sie die Steuerung vom menschlichen Operator an den KI-Agenten zurück.

```javascript
// Disable human takeover and return to AI
ws.send(JSON.stringify({
  command_type: "disable_human_takeover"
}));
```

```python
import json

# Disable human takeover and return to AI
await websocket.send(json.dumps({
    "command_type": "disable_human_takeover"
}))
```

## Anwendungsfälle

Die Echtzeitüberwachung ermöglicht mehrere operative Szenarien:

#### Qualitätssicherung

Überwachen Sie Agentenunterhaltungen in Echtzeit, um Qualitätsstandards sicherzustellen und
Schulungsmöglichkeiten zu erkennen.

#### Eskalation an Menschen

Erkennen Sie Unterhaltungen, die menschliche Intervention erfordern, und übernehmen Sie nahtlos
vom KI-Agenten.

#### Analyse-Dashboards

Erstellen Sie Dashboards zur Echtzeitüberwachung, die Unterhaltungsmetriken und Leistungsindikatoren
zusammenführen.

#### Callcenter-Aufsicht

Beaufsichtigen Sie mehrere Agentenunterhaltungen gleichzeitig und greifen Sie bei Bedarf ein.

#### Automatisierte Intervention

Implementieren Sie automatisierte Systeme, die Gesprächsinhalte analysieren und Aktionen auf Basis
bestimmter Bedingungen auslösen.

#### Training und Coaching

Nutzen Sie Live-Unterhaltungen als Schulungsmaterial und geben Sie Echtzeit-Feedback, um die Leistung
des Agenten zu verbessern.

## Einschränkungen

#### Asynchrone Ereignisübermittlung

Überwachungsereignisse werden asynchron zur Unterhaltung gesendet und treffen möglicherweise nicht in derselben
Reihenfolge wie die Kernereignisse der Unterhaltung ein. Verlassen Sie sich bei der Verarbeitung von Ereignissen nicht auf deren Reihenfolge,
um das exakte Timing der Unterhaltung zu rekonstruieren.

#### Audiodaten nicht verfügbar

Der Überwachungsendpunkt streamt nur Textereignisse und Metadaten. Rohdaten von Audio sind in
Überwachungsereignissen nicht enthalten.

#### Limit für historische Ereignisse

Beim Verbinden mit einer aktiven Unterhaltung sind nur ungefähr die letzten 100 Ereignisse im Cache gespeichert und verfügbar.
Frühere Ereignisse können nicht abgerufen werden.

#### Einschränkungen bei der Ereignisfilterung

VAD-Scores, Metriken für die Zugwahrscheinlichkeit und Ping-Ereignisse können nicht überwacht werden, wenn eine benutzerdefinierte Ereignisauswahl
aktiviert ist.

#### Zeitpunkt der Verbindung

Sie müssen sich verbinden, nachdem die Unterhaltung gestartet wurde. Der Überwachungsendpunkt kann nicht
vor Beginn der Unterhaltung verwendet werden.

#### Erforderliche Berechtigungen

API-Schlüssel müssen den Bereich `ElevenLabs Agents Write` haben, und Sie benötigen `EDITOR`-Workspace-Zugriff,
um Unterhaltungen zu überwachen.

## Verwandte Ressourcen

#### [Webhooks nach dem Anruf](/docs/de/eleven-agents/workflows/post-call-webhooks)

Erhalten Sie Unterhaltungsdaten und Analysen, nachdem Anrufe abgeschlossen sind.

#### [Agentenanalyse](/docs/de/eleven-agents/customization/agent-analysis)

Konfigurieren Sie Erfolgsauswertung und Datenerfassung für Unterhaltungen.

#### [Client-Ereignisse](/docs/de/eleven-agents/customization/events/client-events)

Verstehen Sie Ereignisse, die während dialogorientierter Anwendungen empfangen werden.

#### [WebSocket API](/docs/de/eleven-agents/libraries/web-sockets)

Erfahren Sie mehr über die WebSocket API für Echtzeitunterhaltungen.