Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Opredelitev vaše politike vsebin

Lekcija 9 od 12 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Zakaj potrebujete formalno politiko vsebin
  2. Prilagoditev pragov kontekstu aplikacije
  3. Formalizacija politike kot dokumenta
  4. Upravljanje več aplikacij
  5. Revizija in posodobitve
  6. Ključne ugotovitve

Posodobljeno 3. novembra 2026. Prejšnje politike so uporabljale tri neobstoječe kategorije (hate, violence, unpredictable) in izpuščale dangerous. Zdaj so usklajene z enajstimi ključi iz mistral-moderation-2603. Uvedena je metoda za pretvorbo politike v uradni format parametra guardrails, kar zagotavlja dosledno uporabo pragov pred generiranjem. Viri: Moderation & Guardrailing · mistralai SDK 3.7.0.

Zakaj potrebujete formalno politiko vsebin

Pragovi moderacije niso poljubne tehnične odločitve. Odražajo politiko vsebin – niz pravil, ki opredeljujejo, kaj vaša aplikacija dovoljuje in kaj prepoveduje. Brez formalne politike vsak razvijalec sprejema lastne odločitve, vaš varnostni sistem pa izgubi doslednost: dve storitvi znotraj istega podjetja začneta blokirati različne vsebine, ne da bi kdorkoli vedel zakaj.

Pisna politika vam omogoča, da odločitve o moderaciji utemeljite tako uporabnikom kot regulatorjem, uskladite pragove med ekipami in aplikacijami, revidirate skladnost sistema ter strukturirano iterirate ob spremembah potreb. Ko uporabnik izpodbija blokado, je razlika med „prag je nastavljen na 0,1” in „naša javna politika v1.2 ta prag določa iz tega razloga” ogromna.

Prilagoditev pragov kontekstu aplikacije

Ista vsebina je lahko v enem kontekstu sprejemljiva, v drugem pa nevarna. Vaša politika mora odražati te nianse. Najboljši način za dosego tega je opis vsakega profila kot poimenovanega, datiranega in dokumentiranega objekta, namesto anonimnega slovarja, izgubljenega v kodi.

Za javno dostopnega klepetalnega bota je pravilo preprosto: povsod strogo, varnost je prednostna naloga. Ne veste ničesar o osebi na drugi strani, prisotni pa so lahko tudi mladoletniki.

# 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"
}

Interni asistent spremeni igro na eni točki: uporabniki so avtenticirani, kar pomeni, da so identificirani in odgovorni. To omogoča prilagodljivejše pragove, zlasti za financial in law, nastavljene na 0,6, saj zaposleni, ki asistenta sprašuje o strukturi pogodbe, preprosto opravlja svoje delo.

# 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"
}

Specializirano orodje – medicinsko, pravno ali finančno – to logiko pripelje do konca: znotraj svojega področja zelo dopustno, povsod drugje strogo. V medicinskem primeru se health dvigne na 0,85, saj je razprava o diagnozah ravno funkcija orodja, medtem ko pii pade na 0,15, ker podatki o pacientih nikoli ne smejo krožiti. Tu sta dodana dva elementa, ki sta v prejšnjih politikah manjkala: način blokiranja s preusmeritvijo in izrecno opozorilo.

# 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."
}

Formalizacija politike kot dokumenta

Vaša politika vsebin mora biti različičen dokument, dostopen vsem ekipam. V Pythonu to pomeni razred, ki poleg pragov nosi številko različice in datum revizije ter zna ocenjevati rezultate in generirati sporočilo o blokiranju, ki ustreza deklariranemu načinu.

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",
                },
            }
        ]

Metoda to_guardrails naredi politiko edini vir resnice za zaščitne ograje: client.chat.complete(..., guardrails=policy.to_guardrails()) ali client.beta.agents.create(..., guardrails=policy.to_guardrails()). Pragovi, uporabljeni pred in po generiranju, se ne morejo več razhajati.

Upoštevajte tudi, da rezultat metode evaluate vključuje ime in različico uporabljene politike. Ta podrobnost vam omogoča, da šest mesecev kasneje ponovno odigrate izpodbijano odločitev in točno veste, v okviru katerega režima je bila sprejeta.

Upravljanje več aplikacij

Če vaše podjetje upravlja več aplikacij, centralizirajte upravljanje politik. Spodnji upravitelj počne dve koristni stvari: izrecno zavrne strežbo aplikaciji brez deklarirane politike, s čimer prepreči uvedbe brez varnostnih mrež, in ustvari poročilo o skladnosti, ki za vsako aplikacijo navaja različico in datum zadnje revizije – točno tisto, kar bo zahteval revizor.

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))

Revizija in posodobitve

Vaša politika ni vklesana v kamen. Najpogostejša napaka je, da jo napišete enkrat in nato pozabite nanjo. Vzpostavite ritem: vsak teden analizirajte lažno pozitivne in lažno negativne rezultate, prijavljene v vaših dnevnikih; vsak mesec prilagodite pragove na podlagi zbranih metrik; vsako četrtletje izvedite popolno revizijo s deležniki iz poslovanja, pravnega oddelka in produkta. Temu dodajte nepogrešljivo pravilo: po vsakem incidentu izvedite analizo vzrokov (post-mortem) in takoj izvedite popravek, ne da bi čakali na naslednji načrtovani pregled.

Ključne ugotovitve

  • Politika vsebin prevaja vaše tehnične pragove v poslovna pravila
  • Prilagodite pragove kontekstu: javno dostopno, interno, specializirano
  • Formalizirajte politiko v različičen dokument
  • Centralizirajte upravljanje, če imate več aplikacij
  • Redno revidirajte – politika se mora razvijati skupaj z vašim izdelkom