Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

End-to-end-Pipeline: Traces, Judges, Datensätze, Evaluierungen

Lektion 16 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Der End-to-End-Observability-Workflow
  2. Python-Implementierung
  3. Kurzzusammenfassung
  4. Empfohlene nächste Schritte
  5. Wichtige Erkenntnisse
  6. Wissen testen

Lektion am 2. November 2026 neu geschrieben basierend auf der Mistral-Dokumentation zu Observability und dem mistralai SDK 3.7.0: Die Pipeline verknüpft nun Traces, Judges, Datensätze und Offline-Evaluierungen. Die Funktion „Campaigns” sowie die Methoden chat_completion_events.search, campaigns.* und import_from_explorer der vorherigen Version existieren nicht mehr. Quellen: Traces im Explorer durchsuchen · Offline-Evaluierungen.

Der End-to-End-Observability-Workflow

Sie haben nun jeden Bestandteil des Observability-Stacks von Mistral gemeistert. Diese letzte Lektion setzt die Bausteine zu einer vollständigen Pipeline zusammen, die Sie in Ihrem Produktionskontext reproduzieren und anpassen können.

1

Trace und explorieren

Aktivieren Sie Telemetrie und filtern Sie dann im Explorer die Traces der letzten 7 Tage: Fehler, Langsamkeit, verdächtige Antworten. Notieren Sie den Suchausdruck.

2

Judge

Formalisieren Sie das betreffende Qualitätskriterium in einem Judge (Klassifizierung oder Regression), der an 10 bis 20 bekannten Fällen validiert wurde.

3

Datensatz erstellen

Transformieren Sie problematische Spans in Datensätzeinträge, wobei die erwartete Ausgabe manuell korrigiert wurde.

4

Evaluieren

Messen Sie die aktuelle Version und dann jede Variante an diesem Datensatz mit PASS/FAIL-Zielen.

5

Iterieren

Bereitstellen Sie die gewinnende Variante, behalten Sie den Datensatz als Non-Regression-Schutz und wiederholen Sie den Vorgang.

Python-Implementierung

Der folgende Skript automatisiert die Schritte 1, 3 und 4; der Judge für Schritt 2 wird einmal erstellt, wie in Lektion 13 beschrieben. Zwei Clients koexistieren: Der mistralai SDK-Client für Traces und Datensätze sowie der mistralai-evaluations-Client für Evaluierungen.

import asyncio
import os
from datetime import datetime, timedelta, timezone

from mistralai.client import Mistral
from mistralai.evaluations import Dataset, Evaluation, Evaluator, Goal, Project, System
from mistralai.evaluations import Mistral as MistralEvaluations

key = os.environ["MISTRAL_API_KEY"]
api = Mistral(api_key=key)
evaluations = MistralEvaluations(api_key=key)

# 1. Fehlende Traces der Woche identifizieren
now = datetime.now(timezone.utc)
response = api.beta.observability.traces.search(
    from_=now - timedelta(days=7),
    to=now,
    search_expression="service_name = 'agent-support' AND status_code = 'Error'",
)
for trace in response.traces.results or []:
    print(trace.trace_id, trace.root_span_name)

# 3. Manuell überprüfte und korrigierte Fälle zum Datensatz hinzufügen
corrected_cases = [
    {"ticket": "Zahlung abgelehnt, obwohl meine Karte gültig ist.", "category": "billing"},
    {"ticket": "Kann keinen Kollegen zum Workspace hinzufügen.", "category": "access"},
]
dataset = api.beta.observability.datasets.create(
    name="Support-Vorfälle — Woche 44",
    description="Fälle aus fehlgeschlagenen Traces, erwartete Ausgabe korrigiert",
)
for case in corrected_cases:
    api.beta.observability.datasets.create_record(dataset_id=dataset.id, payload=case)


# 4. Kandidatenversion evaluieren (Aufgabe und Genauigkeit: siehe Lektion 14)
async def main():
    run = await evaluations.evaluation.run(
        project=Project(name="Ticket-Sortierung"),
        evaluation=Evaluation(name="Non-Regression Woche 44"),
        system=System(name="medium-prompt-v2", params={
            "model": "mistral-medium-latest",
            "system_prompt": "Klassifizieren Sie das Ticket: access, billing oder bug. Antworten Sie mit einem einzigen Wort.",
        }),
        dataset=Dataset(id=dataset.id),
        task=task,
        evaluators=[Evaluator(name="accuracy", scorer=accuracy, goal=Goal.gte(0.9))],
    )
    run.show(level="records")


asyncio.run(main())

Führen Sie dies wöchentlich aus; dieses Skript erweitert den Non-Regression-Datensatz mit echten Vorfällen, und jede Kandidatenversion muss ihre Ziele an diesem Datensatz erfüllen, bevor sie bereitgestellt wird.

Kurzzusammenfassung

Dieser Kurs hat Sie durch vier wesentliche Domänen für die AI-Produktion mit Mistral geführt:

