Definieren Sie Ihre Inhaltsrichtlinie

Aktualisiert am 3. November 2026. Frühere Richtlinien nutzten drei nicht existierende Kategorien (hate, violence, unpredictable) und entließen dangerous. Sie stimmen nun mit den elf Schlüsseln von mistral-moderation-2603 überein. Eine Methode wandelt eine Richtlinie nun in das offizielle Format des guardrails-Parameters um, um sicherzustellen, dass konsistente Schwellenwerte vor der Generierung angewendet werden. Quellen: Moderation & Guardrailing · mistralai SDK 3.7.0.

Warum Sie eine formale Inhaltsrichtlinie benötigen

Moderationsschwellen sind keine willkürlichen technischen Entscheidungen. Sie spiegeln eine Inhaltsrichtlinie wider – einen Satz von Regeln, der definiert, was Ihre Anwendung zulässt und verbietet. Ohne eine formale Richtlinie treffen jede Entwickler ihre eigenen Entscheidungen, und Ihr Sicherheitssystem verliert an Konsistenz: Zwei Dienste innerhalb desselben Unternehmens blockieren unterschiedliche Inhalte, ohne dass jemand weiß, warum.

Eine schriftliche Richtlinie ermöglicht es Ihnen, Moderationsentscheidungen sowohl gegenüber Nutzern als auch gegenüber Aufsichtsbehörden zu begründen, Schwellenwerte über Teams und Anwendungen hinweg zu harmonisieren, die Systemkonformität zu überprüfen und bei sich ändernden Anforderungen auf strukturierte Weise zu iterieren. Der Tag, an dem ein Nutzer eine Blockade herausfordert, ist der Unterschied zwischen „die Schwelle ist auf 0,1 gesetzt” und „unsere Public-Facing-Richtlinie v1.2 setzt diese Schwelle aus diesem Grund” enorm.

Anpassung der Schwellenwerte an den Anwendungskontext

Der gleiche Inhalt kann in einem Kontext akzeptabel und in einem anderen gefährlich sein. Ihre Richtlinie muss diese Nuancen widerspiegeln. Der beste Weg, dies zu erreichen, besteht darin, jedes Profil als benanntes, datiertes und dokumentiertes Objekt zu beschreiben, anstatt als anonymes Dictionary, das im Code verloren geht.

Für einen öffentlich zugänglichen Chatbot ist die Regel einfach: überall streng, mit Sicherheit als Priorität. Sie wissen nichts über die Person am anderen Ende, und Minderjährige könnten anwesend sein.

# Richtlinie: Streng bei allem, Sicherheit zuerst
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot, der für alle zugänglich ist, einschließlich Minderjähriger",
    "thresholds": {
        "sexual": 0.1,
        "hate_and_discrimination": 0.1,
        "violence_and_threats": 0.1,
        "dangerous": 0.1,
        "criminal": 0.1,
        "selfharm": 0.1,
        "health": 0.2,
        "financial": 0.2,
        "law": 0.2,
        "pii": 0.1,
        "jailbreaking": 0.1,
    },
    "block_action": "generic_message",
    "logging": "full"
}

Ein interner Assistent ändert das Spiel an einem Punkt: Benutzer sind authentifiziert, was bedeutet, dass sie identifizierbar und verantwortlich sind. Dies ermöglicht flexiblere Schwellenwerte, insbesondere bei financial und law, die auf 0,6 gesetzt sind, da ein Mitarbeiter, der den Assistenten nach der Struktur eines Vertrags fragt, einfach seine Arbeit erledigt.

# Richtlinie: Ausgewogen, identifizierte Benutzer
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Assistent für authentifizierte Mitarbeiter",
    "thresholds": {
        "sexual": 0.2,
        "hate_and_discrimination": 0.15,
        "violence_and_threats": 0.3,
        "dangerous": 0.2,
        "criminal": 0.15,
        "selfharm": 0.15,
        "health": 0.5,
        "financial": 0.6,
        "law": 0.6,
        "pii": 0.3,
        "jailbreaking": 0.15,
    },
    "block_action": "detailed_message",
    "logging": "full"
}

Ein spezialisiertes Werkzeug – medizinisch, rechtlich oder finanziell – führt diese Logik zu ihrem Ende: sehr permissiv innerhalb seines Bereichs, streng überall sonst. Im medizinischen Beispiel steigt health auf 0,85, da die Diskussion von Diagnosen genau die Funktion des Werkzeugs ist, während pii auf 0,15 sinkt, da Patientendaten niemals zirkulieren dürfen. Zwei Elemente, die in früheren Richtlinien fehlten, werden hier hinzugefügt: ein Blockiermodus mit Weiterleitung und eine explizite Haftungsausschluss.

# Richtlinie: Permissiv im Bereich, streng überall sonst
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Werkzeug für Gesundheitsfachkräfte",
    "thresholds": {
        "sexual": 0.2,
        "hate_and_discrimination": 0.1,
        "violence_and_threats": 0.3,
        "dangerous": 0.1,
        "criminal": 0.1,
        "selfharm": 0.3,
        "health": 0.85,    # Sehr permissiv: legitimer Bereich
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Streng: Patientendaten
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "Dieses Werkzeug ersetzt keine medizinische Beratung."
}

