Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Definieer uw inhoudsbeleid

Les 9 van 12 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Waarom u een formeel inhoudsbeleid nodig hebt
  2. Drempelwaarden afstemmen op de applicatiecontext
  3. Het beleid formaliseren als document
  4. Beheer van meerdere applicaties
  5. Revisie en updates
  6. Belangrijkste punten

Bijgewerkt op 3 november 2026. Eerdere beleidslijnen gebruikten drie niet-bestaande categorieën (hate, violence, unpredictable) en lieten dangerous weg. Ze sluiten nu aan bij de elf sleutels uit mistral-moderation-2603. Een methode zet een beleid nu om naar het officiële guardrails-parameterformaat, zodat consistente drempelwaarden worden toegepast vóór de generatie. Bronnen: Moderatie & Guardrailing · mistralai SDK 3.7.0.

Waarom u een formeel inhoudsbeleid nodig hebt

Moderatiedrempels zijn geen willekeurige technische keuzes. Ze weerspiegelen een inhoudsbeleid: een set regels die definieert wat uw applicatie toestaat en verbiedt. Zonder een formeel beleid neemt elke ontwikkelaar zijn eigen beslissingen, en verliest uw beveiligingssysteem zijn consistentie: twee diensten binnen hetzelfde bedrijf blokkeren uiteindelijk verschillende inhoud, zonder dat iemand weet waarom.

Een schriftelijk beleid stelt u in staat om moderatiebeslissingen te verantwoorden tegenover zowel gebruikers als toezichthouders, drempelwaarden te harmoniseren tussen teams en applicaties, de naleving van het systeem te auditeren, en gestructureerd te itereren naarmate de behoeften veranderen. De dag dat een gebruiker een blokkering aanvecht, is het verschil tussen “de drempelwaarde staat op 0,1” en “ons Publiek Beleid v1.2 stelt deze drempelwaarde om deze reden” enorm.

Drempelwaarden afstemmen op de applicatiecontext

Dezelfde inhoud kan in de ene context acceptabel zijn en in de andere gevaarlijk. Uw beleid moet deze nuances weerspiegelen. De beste manier om dit te bereiken, is door elk profiel te beschrijven als een benoemd, gedateerd en gedocumenteerd object, in plaats van een anoniem dictionary dat verloren raakt in de code.

Voor een publiek toegankelijke chatbot is de regel simpel: overal streng, met veiligheid als prioriteit. U weet niets over de persoon aan de andere kant en minderjarigen kunnen aanwezig zijn.

# Policy: Strict on everything, safety first
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot accessible to all, including minors",
    "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"
}

Een interne assistent verandert het spel op één punt: gebruikers zijn geauthenticeerd, wat betekent dat ze identificeerbaar en aansprakelijk zijn. Dit allows voor flexibelere drempelwaarden, met name voor financial en law ingesteld op 0,6, aangezien een medewerker die de assistent vraagt naar een contractstructuur gewoon zijn werk doet.

# Policy: Balanced, identified users
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Assistant for authenticated employees",
    "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"
}

Een gespecialiseerde tool—medisch, juridisch of financieel—voert deze logica tot het uiterste: zeer permissief binnen het eigen domein, streng overal elders. In het medische voorbeeld stijgt health naar 0,85 omdat het bespreken van diagnoses precies de functie van de tool is, terwijl pii daalt naar 0,15 omdat patiëntgegevens nooit mogen circuleren. Twee elementen die ontbraken in eerdere beleidslijnen, worden hier toegevoegd: een blokkeermodus met omleiding en een expliciete disclaimer.

# Policy: Permissive on domain, strict elsewhere
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Tool for healthcare professionals",
    "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,    # Very permissive: legitimate domain
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Strict: patient data
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "This tool does not replace medical advice."
}

Het beleid formaliseren als document

Uw inhoudsbeleid moet een geversioneerd document zijn dat toegankelijk is voor alle teams. In Python vertaalt zich dit naar een klasse die het versienummer en de revisiedatum meedraagt naast de drempelwaarden, en die zowel scores kan evalueren als het blokkeerbericht kan genereren dat overeenkomt met de gedeclareerde modus.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Structured representation of a content policy."""

    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:
        """Evaluates scores against the policy."""
        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:
        """Generates an appropriate blocking message."""
        if self.block_action == "generic_message":
            return "This content cannot be processed."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Content blocked for the following reasons: "
                    f"{cats}. Please rephrase your request.")
        return "Content blocked."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Translates the policy into the guardrails parameter for the Mistral API."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

De methode to_guardrails maakt van het beleid de enige bron van waarheid voor guardrails: client.chat.complete(..., guardrails=policy.to_guardrails()) of client.beta.agents.create(..., guardrails=policy.to_guardrails()). Drempelwaarden die vóór en na de generatie worden toegepast, kunnen niet langer divergeren.

Merk ook op dat het resultaat van evaluate de naam en versie van het toegepaste beleid bevat. Dit detail stelt u in staat om, zes maanden later, een betwiste beslissing opnieuw af te spelen met de wetenschap onder welk regime deze precies is genomen.

Beheer van meerdere applicaties

Als uw bedrijf meerdere applicaties beheert, centraliseer dan het beleidsbeheer. De onderstaande manager doet twee nuttige dingen: hij weigert expliciet een applicatie te bedienen zonder een gedeclareerd beleid, waardoor implementaties zonder veiligheidsnetten worden voorkomen, en hij produceert een nalevingsrapport dat voor elke applicatie de versie en de laatste revisiedatum vermeldt—precies wat een auditor zal vragen.

class PolicyManager:
    """Manages content policies for multiple applications."""

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

    def register(self, app_id: str, policy: ContentPolicy):
        """Registers a policy for an application."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Retrieves the policy for an application."""
        if app_id not in self.policies:
            raise ValueError(f"No policy for {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Generates a global compliance report."""
        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()
        }

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

Revisie en updates

Uw beleid staat niet in steen gebeiteld. De meest gemaakte fout is het eenmaal opschrijven en het vervolgens vergeten. Stel een ritme vast: analyseer elke week false positives en false negatives die in uw logs worden gerapporteerd; pas elke maand drempelwaarden aan op basis van verzamelde metrics; voer elk kwartaal een volledige revisie uit met stakeholders van business, juridische zaken en product. Voeg hier een niet-onderhandelbare regel aan toe: voer na elk incident een post-mortem uit en implementeer een onmiddellijke oplossing, zonder te wachten op de volgende geplande review.

Belangrijkste punten

  • Een inhoudsbeleid vertaalt uw technische drempelwaarden naar bedrijfsregels
  • Stem drempelwaarden af op de context: publiek, intern, gespecialiseerd
  • Formaliseer het beleid in een geversioneerd document
  • Centraliseer het beheer als u meerdere applicaties heeft
  • Herzie regelmatig—het beleid moet evolueren met uw product