Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Compliance und Prüfpfad

Lektion 22 von 22 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Compliance und Prüfpfad
  2. Warum ein Prüfpfad?
  3. Struktur einer Audit-Eintragung
  4. Komplettes Audit-System
  5. Abfragen des Audits
  6. Aufbewahrung und Archivierung
  7. Europäischer AI Act: Was ändert sich
  8. Compliance-Checkliste
  9. Kernaussagen
  10. Wissen testen

Compliance und Prüfpfad

Für KI-Anwendungen in der Produktion ist Rückverfolgbarkeit unerlässlich. Ein vollständiger Prüfpfad schützt Sie bei einer Inspektion, einem Streitfall oder einem Vorfall. Diese Lektion zeigt Ihnen, wie Sie ein robustes Audit-System implementieren, indem Sie am Ende des Kurses alles, was Sie bisher aufgebaut haben – Protokollierung, Moderation und Datenschutz – in einem einzigen, verteidigbaren Rahmen zusammenführen.

Warum ein Prüfpfad?

Vier unterschiedliche Bedürfnisse treffen auf dieselbe Infrastruktur. Erstens regulatorische Compliance: Die DSGVO, der europäische KI-Gesetzgeber (AI Act) und branchenspezifische Standards verlangen von Ihnen, nachzuweisen, was Ihr System tut. Eine Demonstration ohne Protokolle ist wertlos. Zweitens Rückverfolgbarkeit im strengen Sinne – zu wissen, wer was wann getan hat und mit welchem Ergebnis, selbst sechs Monate später. Das Debugging profitiert täglich davon, da das Verständnis unerwarteten Modellverhaltens die Wiederherstellung der exakten Bedingungen des Aufrufs erfordert. Schließlich Verantwortlichkeit: Die Dokumentation von Entscheidungen, die von der KI getroffen wurden, ermöglicht es Ihnen, wenn der Zeitpunkt kommt, nachzuweisen, dass eine angefochtene Empfehlung auf einem kontrollierten Prozess beruhte.

Struktur einer Audit-Eintragung

Der folgende dataclass ist sowohl ein Vertrag als auch eine Datenstruktur. Er gruppiert Identifikatoren, Anwendungskontext, die Anfrage, die Antwort, das Moderationsergebnis und technische Metadaten. Zwei Entscheidungen verdienen Ihre Aufmerksamkeit. Die Benutzer-ID erscheint nur in gehashter Form, niemals im Klartext. Und der Prompt wird nicht gespeichert: nur sein Hash und seine Länge. Dies bewahrt Ihre Fähigkeit, nachzuweisen, dass zwei Aufrufe denselben Inhalt betrafen, ohne jemals ein Archiv dessen zu erstellen, was Ihre Benutzer geschrieben haben.

from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib

@dataclass
class AuditRecord:
    """Audit record for an API call."""
    # Identifiers
    audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

    # Context
    user_id_hash: str = ""  # Never the plain ID
    session_id: str = ""
    application: str = ""

    # Request (no sensitive data)
    model: str = ""
    prompt_hash: str = ""  # Hash of the prompt, not the prompt itself
    prompt_length: int = 0

    # Response
    response_id: str = ""
    output_length: int = 0
    input_tokens: int = 0
    output_tokens: int = 0

    # Moderation
    input_flagged: bool = False
    output_flagged: bool = False

    # Metadata
    duration_ms: int = 0
    status: str = "success"
    error: Optional[str] = None

    def to_json(self) -> str:
        return json.dumps(asdict(self), ensure_ascii=False)

Komplettes Audit-System