Formalisierung der Richtlinie als Dokument

Ihre Inhaltsrichtlinie muss ein versioniertes Dokument sein, das für alle Teams zugänglich ist. In Python übersetzt sich dies in eine Klasse, die die Versionsnummer und das Revisionsdatum neben den Schwellenwerten trägt und sowohl Scores bewerten als auch die Blockiermeldung entsprechend dem deklarierten Modus generieren kann.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Strukturierte Darstellung einer Inhaltsrichtlinie."""

    def __init__(self, config: dict):
        self.name = config["name"]
        self.description = config["description"]
        self.thresholds = config["thresholds"]
        self.block_action = config["block_action"]
        self.logging = config["logging"]
        self.version = config.get("version", "1.0.0")
        self.revision_date = config.get("revision_date", "2026-04-01")

    def evaluate(self, scores: dict) -> dict:
        """Bewertet Scores gegenüber der Richtlinie."""
        violations = []
        for cat, threshold in self.thresholds.items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })

        return {
            "policy": self.name,
            "version": self.version,
            "allowed": len(violations) == 0,
            "violations": violations
        }

    def block_message(self, violations: list) -> str:
        """Generiert eine angemessene Blockiermeldung."""
        if self.block_action == "generic_message":
            return "Dieser Inhalt kann nicht verarbeitet werden."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Inhalt wurde aus folgenden Gründen blockiert: "
                    f"{cats}. Bitte formulieren Sie Ihre Anfrage neu.")
        return "Inhalt wurde blockiert."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Übersetzt die Richtlinie in den guardrails-Parameter für die Mistral API."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

Die to_guardrails-Methode macht die Richtlinie zur einzigen Quelle der Wahrheit für Guardrails: client.chat.complete(..., guardrails=policy.to_guardrails()) oder client.beta.agents.create(..., guardrails=policy.to_guardrails()). Schwellenwerte, die vor und nach der Generierung angewendet werden, können sich nicht mehr voneinander unterscheiden.

Beachten Sie auch, dass das Ergebnis von evaluate den Namen und die Version der angewendeten Richtlinie enthält. Dieser Detail ermöglicht es Ihnen, sechs Monate später eine umstrittene Entscheidung nachzuspielen, genau unter welchem Regime sie getroffen wurde.

Verwaltung mehrerer Anwendungen

Wenn Ihr Unternehmen mehrere Anwendungen verwaltet, zentralisieren Sie die Richtlinienverwaltung. Der Manager unten tut zwei nützliche Dinge: Er lehnt explizit ab, eine Anwendung ohne deklarierte Richtlinie zu bedienen, was Bereitstellungen ohne Sicherheitsnetze verhindert, und er erstellt einen Compliance-Bericht, der die Version und das letzte Revisionsdatum jeder Anwendung auflistet – genau das, was ein Prüfer verlangen wird.

class PolicyManager:
    """Verwaltet Inhaltsrichtlinien für mehrere Anwendungen."""

    def __init__(self):
        self.policies = {}

    def register(self, app_id: str, policy: ContentPolicy):
        """Registriert eine Richtlinie für eine Anwendung."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Ruft die Richtlinie für eine Anwendung ab."""
        if app_id not in self.policies:
            raise ValueError(f"Keine Richtlinie für {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Generiert einen globalen Compliance-Bericht."""
        return {
            app_id: {
                "name": pol.name,
                "version": pol.version,
                "revision_date": pol.revision_date,
                "categories_covered": len(pol.thresholds)
            }
            for app_id, pol in self.policies.items()
        }

# Verwendung
manager = PolicyManager()
manager.register("chatbot-public",
    ContentPolicy(POLICY_PUBLIC))
manager.register("assistant-medical",
    ContentPolicy(POLICY_MEDICAL))

Revision und Aktualisierungen

Ihre Richtlinie ist nicht in Stein gemeißelt. Der häufigste Fehler besteht darin, sie einmal zu schreiben und sie dann zu vergessen. Legen Sie einen Rhythmus fest: Analysieren Sie wöchentlich falsch-positive und falsch-negative Meldungen in Ihren Protokollen; passen Sie monatlich Schwellenwerte basierend auf angesammelten Metriken an; führen Sie vierteljährlich eine vollständige Revision mit Geschäftsführung, Rechtsabteilung und Produktstakeholdern durch. Fügen Sie dazu eine nicht verhandelbare Regel hinzu: Nach jedem Vorfall führen Sie ein Post-Mortem durch und implementieren Sie eine sofortige Korrektur, ohne auf die nächste geplante Überprüfung zu warten.

Kernaussagen

• Eine Inhaltsrichtlinie übersetzt Ihre technischen Schwellenwerte in Geschäftsregeln
• Passen Sie Schwellenwerte an den Kontext an: öffentlich zugängliche, interne, spezialisierte Anwendungen
• Formalisieren Sie die Richtlinie in einem versionierten Dokument
• Zentralisieren Sie die Verwaltung, wenn Sie mehrere Anwendungen haben
• Revidieren Sie regelmäßig – die Richtlinie muss sich mit Ihrem Produkt weiterentwickeln