Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Definuj svoju politiku obsahu

Lekcia 9 z 12 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Prečo potrebuješ formálnu politiku obsahu
  2. Prispôsobenie prahových hodnôt kontextu aplikácie
  3. Formalizácia politiky ako dokumentu
  4. Správa viacerých aplikácií
  5. Revízie a aktualizácie
  6. Kľúčové poznatky

Aktualizované 3. novembra 2026. Predchádzajúce politiky používali tri neexistujúce kategórie (hate, violence, unpredictable) a vynechávali dangerous. Teraz sú v súlade s jedenástimi kľúčmi z mistral-moderation-2603. Metóda teraz konvertuje politiku do oficiálneho formátu parametra guardrails, čo zabezpečuje aplikáciu konzistentných prahových hodnôt pred generovaním. Zdroje: Moderácia a ochranné mechanizmy · mistralai SDK 3.7.0.

Prečo potrebuješ formálnu politiku obsahu

Prahové hodnoty moderácie nie sú svojvoľné technické voľby. Odrážajú politiku obsahu – súbor pravidiel definujúcich, čo tvoja aplikácia povoľuje a čo zakazuje. Bez formálnej politiky robí každý vývojár vlastné rozhodnutia a tvoj bezpečnostný systém stráca konzistenciu: dve služby v rámci tej istej spoločnosti nakoniec blokujú odlišný obsah a nikto nevie prečo.

Písaná politika ti umožňuje obhájiť rozhodnutia o moderácii pred používateľmi aj regulátormi, zosúladiť prahové hodnoty naprieč tímami a aplikáciami, auditovať súlad systému a štruktúrovane iterovať podľa meniacich sa potrieb. V deň, keď používateľ napadne blokovanie, je rozdiel medzi „prahová hodnota je nastavená na 0,1“ a „naša Verejná politika v1.2 nastavuje túto prahovú hodnotu z tohto dôvodu“ obrovský.

Prispôsobenie prahových hodnôt kontextu aplikácie

Ten istý obsah môže byť v jednom kontexte prijateľný a v inom nebezpečný. Tvoja politika musí tieto nuansy zohľadňovať. Najlepší spôsob, ako to dosiahnuť, je opísať každý profil ako pomenovaný, datovaný a zdokumentovaný objekt, namiesto anonymického slovníka strateného v kóde.

Pre chatbota určeného pre verejnosť je pravidlo jednoduché: všade prísne, bezpečnosť ako priorita. Nevieš nič o osobe na druhej strane a môžu byť prítomné aj maloleté osoby.

# Politika: Všetko prísne, bezpečnosť na prvom mieste
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot prístupný všetkým, vrátane maloletých",
    "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"
}

Interný asistent mení hru v jednom bode: používatelia sú autentifikovaní, čo znamená, že sú identifikovateľní a zodpovední. To umožňuje flexibilnejšie prahové hodnoty, najmä pre financial a law nastavené na 0,6, keďže zamestnanec, ktorý sa pýta asistenta na štruktúru zmluvy, len vykonáva svoju prácu.

# Politika: Vyvážená, identifikovaní používatelia
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Asistent pre autentifikovaných zamestnancov",
    "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"
}

Špecializovaný nástroj – lekársky, právny alebo finančný – dovádza túto logiku do dôsledku: vo svojej doméne veľmi permisivný, inde prísny. V lekárskom príklade stúpa health na 0,85, pretože diskusia o diagnózach je presne funkciou nástroja, zatiaľ čo pii klesá na 0,15, pretože údaje o pacientoch sa nikdy nesmú šíriť. Pridané sú tu dva prvky, ktoré chýbali v predchádzajúcich politikách: režim blokovania s presmerovaním a explicitné vyhlásenie.

# Politika: Permisívny v doméne, inde prísny
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Nástroj pre zdravotníckych pracovníkov",
    "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,    # Veľmi permisivný: legitímna doména
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Prísny: údaje o pacientoch
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "Tento nástroj nenahrádza lekársku pomoc."
}

Formalizácia politiky ako dokumentu

Tvoja politika obsahu musí byť verzionovaný dokument prístupný všetkým tímom. V Pythone sa to prekladá do triedy, ktorá nesie číslo verzie a dátum revízie spolu s prahovými hodnotami a dokáže hodnotiť skóre aj generovať blokovaciu správu zodpovedajúcu deklarovanému režimu.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Štruktúrovaná reprezentácia politiky obsahu."""

    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:
        """Vyhodnotí skóre podľa politiky."""
        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:
        """Generuje vhodnú blokovaciu správu."""
        if self.block_action == "generic_message":
            return "Tento obsah nie je možné spracovať."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Obsah zablokovaný z nasledujúcich dôvodov: "
                    f"{cats}. Prosím, preformuluj svoju požiadavku.")
        return "Obsah zablokovaný."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Preloží politiku do parametra guardrails pre Mistral API."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

Metóda to_guardrails robí z politiky jediný zdroj pravdy pre ochranné mechanizmy: client.chat.complete(..., guardrails=policy.to_guardrails()) alebo client.beta.agents.create(..., guardrails=policy.to_guardrails()). Prahové hodnoty aplikované pred a po generovaní sa už nemôžu líšiť.

Všimni si tiež, že výsledok evaluate obsahuje názov a verziu aplikovanej politiky. Tento detail ti umožní o šesť mesiacov replayovať sporné rozhodnutie s presnou znalosťou, za akého režimu bolo vykonané.

Správa viacerých aplikácií

Ak tvoja spoločnosť spravuje viacero aplikácií, centralizuj správu politík. Nižšie uvedený manažér robí dve užitočné veci: explicitne odmietne obslúžiť aplikáciu bez deklarovanej politiky, čím predchádza nasadeniam bez bezpečnostných sietí, a produkuje report o súlade, ktorý uvádza verziu a dátum poslednej revízie pre každú aplikáciu – presne to, o čo požiada audítor.

class PolicyManager:
    """Spravuje politiky obsahu pre viacero aplikácií."""

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

    def register(self, app_id: str, policy: ContentPolicy):
        """Registrovať politiku pre aplikáciu."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Získať politiku pre aplikáciu."""
        if app_id not in self.policies:
            raise ValueError(f"Žiadna politika pre {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Generuje globálny report o súlade."""
        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()
        }

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

Revízie a aktualizácie

Tvoja politika nie je vytesaná do kameňa. Najčastejšou chybou je napísať ju raz a potom na ňu zabudnúť. Zaveď rytmus: každý týždeň analyzuj falošné pozitíva a falošné negatíva nahlásené v tvojich logoch; každý mesiac upravuj prahové hodnoty na základe nazbieraných metrík; každý štvrťrok vykonaj úplnú revíziu so zainteresovanými stranami z biznisu, právneho oddelenia a produktu. Pridaj k tomu nepostrádateľné pravidlo: po každom incidente vykonaj post-mortem analýzu a implementuj okamžitú opravu, bez čakania na ďalšiu plánovanú revíziu.

Kľúčové poznatky

  • Politika obsahu prekladá tvoje technické prahové hodnoty na obchodné pravidlá
  • Prispôsob prahové hodnoty kontextu: verejné použitie, interné použitie, špecializované použitie
  • Formalizuj politiku ako verzionovaný dokument
  • Centralizuj správu, ak máš viacero aplikácií
  • Pravidelne reviduj – politika sa musí vyvíjať spolu s tvojim produktom