Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

OpenAI Moderációs API

5. lecke 14 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Beépített moderációs eszköz
  2. Mit ad vissza az API?
  3. Észlelt kategóriák
  4. A pipeline mindkét végének moderálása
  5. Amit ez az API nem csinál
  6. Főbb megállapítások

Frissítve: 2026. november 3. az OpenAI Moderation útmutatója alapján: hozzáadtuk az illicit kategóriát (és az illicit/violent alcategóriát), amely hiányzott a táblázatból, valamint a képekre vonatkozó kategóriákat. Forrás: Moderation.

Beépített moderációs eszköz

Az OpenAI egy ingyenes Moderációs API-t biztosít, amely elemzi a szöveget a potenciálisan káros tartalmak észlelésére. Ez az első védelmi vonal, amelyet integrálnod kell minden, OpenAI modelleket használó alkalmazásba, és nem korlátozódsz csak erre a felhasználási esetre: mivel nyers szöveget fogad bemenetként, arra is használhatod, hogy szűrje a más modelleknek szánt bemeneteket. Az ingyenesség megváltoztatja a problémához való hozzáállásodat. A szokásos kompromisszumok – moderáljunk minden kérést, vagy csak a gyanúsakat? – elveszítik súlyukat, mivel az egyetlen megmaradó költség a késleltetés.

Mit ad vissza az API?

Az alapvető hívás elfér egy sorban; a válasz az, ami figyelmet igényel. Az API három különböző dolgot ad vissza: egy flagged boolean értéket, amely az OpenAI döntését tükrözi, a ténylegesen kiváltott kategóriák listáját, és ami a legfontosabb, a folyamatos pontszámokat kategóriánként. Ezek a pontszámok jelentik a különbséget éles környezetben, mert lehetővé teszik, hogy te döntsd el, hol húzod meg a határt, ahelyett, hogy örökölnél egy általános használatra tervezett küszöbértéket.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analizálja a szöveget az OpenAI Moderációs API-ján keresztül."""
    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
        },
    }

# Tesztelés különböző tartalomtípusokkal
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())}")

A három teszt példa nem véletlenszerű: az elsőnek át kell mennie, a másodikat blokkolni kell, a harmadik – egy teljesen legitim technikai kérdés – pedig megmutatja, hogyan viselkedik a pipeline-od, amikor biztonsági szókincssel találkozik. Pontosan ez az a fajta kérés, amellyel egy kiberbiztonsági csapat nap mint nap foglalkozik.

Észlelt kategóriák

Az API több tengely mentén osztályozza a problémás tartalmakat, amelyek mindegyike a kár egy sajátos típusának felel meg.

Kategória Leírás
harassment Zaklatás, fenyegetés, megfélemlítés
hate Identitás alapú gyűlöletbeszéd
illicit Tanácsok vagy utasítások illegális cselekmények elkövetéséhez
self-harm Önbántalmazás, öngyilkosság
sexual Explicit szexuális tartalom
violence Grafikus erőszak, fenyegetés

Minden kategóriának vannak alcategóriái is (pl. harassment/threatening, illicit/violent, violence/graphic) a finomabb szűrés érdekében. Az omni-moderation-latest modellel csak a self-harm és variánsai, a sexual, valamint a violence (a violence/graphic-kel együtt) vonatkoznak képekre is; a többi kategória csak szövegre érvényes. Ez a szemcsézettség megkímél attól, hogy durva kompromisszumokat köss: egy fórum moderációs platform például blokkolhatja a harassment/threatening tartalmakat, miközben tolerálja az egyszerű harassment-et, amely sok hétköznapi vitát lefed.

Amikor nagy mennyiséget kell feldolgoznod – például egy beszélgetési előzmény utólagos elemzése –, az API elfogad egy listát, és minden elemre külön eredményt ad vissza, elkerülve a többszörös hálózati körutakat.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Több üzenet moderálása egyetlen hívásban."""
    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

