Przejdź do głównej treści
Polski— Wybierz język
Menu

Zdefiniuj swoją politykę treści

Lekcja 9 z 12 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Dlaczego potrzebujesz formalnej polityki treści
  2. Dostosowanie progów do kontekstu aplikacji
  3. Formalizacja polityki jako dokumentu
  4. Zarządzanie wieloma aplikacjami
  5. Rewizje i aktualizacje
  6. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 r. Poprzednie polityki używały trzech nieistniejących kategorii (hate, violence, unpredictable) i pomijały dangerous. Obecnie są zgodne z jedenastoma kluczami z mistral-moderation-2603. Dodano metodę konwertującą politykę na oficjalny format parametru guardrails, co zapewnia stosowanie spójnych progów przed generowaniem. Źródła: Moderation & Guardrailing · mistralai SDK 3.7.0.

Dlaczego potrzebujesz formalnej polityki treści

Progi moderacji nie są arbitralnymi wyborami technicznymi. Odzwierciedlają one politykę treści – zbiór zasad określających, co Twoja aplikacja dozwala, a czego zabrania. Bez formalnej polityki każdy programista podejmuje własne decyzje, a Twój system bezpieczeństwa traci spójność: dwie usługi w ramach tej samej firmy zaczynają blokować różne treści i nikt nie wie dlaczego.

Spisana polityka pozwala uzasadnić decyzje moderacyjne zarówno przed użytkownikami, jak i regulatorami, ujednolicić progi między zespołami i aplikacjami, przeprowadzić audyt zgodności systemu oraz iteracyjnie go doskonalić w miarę zmiany potrzeb. W dniu, w którym użytkownik zakwestionuje blokadę, różnica między stwierdzeniem „próg ustawiono na 0,1“ a „nasza Polityka Publiczna v1.2 ustala ten próg z takiego a takiego powodu“ jest ogromna.

Dostosowanie progów do kontekstu aplikacji

Ta sama treść może być akceptowalna w jednym kontekście, a niebezpieczna w innym. Twoja polityka musi uwzględniać te niuanse. Najlepszym sposobem na osiągnięcie tego celu jest opisanie każdego profilu jako nazwanego, datowanego i udokumentowanego obiektu, zamiast anonimowego słownika zagubionego w kodzie.

W przypadku czatbota dostępnego publicznie zasada jest prosta: surowość we wszystkim, bezpieczeństwo jako priorytet. Nie wiesz niczego o osobie po drugiej stronie, a wśród użytkowników mogą być niepełnoletni.

# Polityka: Surowa we wszystkim, bezpieczeństwo przede wszystkim
POLITYKA_PUBLICZNA = {
    "name": "Public-Facing",
    "description": "Czatbot dostępny dla wszystkich, w tym niepełnoletnich",
    "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"
}

Asystent wewnętrzny zmienia zasady gry w jednym punkcie: użytkownicy są uwierzytelnieni, co oznacza, że są identyfikowalni i ponoszą odpowiedzialność. Pozwala to na bardziej elastyczne progi, szczególnie w kategoriach financial i law ustawionych na 0,6, ponieważ pracownik pytający asystenta o strukturę kontraktu po prostu wykonuje swoją pracę.

# Polityka: Zrównoważona, zidentyfikowani użytkownicy
POLITYKA_WEWNĘTRZNA = {
    "name": "Internal B2B",
    "description": "Asystent dla uwierzytelnionych pracowników",
    "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"
}

Wyspecjalizowane narzędzie – medyczne, prawne lub finansowe – doprowadza tę logikę do ostateczności: bardzo liberalne w swojej domenie, surowe we wszystkim innym. W przykładzie medycznym kategoria health rośnie do 0,85, ponieważ omawianie diagnoz jest właśnie funkcją tego narzędzia, podczas gdy pii spada do 0,15, ponieważ dane pacjentów nigdy nie mogą być udostępniane. Dodano tu dwa elementy nieobecne w poprzednich politykach: tryb blokowania z przekierowaniem oraz wyraźne zastrzeżenie.

