Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Contentmoderatie op schaal

Les 19 van 20 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Uw gebruikers beschermen in productie
  2. De eerste laag: de Moderations API
  3. Belasting afhandelen
  4. Een verdedigbaar archief bijhouden
  5. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (Responses API) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Uw gebruikers beschermen in productie

Zodra uw applicatie live gaat, moet u ongepaste inhoud afhandelen—zowel bij de input (kwaadaardige prompts) als bij de output (problematische antwoorden). Deze tweezijdige vereiste overvalt teams vaak. De meeste mensen denken eerst aan het filteren van wat gebruikers sturen, maar het reputatierisico concentreert zich op wat uw applicatie onder uw naam publiceert. Een goed uitgelijnd model genereert zelden schokkende inhoud uit zichzelf, maar het kan dat wel doen als het wordt gepusht—en uw merk staat bovenaan de screenshot.

We gaan van een enkele API-call naar een asynchrone pipeline met hoge doorvoer, stap voor stap opschalend.

De eerste laag: de Moderations API

De Moderations API classificeert tekst over verschillende risicocategorieën en retourneert zowel een binair oordeel als gedetailleerde scores. Het is snel en gratis, waardoor het de natuurlijke eerste filter is voor elke publieke applicatie. De onderstaande functie toont alleen categorieën met scores boven de 0,3—een bewust lage drempelwaarde. In dit stadium wilt u zien wat de lijn nadert, niet alleen wat eroverheen gaat.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Controleer of tekst ongepaste inhoud bevat."""
    response = client.moderations.create(
        model="omni-moderation-latest",
        input=text,
    )

    result = response.results[0]
    return {
        "flagged": result.flagged,
        "categories": {
            cat: score
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.3
        },
    }

# Voorbeeld
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")

In productie is een binair oordeel niet genoeg. Afhankelijk van de inhoud en context wilt u deze misschien toestaan, herschrijven, blokkeren of escaleren naar een mens—vier verschillende beslissingen die u expliciet in code moet benoemen in plaats van te improviseren met booleans. De onderstaande pipeline formaliseert deze acties, past drempelwaarden per categorie toe en voegt een tweede laag toe voor detectie van prompt-injectie.

from enum import Enum
from dataclasses import dataclass

class ModerationAction(Enum):
    ALLOW = "allow"
    MODIFY = "modify"
    BLOCK = "block"
    ESCALATE = "escalate"

@dataclass
class ModerationResult:
    action: ModerationAction
    reason: str | None = None
    modified_content: str | None = None

class ModerationPipeline:
    """Moderatiepipeline met meerdere lagen."""

    def __init__(self, thresholds: dict | None = None):
        self.thresholds = thresholds or {
            "harassment": 0.7,
            "hate": 0.7,
            "self-harm": 0.5,
            "sexual": 0.7,
            "violence": 0.7,
        }

    def moderate_input(self, text: str) -> ModerationResult:
        """Moderatie van inputinhoud (gebruikersprompt)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=text,
        )

        result = moderation.results[0]
        if result.flagged:
            problematic_categories = [
                cat for cat, flagged in result.categories.__dict__.items()
                if flagged
            ]
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason=f"Ongepaste inhoud: {', '.join(problematic_categories)}",
            )

        # Detectie van prompt-injectie
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Prompt-injectiepoging gedetecteerd",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderatie van outputinhoud (LLM-antwoord)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Gegenereerd antwoord bevat ongepaste inhoud",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detecteer pogingen tot prompt-injectie."""
        markers = [
            "ignore previous instructions",
            "ignore your instructions",
            "forget your guidelines",
            "you are now",
            "new role",
            "system prompt",
            "jailbreak",
        ]
        text_lower = text.lower()
        return any(m in text_lower for m in markers)

De drempelwaarde van 0,5 voor self-harm—strenger dan de 0,7 die voor andere categorieën wordt gebruikt—illustreert de redenering die u voor elke drempelwaarde moet toepassen. Hier weegt de kostprijs van een false positive niet op tegen de kostprijs van een false negative, dus verlaagt u de lat. Maak deze afweging categorie per categorie, op basis van uw doelgroep, in plaats van een uniforme waarde toe te passen.

Injectiedetectie op basis van markers heeft een kanttekening. Het vangt naïeve pogingen, die het gros van het volume uitmaken, en niets meer: een iets andere formulering of een vertaalde versie glipt erdoorheen. Beschouw het als een ruisfilter, niet als een verdediging. Echte bescherming tegen injectie is architecturaal—geef het model nooit mogelijkheden die een gekaapte prompt zou kunnen misbruiken.

Belasting afhandelen

Bij een applicatie met veel verkeer wordt synchrone moderatie een flessenhals: elk bericht wacht op zijn oordeel voordat het wordt verwerkt. Een asynchrone moderator ontkoppelt deze stappen door inhoud in een wachtrij te plaatsen voor consumptie door meerdere workers, terwijl onderweg ook nuttige statistieken worden bijgehouden.

import asyncio

class AsyncModerator:
    """Moderatie van inhoud asynchroon voor hoge doorvoer."""

    def __init__(self, num_workers: int = 10):
        self.pipeline = ModerationPipeline()
        self.queue: asyncio.Queue = asyncio.Queue()
        self.num_workers = num_workers
        self.stats = {"allowed": 0, "blocked": 0, "escalated": 0}

    async def worker(self):
        while True:
            task = await self.queue.get()
            try:
                result = self.pipeline.moderate_input(task["text"])
                task["callback"](result)

                match result.action:
                    case ModerationAction.ALLOW:
                        self.stats["allowed"] += 1
                    case ModerationAction.BLOCK:
                        self.stats["blocked"] += 1
                    case ModerationAction.ESCALATE:
                        self.stats["escalated"] += 1
            finally:
                self.queue.task_done()

    async def start(self):
        for _ in range(self.num_workers):
            asyncio.create_task(self.worker())

    def report(self) -> str:
        total = sum(self.stats.values())
        if total == 0:
            return "Geen inhoud gemodereerd."
        return (
            f"Totaal: {total} | "
            f"Toegestaan: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Geblokkeerd: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Het blokkeerpercentage dat door report wordt geproduceerd, is uw primaire kalibratiemaatstaf. Als dit plotseling springt naar 15% na te hebben gedraaid op 0,5%, zijn er slechts twee verklaringen: u ligt onder een gecoördineerde aanval, of u heeft zojuist uw drempelwaarden verbroken. In beide gevallen wilt u dit binnen het uur weten, niet bij de volgende maandelijkse evaluatie.

Eén laatste beperking verdient vermelding: de Moderations API weet niets van uw bedrijf. Een bericht dat over het algemeen perfect acceptabel is, kan uw eigen regels schenden—het vragen van medisch advies aan een bankassistent, proberen een off-grid tarief te verkrijgen, of een procedure omzeilen. Contextuele moderatie voegt deze laag toe door het bericht naar een model te sturen met uw expliciete regels, maar pas nadat het standaardfilter het heeft doorgelaten.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Contextbewuste moderatie op maat van de applicatie."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

    if standard_result.action == ModerationAction.BLOCK:
        return standard_result

    verification_prompt = (
        f"Applicatiecontext: {app_context}\n\n"
        f"Te verifiëren bedrijfsregels:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nGebruikersbericht: {text}\n\n"
        "Voldoet het bericht aan alle regels? "
        "Antwoord ja of nee met een korte onderbouwing."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vereist effort none
        input=verification_prompt,
        max_output_tokens=100,
        temperature=0.0,
    )

    if "no" in response.output_text.lower()[:10]:
        return ModerationResult(
            action=ModerationAction.BLOCK,
            reason=response.output_text,
        )

    return ModerationResult(action=ModerationAction.ALLOW)

De volgorde van deze twee controles is belangrijk. Het gratis, snelle filter draait eerst, en de betaalde modelaanroep gebeurt alleen voor berichten die dit filter passeren. Bij echt verkeer dekt dit bijna alle berichten. Het omgekeerde doen—betalen voor een modelaanroep op inhoud die de Moderations API in milliseconden zou hebben afgewezen—zou verspilling zijn.

Een verdedigbaar archief bijhouden

Een moderatiebeslissing is een beslissing waar u vroeg of laat verantwoordelijk voor wordt gehouden. U heeft een logboek nodig—maar eentje dat niet zelf tot een probleem wordt. Het commentaar in de code markeert de belangrijkste regel in het bestand: leg de actie, de reden en de lengte vast, nooit de ruwe tekst. Het opslaan van gebruikersberichten in een logbestand stelt u bloot aan gegevensbeschermingsverplichtingen die veel zwaarder wegen dan de geleverde dienst.

import json
import time
from pathlib import Path

class ModerationLog:
    """Log alle moderatiebeslissingen voor auditdoeleinden."""

    def __init__(self, log_path: str = "logs/moderation.jsonl"):
        self.path = Path(log_path)
        self.path.parent.mkdir(parents=True, exist_ok=True)

    def record(
        self,
        text: str,
        result: ModerationResult,
        source: str = "input",
    ):
        entry = {
            "timestamp": time.time(),
            "source": source,
            "action": result.action.value,
            "reason": result.reason,
            "text_length": len(text),
            # Log GEEN ruwe tekst vanwege privacy
        }

        with open(self.path, "a") as f:
            f.write(json.dumps(entry) + "\n")

Als u toch in staat moet zijn om een specifiek bericht tijdens een geschil op te halen, log dan een hash van de tekst in plaats van de tekst zelf. Hiermee kunt u bevestigen dat een bepaald stuk inhoud overeenkomt met een geregistreerde beslissing zonder de inhoud aan uw kant te bewaren.

Belangrijkste punten

  • Moderatie zowel inputs (prompts) als outputs (antwoorden)
  • Gebruik de Moderations API als uw eerste, snelle, gratis laag
  • Pas drempelwaarden per categorie aan op basis van de reële kostprijs van een false negative
  • Voeg injectiedetectie toe met de wetenschap dat het alleen naïeve pogingen vangt
  • Log alle beslissingen voor audit zonder ruwe inhoud op te slaan