Der Client, der diese Struktur nutzt, verknüpft Eingangsmoderation, API-Aufruf, Ausgangsmoderation und schreibt in jedem Fall. Das wichtige Wort ist append-only: Die JSONL-Datei wird im Anhängemodus geöffnet, niemals neu geschrieben, was die Bedingung ist, damit ein Protokoll Beweiskraft besitzt. Beachten Sie den Pfad einer markierten Eintragung – die Eintragung wird vor dem Werfen der Ausnahme gespeichert, mit dem Status blocked_input. Ein Block hinterlässt also eine Spur genau wie ein Erfolg, und der finale except-Block garantiert, dass kein Fehler, unabhängig von seinem Ursprung, unter dem Radar bleibt.

import time
from openai import OpenAI

class AuditedClient:
    """OpenAI client with integrated audit trail."""

    def __init__(self, application: str, audit_store: str = "audit.jsonl"):
        self.client = OpenAI()
        self.application = application
        self.audit_store = audit_store

    def _hash(self, text: str) -> str:
        """Truncated SHA-256 hash for auditing."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Saves an audit record (append-only)."""
        with open(self.audit_store, "a", encoding="utf-8") as f:
            f.write(record.to_json() + "\n")

    def create(self, user_id: str, session_id: str,
               model: str, input: str, **kwargs) -> object:
        """API call with automatic auditing."""

        record = AuditRecord(
            user_id_hash=self._hash(user_id),
            session_id=session_id,
            application=self.application,
            model=model,
            prompt_hash=self._hash(input),
            prompt_length=len(input),
        )

        start = time.monotonic()

        try:
            # Input moderation
            mod = self.client.moderations.create(
                model="omni-moderation-latest",
                input=input
            )
            record.input_flagged = mod.results[0].flagged

            if record.input_flagged:
                record.status = "blocked_input"
                self._save_audit(record)
                raise ValueError("Inappropriate input content")

            # API call
            response = self.client.responses.create(
                model=model,
                input=input,
                **kwargs
            )

            # Output moderation
            mod_out = self.client.moderations.create(
                model="omni-moderation-latest",
                input=response.output_text
            )
            record.output_flagged = mod_out.results[0].flagged

            # Fill metrics
            record.response_id = response.id
            record.output_length = len(response.output_text)
            record.input_tokens = response.usage.input_tokens
            record.output_tokens = response.usage.output_tokens
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "success"

            self._save_audit(record)
            return response

        except Exception as e:
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "error"
            record.error = type(e).__name__
            self._save_audit(record)
            raise

# Usage
audited = AuditedClient(application="support-chatbot")

response = audited.create(
    user_id="[email protected]",
    session_id="sess-abc123",
    model="gpt-5.6-terra",
    input="How do I return a product?"
)
print(response.output_text)

In diesem Beispiel erreicht die als user_id übergebene E-Mail-Adresse niemals die Datei: Sie wird gehasht, sobald die Eintragung erstellt wird. Eine JSONL-Datei funktioniert gut, um zu beginnen und für eine einzelne Instanz; sobald mehrere Prozesse parallel schreiben, leiten Sie diesen Stream an eine Datenbank oder einen Protokollsammler weiter.

Abfragen des Audits

