Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

API za moderiranje podjetja OpenAI

Lekcija 5 od 14 Posodobljeno 3. november 2026 Napredni
Na tej strani
  1. Vgrajeno orodje za moderiranje
  2. Kaj API vrne
  3. Zaznane kategorije
  4. Moderiranje obeh koncev cevovoda
  5. Česa ta API ne počne
  6. Ključne ugotovitve

Posodobljeno 3. novembra 2026 na podlagi vodnika Moderation podjetja OpenAI: dodana je bila kategorija illicit (in illicit/violent), ki je manjkala v tabeli, skupaj s kategorijami, ki veljajo za slike. Vir: Moderation.

Vgrajeno orodje za moderiranje

OpenAI ponuja brezplačen API za moderiranje, ki analizira besedilo in zazna potencialno škodljivo vsebino. To je prva obrambna linija, ki jo moraš vključiti v vsako aplikacijo, ki uporablja modele OpenAI, pri čemer nisi omejen le na ta primer uporabe: ker API kot vhod sprejme surovo besedilo, ga lahko uporabiš tudi za filtriranje vhodnih podatkov, namenjenih drugim modelom. Dejstvo, da je brezplačen, spremeni tvoj pristop k problemu. Običajni kompromisi – ali naj moderiramo vsako zahtevo ali le sumljive? – izgubijo svojo težo, saj so edini preostali stroški latenca.

Kaj API vrne

Osnovni klic se prilega v eno vrstico; pozornost si zasluži odgovor. API vrne tri različne stvari: boolean vrednost flagged, ki odraža odločitev OpenAI, seznam dejansko sproženih kategorij in, kar je najpomembneje, zvezne rezultate (score) za vsako kategorijo. Ti rezultati so tisti, ki delajo razliko v produkcijskem okolju, saj ti omogočajo, da sam določiš mejo, namesto da bi podedoval prag, zasnovan za splošno uporabo.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analizira besedilo prek API-ja za moderiranje podjetja OpenAI."""
    response = client.moderations.create(input=text)
    result = response.results[0]

    return {
        "blocked": result.flagged,
        "categories": {
            cat: flagged
            for cat, flagged in result.categories.__dict__.items()
            if flagged
        },
        "scores": {
            cat: round(score, 4)
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.01
        },
    }

# Testiranje z različnimi vrstami vsebine
examples = [
    "How do I bake a chocolate cake?",
    "I will kill you if you don't answer me",
    "Explain how AES encryption works",
]

for text in examples:
    result = moderate_content(text)
    status = "BLOCKED" if result["blocked"] else "OK"
    print(f"{status} : {text[:50]}...")
    if result["categories"]:
        print(f"  Categories : {list(result['categories'].keys())}")

Trije testni primeri niso naključni: prvi bi moral iti skozi, drugi bi moral biti blokiran, tretji – popolnoma legitimno tehnično vprašanje – pa ti pokaže, kako se tvoj cevovod obnaša, ko se sooči z varnostnim besediščem. To je točno tista vrsta zahteve, s katero se ekipa za kibernetsko varnost sooča vsak dan.

Zaznane kategorije

API razvršča problematično vsebino po več oseh, od katerih vsaka ustreza drugačni vrsti škode.

Kategorija Opis
harassment Nadlegovanje, grožnje, zastraševanje
hate Govor sovraštva na podlagi identitete
illicit Nasveti ali navodila za izvrševanje nedovoljenih dejanj
self-harm Samopoškodovanje, samomor
sexual Eksplicitna spolna vsebina
violence Grafično nasilje, grožnje

Vsaka kategorija ima tudi podkategorije (npr. harassment/threatening, illicit/violent, violence/graphic) za natančnejše filtriranje. Pri modelu omni-moderation-latest se kategoriji self-harm in njene različice, sexual ter violence (z violence/graphic) uporabljajo tudi za slike; druge kategorije veljajo samo za besedilo. Ta granularnost te rešuje pred grobimi kompromisi: platforma za moderiranje forumov bi morda želela blokirati harassment/threatening, medtem ko dopušča preprosto harassment, kar zajema številne običajne spore.

Ko moraš obdelati velike količine – na primer retrospektivno analizo zgodovine pogovora – API sprejme seznam in vrne rezultat za vsak element, s čimer se izogneš večkratnim omrežnim krogom.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Moderira več sporočil v enem klicu."""
    response = client.moderations.create(input=messages)
    results = []
    for i, result in enumerate(response.results):
        results.append({
            "index": i,
            "text": messages[i][:50],
            "blocked": result.flagged,
            "max_score": max(
                score
                for score in result.category_scores.__dict__.values()
            ),
        })
    return results