Batch-Inferenz (Lektionen 1-4)

Sie wissen, wie Sie Millionen von Anfragen zu reduzierten Kosten verarbeiten können, unter Verwendung des JSONL-Formats, der Dateibatching und des Inline-Batching.

Vorhergesagte Ausgaben (Lektionen 5-7)

Sie wissen, wie Sie die Generierungs-Latenz durch die Bereitstellung einer Ausgabe-Vorhersage reduzieren können, insbesondere für Code- und Textbearbeitung.

Zitate und Referenzen (Lektionen 8-10)

Sie wissen, wie Sie die Antworten Ihres LLMs in verifizierte Quellen verankern, Zitate parsen und zuverlässige RAG-Pipelines erstellen.

Observability (Lektionen 11-16)

Sie wissen, wie Sie Ihre Anwendung mit OpenTelemetry verfolgen, Produktions-Traces im Explorer untersuchen, die Qualitätsbewertung mit Judges automatisieren, Datensätze erstellen und jede Version über Offline-Evaluierungen messen.

Empfohlene nächste Schritte

Der beste Weg, um diese Fähigkeiten zu festigen, besteht darin, sie in der Reihenfolge anzuwenden, die Ihrem Produktionsumgebung am meisten nützt. Beginnen Sie damit, eine Batch-Pipeline auf einem konkreten Use Case in Ihrer Organisation bereitzustellen – eine monatliche Klassifizierung, eine Kataloganreicherung –, da dies der schnellste Gewinn ist, den Sie demonstrieren können. Integrieren Sie anschließend Vorhergesagte Ausgaben überall dort, wo Ihre Tools bestehenden Code oder Dokumente bearbeiten: Die Latenzverbesserung ist innerhalb weniger Tage messbar. Fügen Sie Zitate Ihrem RAG-System hinzu, sobald Benutzer auf seine Antworten zur Entscheidungsfindung angewiesen sind. Schließlich beginnt Observability mit dem Senden von Traces, was mit einem einfachen API-Schlüssel möglich ist; der Explorer und Offline-Evaluierungen erfordern eine Enterprise-Organisation. Es ist das Enterprise-Tier, das die ersten drei Initiativen in einen kontinuierlichen Verbesserungszyklus verwandelt, anstatt einmalige Bereitstellungen.

Wichtige Erkenntnisse

  • Die Pipeline folgt dem Zyklus: Trace und explorieren, Judge, Datensatz erstellen, evaluieren, iterieren
  • Jeder Produktionsvorfall kann zu einem Testfall werden, und jede Kandidatenversion muss ihre Ziele erfüllen
  • Automatisieren Sie den Zyklus mit dem SDK (traces.search, datasets.create_record, evaluation.run) und führen Sie ihn in regelmäßigen Abständen aus
  • Die vier Domänen dieses Kurses (Batch, vorhergesagte Ausgaben, Zitate, Observability) ergänzen sich für eine robuste AI-Produktion

Wissen testen

Batch, Latenz, Zitate, Observability: Die vier Säulen der Produktion.

1. Wann ist Batch-Inferenz die richtige Wahl?

Antwort: Für hohe Volumina ohne Echtzeit-Anforderungen: asynchrone JSONL-Jobs (oder Inline bis zu 10.000 Anfragen) zu reduzierten Kosten – Klassifizierung, Anreicherung, Massengenerierung.

2. Was sind Vorhergesagte Ausgaben?

Antwort: Eine Beschleunigung, wenn die Antwort weitgehend vorhersehbar ist (Bearbeitung bestehenden Textes, Vorlagen): Sie liefern die Vorhersage, und das Modell „bezahlt” nur für die Unterschiede – die Latenz sinkt erheblich.

3. Was ermöglichen Zitate mit Reference Object?

Antwort: Verknüpfung jeder Aussage in der Antwort mit ihren Quellen in einem RAG: überprüfbare Antworten, reduzierte Halluzinationen – Vertrauen wird zu einer Produkteigenschaft.

4. Was tun Sie im Explorer?

Antwort: Suchen und untersuchen Sie Produktions-Traces – unter Verwendung einer Ausdruckssprache für service_name, status_code, duration_ns oder Span-Attribute –, um problematische Anfragen zu finden, und verwandeln Sie sie dann in Testfälle: das Rohmaterial für jede Verbesserung.

5. Wie arbeiten Judges, Datensätze und Evaluierungen zusammen?

Antwort: Judges bewerten automatisch (LLM-as-Judge), Datensätze sammeln Testfälle aus der Produktion, und Offline-Evaluierungen messen jede Version an diesen Datensätzen mit PASS/FAIL-Zielen – der Zyklus Trace → Judge → Build → Evaluate.

Die finale Pipeline des Kurses verknüpft alle vier: wirtschaftlich produzieren, schnell antworten, Antworten belegen, beobachten – reife Produktion in einem einzigen Workflow.