Ein Protokoll, das nicht abgefragt werden kann, dient nur dazu, Festplattenspeicher zu belegen. Die Zeile-für-Zeile-Lesung des JSONL-Formats macht die Auswertung trivial, und der folgende Bericht fasst den abgedeckten Zeitraum, die Verteilung zwischen Erfolgen, Fehlern und Blockaden, den Tokenverbrauch und die durchschnittliche Latenz zusammen. Die Anzahl der eindeutigen Benutzer stützt sich auf Hashes, was beiläufig beweist, dass ein pseudonymisiertes Protokoll vollständig analysierbar bleibt.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Reads all audit records."""
    records = []
    try:
        with open(file, "r", encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    records.append(json.loads(line))
    except FileNotFoundError:
        pass
    return records

def audit_report(file: str = "audit.jsonl") -> dict:
    """Generates an audit report."""
    records = read_audit(file)

    if not records:
        return {"message": "No records"}

    total = len(records)
    errors = sum(1 for r in records if r["status"] == "error")
    blocked = sum(1 for r in records if r["status"] == "blocked_input")
    tokens_total = sum(
        r.get("input_tokens", 0) + r.get("output_tokens", 0)
        for r in records
    )
    durations = [r["duration_ms"] for r in records if r["duration_ms"] > 0]

    return {
        "period": {
            "start": records[0]["timestamp"],
            "end": records[-1]["timestamp"],
        },
        "total_calls": total,
        "successes": total - errors - blocked,
        "errors": errors,
        "moderation_blocks": blocked,
        "tokens_consumed": tokens_total,
        "avg_latency_ms": round(sum(durations) / max(len(durations), 1)),
        "unique_users": len(set(r["user_id_hash"] for r in records)),
    }

print(json.dumps(audit_report(), indent=2, ensure_ascii=False))

Aufbewahrung und Archivierung

Die unendliche Aufbewahrung von Daten widerspricht dem Prinzip der Speicherbegrenzung; ein zu frühes Löschen beraubt Sie des Beweises, den Sie möglicherweise benötigen. Rotation löst dieses Dilemma: Jenseits einer von Ihnen festgelegten Dauer – hier 90 Tage – verlassen Einträge die aktive Datei für ein datiertes Archiv, während das aktuelle Protokoll nur mit den jüngsten neu geschrieben wird. Planen Sie diese Funktion als periodische Aufgabe und richten Sie retention_days auf die von Ihrem Rechtsberater genehmigte Richtlinie aus, nicht auf einen zufälligen Wert.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Archives and purges old records."""
    records = read_audit(file)
    limit = datetime.now() - timedelta(days=retention_days)

    recent = []
    archives = []

    for record in records:
        date_record = datetime.fromisoformat(record["timestamp"])
        if date_record > limit:
            recent.append(record)
        else:
            archives.append(record)

    if archives:
        # Archive old ones
        archive_name = f"audit_archive_{datetime.now().strftime('%Y%m%d')}.jsonl"
        with open(archive_name, "w", encoding="utf-8") as f:
            for record in archives:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        # Rewrite main file with recent ones
        with open(file, "w", encoding="utf-8") as f:
            for record in recent:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        print(f"Archived {len(archives)} records to {archive_name}")
        print(f"Kept {len(recent)} recent records")

Europäischer AI Act: Was ändert sich

Der Europäische AI Act (AI Act) verhängt Verpflichtungen basierend auf dem Risikostufe Ihrer Anwendung. Die Logik ist gestuft: Je stärker Ihr System auf das Leben der Menschen einwirkt, desto strenger sind die Anforderungen. Ein FAQ-Chatbot, eine Zusammenfassung oder eine Übersetzung fällt unter minimales Risiko und erfordert nur grundlegende Transparenz. Sobald es um Konversation oder Sentiment-Analyse geht, wechseln Sie zum begrenzten Risiko, mit der Verpflichtung, den Benutzer zu informieren, dass er mit einer KI interagiert. Der Sprung ist abrupt für hohes Risiko – Bonitätsprüfung, Recruiting, medizinische Diagnose – wo Konformitätsbewertung, Risikomanagement, Dokumentation der Trainingsdaten, vollständige Rückverfolgbarkeit, menschliche Aufsicht und Nachweis der Genauigkeit hinzukommen. Bestimmte Anwendungen, wie soziale Bewertung oder subliminale Manipulation, sind rein verboten.

# Assess the risk level of your application
RISK_LEVELS = {
    "minimal": {
        "examples": ["FAQ chatbot", "text summary", "translation"],
        "obligations": ["Basic transparency"]
    },
    "limited": {
        "examples": ["customer service chatbot", "sentiment analysis"],
        "obligations": ["Inform the user they are interacting with an AI"]
    },
    "high": {
        "examples": ["credit scoring", "recruitment", "medical diagnosis"],
        "obligations": [
            "Conformity assessment",
            "Risk management system",
            "Documented training data",
            "Logging and complete traceability",
            "Mandatory human supervision",
            "Demonstrated accuracy and robustness"
        ]
    },
    "unacceptable": {
        "examples": ["social scoring", "subliminal manipulation"],
        "obligations": ["PROHIBITED"]
    }
}