Moderiranje obeh koncev cevovoda

Pogosta napaka je moderiranje samo vhodnih podatkov. To temelji na napačni intuiciji: če je prihajajoče sporočilo sprejemljivo, bo tudi odgovor. Vendar pa lahko model ustvari problematično vsebino iz nevtralne zahteve, še posebej, ko se zanaša na pridobljene dokumente, katerih vsebine nihče ni preveril. Spodnji razred zato uporablja enako obravnavo v obe smeri in dodaja prilagojen prag, ki zaostruje privzeto odločitev API-ja.

class ModerationPipeline:
    """Cevovod za moderiranje vhodov in izhodov za aplikacijo LLM."""

    def __init__(self, custom_threshold: float = 0.7):
        self.client = OpenAI()
        self.threshold = custom_threshold

    def moderate_input(self, message: str) -> tuple[bool, dict]:
        """Moderira sporočilo PRED pošiljanjem modelu."""
        result = self.client.moderations.create(input=message).results[0]
        scores = result.category_scores.__dict__
        high_categories = {
            cat: score for cat, score in scores.items() if score > self.threshold
        }
        blocked = result.flagged or bool(high_categories)
        return blocked, {"flagged_api": result.flagged, "custom_categories": high_categories}

    def moderate_output(self, response: str) -> tuple[bool, dict]:
        """Moderira odgovor modela PRED pošiljanjem uporabniku."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Polni cevovod: moderiranje vhoda, LLM, moderiranje izhoda."""
        # 1. korak: moderiranje vhoda
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Vašega sporočila ni mogoče obdelati. Prosimo, preoblikujte ga."

        # 2. korak: klic modela
        response = self.client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message},
            ],
        )
        model_response = response.choices[0].message.content

        # 3. korak: moderiranje izhoda
        output_blocked, _ = self.moderate_output(model_response)
        if output_blocked:
            return "Odgovor je bil filtriran zaradi neskladnosti."

        return model_response

# Uporaba
pipeline = ModerationPipeline(custom_threshold=0.5)
response = pipeline.process_message(
    "How do I protect my application against SQL injections?",
    "You are an expert in defensive cybersecurity."
)
print(response)

Česa ta API ne počne

Njegova najpomembnejša omejitev je hkrati tudi najbolj napačno razumljena: ne zazna vbrizgavanja pozivov (prompt injection). Vljudno sporočilo, ki je z vidika vsebine popolnoma neškodljivo, a od modela zahteva, da ignorira svoja navodila, bo šlo skozi brez sprožitve katere koli kategorije. Pričakovati, da bo ščitilo pred manipulacijo, je kot namestitev detektorja dima z upanjem, da bo ustavil vlomilce.

Lažno pozitivni rezultati so druga omejitev, še posebej občutljiva v varnostnih ali medicinskih kontekstih, kjer je opisovanje groženj del dela. Vsaki zahtevi se doda dodatni omrežni klic, kar je pomembno, ko ciljaš na odzive v realnem času. Zaznavanje ostaja zanesljivejše v angleščini kot v drugih jezikih, kar je slepa pega, ki jo napadalci odlično poznajo. Nazadnje, kategorije in pragovi se s posodobitvami spreminjajo: kalibracijski niz, star šest mesecev, si zasluži ponovno preverjanje.

Te omejitve narekujejo način uporabe orodja. Moderiraj v obe smeri, prilagodi pragove kategorija za kategorijo namesto globalno in ga sistematično kombiniraj z drugimi plastmi – zaznavanjem vbrizgavanj, filtriranjem poslovne logike –, ki jih podrobneje opisujejo naslednje lekcije. Beleži rezultate, saj je opazovanje lastnih lažno pozitivnih rezultatov način, kako se naučiš, kam premakniti drsnike. In načrtuj primer, ko API ni na voljo: odloči se zdaj, ko je mirno, ali naj tvoja aplikacija privzeto blokira ali prepušča promet, namesto da bi to vedenje odkril med incidentom.

Ključne ugotovitve

  • API za moderiranje je brezplačen, hiter in preprost za integracijo
  • Zazna žaljivo vsebino, ne pa vbrizgavanj ali prebojev (jailbreaks)
  • Cevovod vhod-model-izhod mora biti moderiran na obeh koncih
  • Privzeti pragovi redko ustrezajo – prilagodi jih svojemu kontekstu
  • Je ena izmed plasti, nikoli edina obrambna linija