> ## Documentation Index
> Fetch the complete documentation index at: https://avala.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Fehler-Ingest

> Senden Sie Rollouts und Fehler an Avala, und erfahren Sie, wie Avala daraus eine Fehlertaxonomie und einen Lückenbericht macht

Der Kreislauf beginnt mit dem, was Ihre Roboter tatsächlich tun. Sie senden Rollouts, einschließlich der Fehler und der Eingriffe. Avala liest sie, findet die Muster und sagt Ihnen, welche Daten fehlen.

## Formate

| Format | Wie es ankommt |
| - | - |
| MCAP | Upload als Flottenaufnahme oder `avala import folder --data-type mcap` |
| ROS-Bags (`.bag`, `.db3`) | `avala import rosbag` oder Konvertierung in MCAP und Upload als Flottenaufnahme |
| LeRobot-Datensätze | `avala import lerobot` vom Hugging Face Hub oder aus einem lokalen Verzeichnis |
| Video mit Logs | Video über `avala import folder --data-type video`. Avala gleicht die Logs als Teil des Programms mit dem Video ab. |
| Inspect-Robots-Evaluations-Logs | `avala import inspect-robots`. Siehe den Abschnitt Evaluations-Logs importieren unten. |

MCAP behält jedes Topic und liefert daher das vollständigste Bild. Der ROS-Bag-Importer konvertiert Kamera-Topics (`sensor_msgs/Image` und `sensor_msgs/CompressedImage`) und übernimmt Gelenkzustände sowie andere numerische oder Text-Topics. Punktwolken und andere binäre Nutzdaten werden übersprungen. Senden Sie MCAP, wenn jedes Topic erhalten bleiben soll.

## Rollouts als Flottenaufnahmen senden

Jeder Upload geht in eine bestehende Flottenaufnahme. Avala stellt Aufnahmen für Ihre registrierten Geräte bereit, wenn das Programm startet. Listen Sie sie auf, um die UID der Aufnahme zu finden.

```python Python theme={null}
from avala import Client

client = Client()  # reads AVALA_API_KEY

page = client.fleet.recordings.list(device_id="<device-uid>", limit=20)
for recording in page:
    print(recording.uid, recording.status, recording.started_at)

# Upload a local directory of rollout files into one recording.
session = client.fleet.uploads.upload_recording(
    "<recording-uid>",
    "./rollouts/2026-09-29",
)
print(session.uid, session.status)
```

```bash CLI theme={null}
# Preview what will be uploaded
avala fleet recordings upload \
  --source ./rollouts/2026-09-29 \
  --recording <recording-uid> \
  --dry-run

# Upload and wait for server-side processing
avala fleet recordings upload \
  --source ./rollouts/2026-09-29 \
  --recording <recording-uid> \
  --wait
```

`upload_recording` setzt einen unterbrochenen Upload derselben Quelle fort. Ein abgeschlossener Aufruf bedeutet, dass die Verarbeitung in der Warteschlange steht. Prüfen Sie `client.fleet.recordings.get(uid).status`, bis der Wert `ready` lautet.

## Fehler und Eingriffe als Events markieren

Flotten-Events versehen einen Moment in einer Aufnahme mit einem Label. Markieren Sie jeden Fehler und jeden Eingriff, damit Avala ihn schnell findet. Verwenden Sie `type` für die Event-Klasse und `metadata` für alles, was Ihr Stack protokolliert, etwa die Modellversion und die Aufgabe.

```python Python theme={null}
from avala import Client

client = Client()

event = client.fleet.events.create(
    recording="<recording-uid>",
    device="<device-uid>",
    type="anomaly",
    label="Plate slipped during placement",
    timestamp="2026-09-29T14:03:12Z",
    severity="warning",
    duration_ms=1800,
    tags=["failure", "regrasp"],
    metadata={"model_version": "your-policy@2026-09-20", "task": "load_dishwasher"},
)
print(event.uid)

# Many events at once
created = client.fleet.events.create_batch(
    events=[
        {
            "recording": "<recording-uid>",
            "device": "<device-uid>",
            "type": "state_change",
            "label": "Operator took over",
            "timestamp": "2026-09-29T14:03:15Z",
            "tags": ["intervention"],
        },
    ]
)
print(created)
```

```typescript TypeScript theme={null}
import Avala from "@avala-ai/sdk";

const avala = new Avala(); // reads AVALA_API_KEY

const event = await avala.fleet.events.create({
  recording: "<recording-uid>",
  device: "<device-uid>",
  type: "anomaly",
  label: "Plate slipped during placement",
  timestamp: "2026-09-29T14:03:12Z",
  severity: "warning",
  durationMs: 1800,
  tags: ["failure", "regrasp"],
  metadata: { model_version: "your-policy@2026-09-20", task: "load_dishwasher" },
});
console.log(event.uid);
```

```bash CLI theme={null}
avala fleet events create \
  --recording <recording-uid> \
  --device <device-uid> \
  --type anomaly \
  --label "Plate slipped during placement" \
  --timestamp 2026-09-29T14:03:12Z \
  --severity warning
```

Event-`type` ist einer von `error`, `warning`, `info`, `state_change`, `anomaly` oder `custom`. `severity` ist einer von `info`, `warning`, `error` oder `critical`. Sie können Events auch automatisch mit [Aufnahmeregeln](/docs/visualization/fleet/recording-rules.md) erstellen.

## ROS-Bags und LeRobot-Datensätze importieren