Situieren Sie Ihr Projekt ehrlich in diesem Raster, bevor Sie die erste Zeile Code schreiben: Eine als hohes Risiko eingestufte Anwendung verhängt architektonische Zwänge – erschöpfende Protokollierung, menschliche Kontrollpunkte –, die nicht nachträglich an ein System angefügt werden können, das ohne sie entworfen wurde.

Compliance-Checkliste

  • Append-only-Prüfpfad mit Zeitstempel
  • Hash von personenbezogenen Daten in Protokollen (niemals im Klartext)
  • Systematische Moderation von Eingängen und Ausgängen
  • Auf dem neuesten Stand befindliches Verzeichnis der Verarbeitungstätigkeiten gemäß DSGVO
  • Definierte Aufbewahrungs- und Archivrichtlinie
  • Bewertung der Risikostufe gemäß AI Act durchgeführt
  • Benutzer informiert, dass sie mit einer KI interagieren
  • Menschliche Aufsicht für einschneidende Entscheidungen

Kernaussagen

  • Ein Prüfpfad ist verpflichtend für die regulatorische Compliance
  • Protokollieren Sie im append-only-Modus: Modifizieren Sie niemals bestehende Einträge
  • Hashen Sie alle personenbezogenen Daten in Audit-Protokollen
  • Der Europäische AI Act stuft Anwendungen nach Risikostufe ein
  • Implementieren Sie automatische Moderation UND menschliche Aufsicht
  • Definieren Sie eine Aufbewahrungsrichtlinie und archivieren Sie regelmäßig

Wissen testen

Zwölf API-Lektionen: Validieren Sie die Mechanismen, die die Produktion zusammenhalten.

1. Warum migrieren Sie zur Responses API statt bei Chat Completions zu bleiben?

Antwort: Es ist die moderne API von OpenAI: integrierte Verwaltung des Gesprächszustands, native Tools und eine Evolution, die sich darauf konzentriert – Chat Completions bleibt unterstützt, ist aber veraltet.

2. Wie entscheiden Sie auf der API-Seite zwischen Sol, Terra und Luna?

Antwort: gpt-5.6-sol für anspruchsvolle Aufgaben, terra für das Gleichgewicht aus Kosten und Qualität, luna für wirtschaftliche Volumen – und das Reasoning-Level (none→max) wird dann pro Anfrage angepasst.

3. Was garantiert Strukturierte Ausgabe?

Antwort: Ausgabe, die dem bereitgestellten JSON-Schema entspricht – Felder, Typen, Struktur – die von einem Programm ohne defensives Parsen oder Reparatur ausgenutzt werden kann.

4. Was tun Sie angesichts eines 429-Fehlers?

Antwort: Respektieren Sie Rate Limits: Wiederholen Sie mit exponentiellem Backoff (und Jitter), begrenzen Sie die Versuche und planen Sie einen Circuit Breaker ein – niemals einen sofortigen Wiederholungsloop.

5. Nennen Sie zwei unverzichtbare Schutzmaßnahmen auf der Anwendungssicherheitsebene.

Antwort: Moderation von eingehendem und ausgehendem Inhalt über die dedizierte API und Verteidigung gegen Prompt-Injection: Trennen Sie Anweisungen von Daten, validieren Sie Ausgaben und begrenzen Sie exponierte Fähigkeiten.

Produktion, Sicherheit, Compliance: Die letzten drei Blöcke des Kurses machen den Unterschied zwischen einem Prototyp und einem Service – halten Sie sie als Checkliste.