Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Definér din indholdsretningslinje

Lektion 9 af 12 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Hvorfor du har brug for en formel indholdsretningslinje
  2. Tilpasning af tærskler til applikationskontekst
  3. Formalisering af retningslinjen som et dokument
  4. Håndtering af flere applikationer
  5. Revision og opdateringer
  6. Vigtige pointer

Opdateret 3. november 2026. Tidligere retningslinjer brugte tre ikke-eksisterende kategorier (hate, violence, unpredictable) og udelod dangerous. De er nu tilpasset de elleve nøgler fra mistral-moderation-2603. En metode konverterer nu en retningslinje til det officielle guardrails-parameterformat, hvilket sikrer, at ensartede tærskler anvendes før generering. Kilder: Moderation & Guardrailing · mistralai SDK 3.7.0.

Hvorfor du har brug for en formel indholdsretningslinje

Moderationstærskler er ikke vilkårlige tekniske valg. De afspejler en indholdsretningslinje – et regelsæt, der definerer, hvad din applikation tillader og forbyder. Uden en formel retningslinje træffer hver udvikler sine egne beslutninger, og dit sikkerhedssystem mister sin konsistens: To tjenester inden for samme virksomhed ender med at blokere forskelligt indhold, uden at nogen ved hvorfor.

En skriftlig retningslinje gør det muligt for dig at begrunde moderationsbeslutninger over for både brugere og myndigheder, harmonisere tærskler på tværs af teams og applikationer, revidere systemets overholdelse og iterere på en struktureret måde, efterhånden som behovene ændrer sig. Den dag en bruger anfægter en blokering, er forskellen mellem „tærsklen er sat til 0,1” og „vores offentlige retningslinje v1.2 fastsætter denne tærskel af denne årsag” enorm.

Tilpasning af tærskler til applikationskontekst

Det samme indhold kan være acceptabelt i én kontekst og farligt i en anden. Din retningslinje skal afspejle disse nuancer. Den bedste måde at opnå dette på er at beskrive hver profil som et navngivet, datoen og dokumenteret objekt frem for en anonym ordbog, der går tabt i koden.

For en chatbot rettet mod offentligheden er reglen enkel: Streng overalt, hvor sikkerhed har førsteprioritet. Du ved intet om personen i den anden ende, og mindreårige kan være til stede.

# Politik: Streng på alt, sikkerhed først
POLICY_PUBLIC = {
    "name": "Public-Facing",
    "description": "Chatbot tilgængelig for alle, inklusive mindreårige",
    "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"
}

En intern assistent ændrer spillet på ét punkt: Brugere er autentificerede, hvilket betyder, at de er identificerbare og ansvarlige. Dette muliggør mere fleksible tærskler, især for financial og law sat til 0,6, da en medarbejder, der spørger assistenten om en kontraktstruktur, blot udfører sit arbejde.

# Politik: Afbalanceret, identificerede brugere
POLICY_INTERNAL = {
    "name": "Internal B2B",
    "description": "Assistent til autentificerede medarbejdere",
    "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"
}

Et specialiseret værktøj – medicinsk, juridisk eller finansielt – fører denne logik ud i sin yderste konsekvens: Meget tilladende inden for sit domæne, strengt overalt andet. I det medicinske eksempel hæves health til 0,85, fordi diskussion af diagnoser netop er værktøjets funktion, mens pii sænkes til 0,15, fordi patientdata aldrig må cirkulere. To elementer, der manglede i tidligere retningslinjer, tilføjes her: En blokeringsmode med omdirigering og en eksplicit ansvarsfraskrivelse.

# Politik: Tilladende inden for domæne, strengt andre steder
POLICY_MEDICAL = {
    "name": "Medical Assistant",
    "description": "Værktøj til sundhedsprofessionelle",
    "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,    # Meget tilladende: legitimt domæne
        "financial": 0.3,
        "law": 0.4,
        "pii": 0.15,       # Strengt: patientdata
        "jailbreaking": 0.1,
    },
    "block_action": "detailed_message_with_redirect",
    "logging": "full_with_audit",
    "disclaimer": "Dette værktøj erstatter ikke medicinsk rådgivning."
}