A pipeline mindkét végének moderálása

Gyakori hiba, ha csak a bemeneteket moderálod. Ez hamis intuícióra épül: ha a bejövő üzenet elfogadható, a válasz is az lesz. Egy modell azonban problémás tartalmat is generálhat semleges kérésből, különösen akkor, ha olyan lekért dokumentumokra támaszkodik, amelyek tartalmát senki nem ellenőrizte. Az alábbi osztály ezért mindkét irányban ugyanazt a kezelést alkalmazza, hozzáadva egy egyéni küszöbértéket, amely szigorítja az API alapértelmezett döntését.

class ModerationPipeline:
    """Bemeneti + kimeneti moderációs pipeline LLM alkalmazásokhoz."""

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

    def moderate_input(self, message: str) -> tuple[bool, dict]:
        """Az üzenet moderálása MIELŐTT elküldenénk a modellnek."""
        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]:
        """A modell válaszának moderálása MIELŐTT elküldenénk a felhasználónak."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Teljes pipeline: bemeneti moderálás, LLM, kimeneti moderálás."""
        # 1. lépés: bemenet moderálása
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Az üzenetedet nem lehet feldolgozni. Kérlek, fogalmazd át."

        # 2. lépés: modell hívása
        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. lépés: kimenet moderálása
        output_blocked, _ = self.moderate_output(model_response)
        if output_blocked:
            return "A választ szűrtük a megfelelőség hiánya miatt."

        return model_response

# Használat
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)

Amit ez az API nem csinál

A legfontosabb korlátja egyben a legfélreértettebb is: nem észleli a prompt injection támadásokat. Egy udvarias üzenet, amely tartalmi szempontból teljesen ártalmatlan, de arra kéri a modellt, hogy hagyja figyelmen kívül az utasításait, átmegy anélkül, hogy bármelyik kategóriát kiváltaná. Azt várni tőle, hogy megvédjen a manipulációtól, olyan, mint füstérzékelőt telepíteni, és remélni, hogy megállítja a betörőket.

A hamis pozitív eredmények a második korlát, amelyek különösen érzékenyek biztonsági vagy orvosi kontextusban, ahol a fenyegetés leírása a munka része. Minden kéréshez hozzáadódik egy további hálózati hívás, ami számít, ha valós idejű válaszokra törekszel. Az észlelés angol nyelven megbízhatóbb, mint más nyelveken; ez egy vakfolt, amelyet a támadók tökéletesen ismernek. Végül a kategóriák és küszöbértékek a frissítésekkel evolvesznek: egy hat hónappal ezelőtt kalibrált készlet újraellenőrzést érdemel.

Ezek a korlátok diktálják az eszköz használatát. Moderálj mindkét irányban, állítsd be a küszöbértékeket kategóriánként a globális helyett, és szisztematikusan kombináld más rétegekkel – injection észlelés, üzleti logika szűrés –, amelyeket a következő leckék részleteznek. Naplózd az eredményeket, mert a saját hamis pozitívjaid megfigyelése révén tanulod meg, hol kell elmozdítani a csúszkákat. És tervezz arra az esetre, ha az API nem elérhető: döntsd el most, míg nyugalom van, hogy az alkalmazásod alapértelmezetten blokkoljon-e, vagy engedje át a forgalmat, ahelyett, hogy egy incidens során fedeznéd fel ezt a viselkedést.

Főbb megállapítások

  • A Moderációs API ingyenes, gyors és egyszerűen integrálható
  • Észleli a sértő tartalmakat, de nem az injectionöket vagy a jailbreakeket
  • A bemenet-modell-kimenet pipeline-t mindkét végén moderálni kell
  • Az alapértelmezett küszöbértékek ritkán illenek – igazítsd őket a kontextusodhoz
  • Ez csak egy réteg a többi között, soha nem az egyetlen védelmi vonal