# Polityka: Liberalna w domenie, surowa gdzie indziej
POLITYKA_MEDYCZNA = {
    "name": "Medical Assistant",
    "description": "Narzędzie dla pracowników służby zdrowia",
    "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,    # Bardzo liberalne: legitna domena
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Surowe: dane pacjentów
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "To narzędzie nie zastępuje porady lekarskiej."
}

Formalizacja polityki jako dokumentu

Twoja polityka treści musi być wersjonowanym dokumentem dostępnym dla wszystkich zespołów. W Pythonie przekłada się to na klasę, która przenosi numer wersji i datę rewizji wraz z progami, a która potrafi zarówno oceniać wyniki, jak i generować komunikat blokujący odpowiadający zadeklarowanemu trybowi.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Strukturalna reprezentacja polityki treści."""

    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:
        """Ocenia wyniki względem polityki."""
        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 odpowiedni komunikat blokujący."""
        if self.block_action == "generic_message":
            return "Ta treść nie może zostać przetworzona."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Treść zablokowana z następujących powodów: "
                    f"{cats}. Proszę przeformułować swoje żądanie.")
        return "Treść zablokowana."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Tłumaczy politykę na parametr guardrails dla API Mistral."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

Metoda to_guardrails czyni politykę jedinym źródłem prawdy dla guardrails: client.chat.complete(..., guardrails=policy.to_guardrails()) lub client.beta.agents.create(..., guardrails=policy.to_guardrails()). Progi stosowane przed i po generowaniu nie mogą się już różnić.

Zauważ również, że wynik evaluate zawiera nazwę i wersję zastosowanej polityki. Ten szczegół pozwala Ci, sześć miesięcy później, odtworzyć kwestionowaną decyzję, wiedząc dokładnie, w ramach jakiego reżimu została podjęta.

Zarządzanie wieloma aplikacjami

Jeśli Twoja firma zarządza wieloma aplikacjami, scentralizuj zarządzanie politykami. Poniższy menedżer robi dwie użyteczne rzeczy: wyraźnie odmawia obsługi aplikacji bez zadeklarowanej polityki, zapobiegając wdrażaniu bez siatek bezpieczeństwa, oraz generuje raport zgodności wymieniający wersję i datę ostatniej rewizji dla każdej aplikacji – dokładnie to, o co poprosi audytor.

class PolicyManager:
    """Zarządza politykami treści dla wielu aplikacji."""

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

    def register(self, app_id: str, policy: ContentPolicy):
        """Rejestruje politykę dla aplikacji."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Pobiera politykę dla aplikacji."""
        if app_id not in self.policies:
            raise ValueError(f"Brak polityki dla {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Generuje globalny raport zgodności."""
        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()
        }

# Użycie
manager = PolicyManager()
manager.register("chatbot-public",
    ContentPolicy(POLITYKA_PUBLICZNA))
manager.register("assistant-medical",
    ContentPolicy(POLITYKA_MEDYCZNA))

Rewizje i aktualizacje

Twoja polityka nie jest wyryta w kamieniu. Najczęstszym błędem jest napisanie jej raz, a następnie zapomnienie o niej. Ustal rytm: co tydzień analizuj fałszywe pozytywy i fałszywe negatywy zgłaszane w logach; co miesiąc dostosowuj progi na podstawie zgromadzonych metryk; co kwartał przeprowadzaj pełną rewizję z udziałem interesariuszy biznesowych, prawnych i produktowych. Dodaj do tego niepodważalną zasadę: po każdym incydencie przeprowadź analizę powłamaniową (post-mortem) i wdróż natychmiastową poprawkę, nie czekając na kolejny zaplanowany przegląd.

Kluczowe wnioski

  • Polityka treści przekłada Twoje techniczne progi na zasady biznesowe
  • Dostosuj progi do kontekstu: publiczny, wewnętrzny, wyspecjalizowany
  • Sformalizuj politykę w wersjonowanym dokumencie
  • Scentralizuj zarządzanie, jeśli masz wiele aplikacji
  • Regularnie dokonuj rewizji – polityka musi ewoluować wraz z Twoim produktem