Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Moderacija sadržaja u velikom obujmu

Lekcija 19 od 20 Ažurirano 3. studenoga 2026. Napredno
Na ovoj stranici
  1. Zaštita tvojih korisnika u proizvodnji
  2. Prvi sloj: Moderations API
  3. Rukovanje opterećenjem
  4. Vođenje obranjive evidencije
  5. Ključne točke

Lekcija ažurirana 3. studenoga 2026. na temelju OpenAI dokumentacije: parametri temperature i top_p prihvaćeni su samo uz napor rezoniranja (reasoning effort) vrijednosti none, dok modeli GPT-5.6 prema zadanim postavkama rezoniraju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificirati reasoning={"effort": "none"} (Responses API) ili reasoning_effort="none" (Chat Completions). Izvori: Korištenje GPT-6 · GPT-5.6 Terra.

Zaštita tvojih korisnika u proizvodnji

Čim tvoja aplikacija krene u rad, moraš rukovati neprimjerenim sadržajem – i na ulazu (zlonamjerni upiti) i na izlazu (problematični odgovori). Taj zahtjev u oba smjera često iznenadi timove. Većina ljudi prvo razmišlja o filtriranju onoga što korisnici šalju, no reputacijski rizik koncentriran je na onome što tvoja aplikacija objavljuje pod tvojim imenom. Dobro usklađen model rijetko sam od sebe generira šokantan sadržaj, ali može ga proizvesti ako ga se gura – a tvoja marka nalazi se na vrhu snimke zaslona.

Prijeći ćemo s jednog API poziva na asinkroni cjevovod velikog propusnog opsega, postupno povećavajući razmjere.

Prvi sloj: Moderations API

Moderations API klasificira tekst u nekoliko kategorija rizika i vraća i binarnu presudu i detaljne rezultate. Brz je i besplatan, što ga čini prirodnim prvim filtrom za svaku javnu aplikaciju. Donja funkcija prikazuje samo kategorije s rezultatom većim od 0,3 – namjerno nizak prag. U ovoj fazi želiš vidjeti što se približava granici, a ne samo što ju prelazi.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Provjeri sadrži li tekst neprimjeren sadržaj."""
    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
        },
    }

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

U proizvodnji binarna presuda nije dovoljna. Ovisno o sadržaju i kontekstu, možda ćeš ga htjeti dopustiti, prepisati, blokirati ili eskalirati čovjeku – četiri različite odluke koje trebaš eksplicitno imenovati u kodu, umjesto da improviziraš s boolean vrijednostima. Cjevovod u nastavku formalizira ove radnje, primjenjuje pragove po kategorijama i dodaje drugi sloj za detekciju ubrizgavanja upita (prompt injection).

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:
    """Višeslojni cjevovod za moderaciju."""

    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:
        """Moderiraj ulazni sadržaj (korisnički upit)."""
        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"Inappropriate content: {', '.join(problematic_categories)}",
            )

        # Detekcija ubrizgavanja upita
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Prompt injection attempt detected",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderiraj izlazni sadržaj (LLM odgovor)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Generated response contains inappropriate content",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detektiraj pokušaje ubrizgavanja upita."""
        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)

Prag od 0,5 za self-harm – stroži od 0,7 korištenog za druge kategorije – ilustrira razmišljanje koje trebaš primijeniti na svaki prag. Ovdje trošak lažno pozitivnog rezultata nije ni blizu trošku lažno negativnog, pa spuštaš letvicu. Napravi tu razmjenu kategoriju po kategoriju, na temelju svoje publike, umjesto da primjenjuješ jedinstvenu vrijednost.

Detekcija ubrizgavanja temeljena na markerima nosi određena ograničenja. Hvata naivne pokušaje, koji čine većinu prometa, i ništa više: malo drugačija formulacija ili prevedena verzija proći će neopaženo. Tretiraj to kao filtar za šum, a ne kao obranu. Prava zaštita od ubrizgavanja je arhitektonska – nikada nemoj modelu davati mogućnosti koje bi oteti upit mogao iskoristiti.

Rukovanje opterećenjem

Na aplikaciji s velikim prometom sinkrona moderacija postaje usko grlo: svaka poruka čeka svoju presudu prije obrade. Asinkroni moderator odvaja ove korake stavljanjem sadržaja u red čekanja za obradu od strane više radnika, pritom prateći korisne statistike.

import asyncio

class AsyncModerator:
    """Asinkrono moderiranje sadržaja za veliki propusni opseg."""

    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 "No content moderated."
        return (
            f"Total: {total} | "
            f"Allowed: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Blocked: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Stopa blokiranja koju proizvodi report tvoja je primarna metrika za kalibraciju. Ako naglo skoči na 15% nakon što je radila na 0,5%, postoje samo dva objašnjenja: pod koordiniranim si napadom ili si upravo pokvario svoje pragove. U oba slučaja, to želiš saznati unutar sat vremena, a ne na sljedećem mjesečnom pregledu.

Treba spomenuti još jedno konačno ograničenje: Moderations API ne zna ništa o tvom poslovanju. Poruka koja je općenito sasvim prihvatljiva može kršiti tvoja vlastita pravila – traženje medicinskog savjeta od bankovnog asistenta, pokušaj dobivanja cijene izvan mreže ili zaobilaženje postupka. Kontekstualna moderacija dodaje ovaj sloj slanjem poruke modelu s tvojim eksplicitnim pravilima, ali tek nakon što standardni filtar propusti sadržaj.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Moderacija svjesna konteksta prilagođena aplikaciji."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

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

    verification_prompt = (
        f"Application context: {app_context}\n\n"
        f"Business rules to verify:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nUser message: {text}\n\n"
        "Does the message comply with all rules? "
        "Answer yes or no with a brief justification."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires 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)

Redoslijed ove dvije provjere je bitan. Besplatni, brzi filtar pokreće se prvi, a poziv plaćenom modelu događa se samo za poruke koje ga prođu. Na stvarnom prometu to pokriva gotovo sve poruke. Činiti obrnuto – plaćati poziv modelu za sadržaj koji bi Moderations API odbio u milisekundama – bilo bi rasipnički.

Vođenje obranjive evidencije

Odluka o moderaciji je odluka za koju ćeš biti odgovoran, na ovaj ili onaj način. Trebaš zapisnik – ali onaj koji sam po sebi ne postaje problem. Komentar u kodu ističe najvažniju liniju u datoteci: zabilježi radnju, razlog i duljinu, nikada sirovi tekst. Pohranjivanje korisničkih poruka u zapisnik izlaže te obvezama zaštite podataka daleko težima od same pružene usluge.

import json
import time
from pathlib import Path

class ModerationLog:
    """Zabilježi sve odluke o moderaciji radi revizije."""

    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),
            # DO NOT log raw text for privacy
        }

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

Ako ipak moraš biti u mogućnosti dohvatiti određenu poruku tijekom spora, zabilježi hash teksta umjesto samog teksta. To ti omogućuje potvrdu da se određeni sadržaj podudara sa zabilježenom odlukom, a da pritom ne zadržavaš sadržaj na svojoj strani.

Ključne točke

  • Moderiraj i ulaze (upite) i izlaze (odgovore)
  • Koristi Moderations API kao svoj prvi, brzi i besplatni sloj
  • Prilagodi pragove kategoriju po kategoriju na temelju stvarnog troška lažno negativnog rezultata
  • Dodaj detekciju ubrizgavanja znajući da hvata samo naivne pokušaje
  • Zabilježi sve odluke radi revizije bez pohranjivanja sirovog sadržaja