Formalisering af retningslinjen som et dokument

Din indholdsretningslinje skal være et versionsstyret dokument, der er tilgængeligt for alle teams. I Python oversættes dette til en klasse, der bærer versionsnummeret og revisionsdatoen sammen med tærsklerne, og som både kan evaluere scorer og generere blokeringsmeddelelsen svarende til den erklærede mode.

from mistralai.client.models import GuardrailConfigTypedDict


class ContentPolicy:
    """Struktureret repræsentation af en indholdsretningslinje."""

    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:
        """Evaluerer scorer mod retningslinjen."""
        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:
        """Genererer en passende blokeringsmeddelelse."""
        if self.block_action == "generic_message":
            return "Dette indhold kan ikke behandles."
        elif self.block_action == "detailed_message":
            cats = ", ".join(v["category"] for v in violations)
            return (f"Indhold blokeret af følgende årsager: "
                    f"{cats}. Venligst omformulér din anmodning.")
        return "Indhold blokeret."

    def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
        """Oversætter retningslinjen til guardrails-parameteren til Mistral API."""
        return [
            {
                "block_on_error": True,
                "moderation_llm_v2": {
                    "custom_category_thresholds": self.thresholds,
                    "ignore_other_categories": False,
                    "action": "block",
                },
            }
        ]

Metoden to_guardrails gør retningslinjen til den eneste sandhetskilde for guardrails: client.chat.complete(..., guardrails=policy.to_guardrails()) eller client.beta.agents.create(..., guardrails=policy.to_guardrails()). Tærskler anvendt før og efter generering kan ikke længere afvige fra hinanden.

Bemærk også, at resultatet af evaluate inkluderer navnet og versionen af den anvendte retningslinje. Denne detalje gør det muligt for dig, seks måneder senere, at genafspille en omdiskuteret beslutning med fuld viden om, under hvilket regime den blev truffet.

Håndtering af flere applikationer

Hvis din virksomhed administrerer flere applikationer, bør du centralisere styringen af retningslinjer. Manageren nedenfor gør to nyttige ting: Den nægter eksplicit at betjene en applikation uden en erklæret retningslinje, hvilket forhindrer udrulninger uden sikkerhedsnet, og den producerer en overholdelsesrapport, der lister hver applikations version og sidste revisionsdato – præcis det, en revisor vil spørge efter.

class PolicyManager:
    """Administrerer indholdsretningslinjer for flere applikationer."""

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

    def register(self, app_id: str, policy: ContentPolicy):
        """Registrerer en retningslinje for en applikation."""
        self.policies[app_id] = policy

    def get(self, app_id: str) -> ContentPolicy:
        """Henter retningslinjen for en applikation."""
        if app_id not in self.policies:
            raise ValueError(f"Ingen retningslinje for {app_id}")
        return self.policies[app_id]

    def compliance_report(self) -> dict:
        """Genererer en global overholdelsesrapport."""
        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()
        }

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

Revision og opdateringer

Din retningslinje er ikke mejslet i sten. Den mest almindelige fejl er at skrive den én gang og derefter glemme den. Etabler en rytme: Hver uge analyserer du falske positiver og falske negativer rapporteret i dine logs; hver måned justerer du tærskler baseret på akkumulerede metriker; hvert kvartal gennemfører du en fuld revision med interessenter fra forretning, juridisk og produkt. Føj hertil en ikke-forhandlingsregel: Efter hver hændelse skal du udføre en post-mortem og implementere en øjeblikkelig løsning uden at vente på næste planlagte gennemgang.

Vigtige pointer

  • En indholdsretningslinje oversætter dine tekniske tærskler til forretningsregler
  • Tilpas tærskler til konteksten: Offentlig, intern, specialiseret
  • Formalisér retningslinjen i et versionsstyret dokument
  • Centralisér styringen, hvis du har flere applikationer
  • Revidér regelmæssigt – retningslinjen skal udvikle sig sammen med dit produkt