Wenn Rollouts außerhalb der Flotte liegen, importieren Sie sie als Datensatz. Installieren Sie zuerst das Extra für das Format.

```bash theme={null}
pip install "avala[rosbag]"
avala import rosbag ./rollout_0412.bag --name "Rollouts 0412" --slug rollouts-0412 --wait

pip install "avala[lerobot]"
avala import lerobot --repo-id your-hf-user/your-rollouts --name "Rollouts" --slug rollouts --wait
```

Der LeRobot-Importer ist unter [Exporte](/docs/de/fleet-learning/exports.md) ausführlich beschrieben.

## Evaluations-Logs importieren

Wenn Sie Ihre Policy mit [Inspect Robots](https://github.com/robocurve/inspect-robots) evaluieren, einem Open-Source-Evaluationswerkzeug, importieren Sie dessen JSON-Eval-Log. Jeder Versuch, also eine Szene in einer Epoche, labelt eine Sequenz mit einem [Ergebnis-Label](/docs/de/fleet-learning/sequence-metadata.md). Fehlgeschlagene Versuche werden zu Sequenzen, die Sie filtern, prüfen und in Erhebungsarbeit umsetzen können.

```bash theme={null}
pip install "avala[inspect]"

# Preview the trial-to-outcome mapping. Reads the log only.
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval --dry-run

# Label the sequences that already exist in the dataset, one per trial
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval

# Or create the dataset from each trial's recorded actions, plus camera frames if the run stored them
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval --create
```

| Inspect-Robots-Versuch | Ergebnis |
| - | - |
| Erfolgswert bei oder über `--success-threshold`, Bewertungswert bei oder über `--expert-threshold` | `expert_success` |
| Erfolgswert bei oder über `--success-threshold`, Bewertungswert unter `--expert-threshold` | `partial_success` |
| Erfolgswert unter `--success-threshold` | `failure` |
| Versuch mit Fehler beendet oder abgebrochen | `aborted` |
| Erfolgs-Scorer lieferte keinen Wert | Kein Label |

Jedes importierte Label hat `source` auf `imported`, `evaluation_membership` auf `held_out_eval` und `autonomy_level` auf `autonomous` gesetzt. `model_version` ist die Policy des Durchlaufs. Die Aufgabe des Durchlaufs wird zu einer Teilaufgabe, die den ganzen Versuch umfasst. Labels, die eine Person oder ein Modell geschrieben hat, bleiben erhalten, sofern Sie nicht `--overwrite` übergeben. Die vollständige Optionsliste steht in der [CLI-Referenz](/docs/sdks/cli.md#inspect-robots-evaluation-logs).

## Aufnahmen und Events mit dem MCP-Server prüfen

Der MCP-Server liest Flottendaten. Fragen Sie Ihren Assistenten nach aktuellen Fehlern, oder rufen Sie die Tools direkt auf:

* `fleet_list_recordings` und `fleet_get_recording` für Aufnahmen
* `fleet_list_events`, gefiltert nach `recording`, `device`, `type` oder `severity`
* `get_fleet_health` für eine flottenweite Zusammenfassung

Uploads und das Erstellen von Events laufen über das SDK oder die CLI. Siehe [Avala mit KI nutzen](/docs/de/getting-started/mcp.md) für die Verbindung.

## Was Avala mit den Rollouts macht

Die folgenden Schritte sind ein Service, den Avala als Teil des Programms erbringt. Dafür gibt es keine API, die Sie aufrufen.

1. **Segmentierung.** Avala teilt jeden Rollout an Zustandswechseln in Sequenzen und Teilaufgaben auf. Ihre Events verankern die Fehlermomente.
2. **Labeling.** Jede Sequenz erhält beide Achsen ihrer [Sequenz-Metadaten](/docs/de/fleet-learning/sequence-metadata.md): eine Prüfung der technischen Gültigkeit und ein Ergebnis-Label.
3. **Clustering.** Avala gruppiert Fehler danach, was schiefging und unter welchen Bedingungen. Die Cluster werden einer versionierten Fehlertaxonomie für Ihr Programm zugeordnet. Neue Cluster erweitern die Taxonomie.
4. **Lückenanalyse.** Avala vergleicht die Fehlercluster mit der Abdeckung Ihrer bestehenden Trainingsdaten und den Evaluationskohorten.

## Der Lückenbericht

Avala liefert für jeden Batch von Rollouts einen Lückenbericht.

| Abschnitt | Inhalt |
| - | - |
| Umfang | Aufnahmen, Zeitraum, Modellversionen und Version der Taxonomie. |
| Fehlertaxonomie | Jeder Fehlermodus, seine Definition und Beispielsequenzen. |
| Verteilung | Fehleranzahl und -raten pro Modus, pro Modellversion und pro Abdeckungszelle. |
| Fehlende Abdeckung | Die [Abdeckungszellen](/docs/de/fleet-learning/coverage.md) hinter jedem Fehlermodus, die Ihren Trainingsdaten fehlen oder dort zu dünn besetzt sind. |
| Vorgeschlagene Experimente | Ein Entwurf eines [Fähigkeitsexperiments](/docs/de/fleet-learning/capability-experiments.md) pro priorisierter Fehlerbedingung, mit einer Hypothese und Zielzellen. |

Sie prüfen den Lückenbericht und wählen die Prioritäten. Die genehmigten Experimente werden zum nächsten Erhebungsbriefing.
