Tartalommoderálás nagy léptékben
Ezen az oldalon
Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a
temperatureés atop_pparaméterek csaknonegondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk areasoning={"effort": "none"}(Responses API) vagyreasoning_effort="none"(Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.
Felhasználóid védelme éles környezetben
Amint az alkalmazásod élesbe kerül, kezelned kell a nem megfelelő tartalmakat – mind a bemenetnél (rosszindulatú promptok), mind a kimenetnél (problémás válaszok). Ezt a kétirányú követelményt sok csapat figyelmen kívül hagyja. A legtöbben először a felhasználók által küldött adatok szűrésére gondolnak, pedig a hírnévkockázat főként abban rejlik, amit az alkalmazásod a te nevedben tesz közzé. Egy jól igazított modell ritkán generál sokkoló tartalmat magától, de ha nyomás alá helyezik, képes rá – és a márkád neve lesz a képernyőfotó tetején.
Lépésről lépésre haladunk: egyetlen API-hívástól indulunk el egy nagy átviteli sebességű, aszinkron folyamatrendszer felé.
Az első réteg: a Moderations API
A Moderations API több kockázati kategória szerint osztályozza a szöveget, és egyszerre ad vissza bináris döntést és részletes pontszámokat. Gyors és ingyenes, így bármely nyilvános alkalmazás természetes első szűrője. Az alábbi függvény csak azokat a kategóriákat emeli ki, amelyek pontszáma meghaladja a 0,3-at – ez szándékosan alacsony küszöb. Ebben a szakaszban nemcsak azt akarod látni, ami átlépi a határt, hanem azt is, ami közelít hozzá.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Ellenőrzi, hogy a szöveg tartalmaz-e nem megfelelő tartalmat."""
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
},
}
# Példa
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
Éles környezetben a bináris döntés önmagában nem elég. A tartalomtól és a kontextustól függően engedélyezned kell azt, át kell írnod, blokkolnod, vagy emberi ellenőrzésre kell escalálnod – ez négy különálló döntés, amelyet explicit módon kell elnevezned a kódban, nem pedig boole változókkal improvizálni. Az alábbi folyamatrendszer formalizálja ezeket a műveleteket, kategóriánkénti küszöbértékeket alkalmaz, és hozzáad egy második réteget a prompt-injekciók észlelésére.
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:
"""Többrétegű moderálási folyamatrendszer."""
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:
"""Bemeneti tartalom (felhasználói prompt) moderálása."""
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"Nem megfelelő tartalom: {', '.join(problematic_categories)}",
)
# Prompt-injekció észlelése
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Prompt-injekciós kísérlet észlelve",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Kimeneti tartalom (LLM-válasz) moderálása."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="A generált válasz nem megfelelő tartalmat tartalmaz",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Prompt-injekciós kísérletek észlelése."""
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)
A self-harm kategóriára vonatkozó 0,5-ös küszöb – amely szigorúbb, mint a többi kategóriára alkalmazott 0,7 – jól szemlélteti azt a logikát, amelyet minden küszöbértéknél alkalmaznod kell. Itt a hamis pozitív döntés költsége messze elmarad a hamis negatív döntés költségétől, ezért lejjebb viszed a lécet. Ezt a kompromisszumot kategóriánként, a saját közönséged alapján kell meghoznod, nem pedig egységes értéket alkalmazni.
A jelölőalapú injekcióészlelésnek van egy szépséghibája. Csak a naiv kísérleteket fogja el, amelyek a forgalom nagy részét teszik ki, de semmi mást: egy kissé eltérő megfogalmazás vagy egy lefordított változat átszökik a rostán. Tekints rá zajszűrőként, nem pedig védelemként. Az injekciók elleni valódi védelem architektúrális kérdés – soha ne adj a modellnek olyan képességeket, amelyeket egy eltérített prompt kihasználhatna.
Terhelés kezelése
Nagy forgalmú alkalmazásoknál a szinkron moderálás szűk keresztmetszetté válik: minden üzenet vár a döntésre, mielőtt feldolgoznák. Egy aszinkron moderátor szétválasztja ezeket a lépéseket: a tartalmat sorba állítja, hogy több munkafolyamat (worker) fogyaszthassa, miközben hasznos statisztikákat is gyűjt menet közben.
import asyncio
class AsyncModerator:
"""Tartalom aszinkron moderálása nagy átviteli sebesség érdekében."""
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 "Nem történt tartalommoderálás."
return (
f"Összesen: {total} | "
f"Engedélyezve: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blokkolva: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
A report által előállított blokkolási arány az elsődleges kalibrációs metrikád. Ha hirtelen 0,5%-ról 15%-ra ugrik, csak két magyarázat lehetséges: koordinált támadás alatt állsz, vagy éppen elrontottad a küszöbértékeidet. Mindkét esetben órákon belül tudnod kell róla, nem a következő havi értékelésen.
Érdemes megemlíteni egy utolsó korlátot is: a Moderations API semmit sem tud a te üzletedről. Egy üzenet, amely általánosságban teljesen elfogadható, sértheti a te saját szabályaidat – például orvosi tanácsot kér egy banki asszisztenstől, próbál off-grid árat szerezni, vagy megkerülni egy eljárást. A kontextuális moderálás ezt a réteget adja hozzá: az üzenetet elküldi egy modellnek a te explicit szabályaiddal, de csak azután, hogy a szabványos szűrő engedélyezte azt.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Az alkalmazásra szabott, kontextusfüggő moderálás."""
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)
Ennek a két ellenőrzésnek a sorrendje számít. Az ingyenes, gyors szűrő fut először, és a fizetett modellhívás csak azokon az üzeneteken történik meg, amelyek átmentek rajta. Valós forgalom esetén ez az üzenetek szinte teljes körét lefedi. Fordítva csinálni – vagyis fizetni egy modellhívásért olyan tartalom esetén, amelyet a Moderations API milliszekundumok alatt elutasított volna – pazarlás lenne.
Védhető napló vezetése
A moderálási döntés olyan döntés, amelyért előbb-utóbb felelősségre vonnak. Naplót kell vezetned – de olyat, amely maga nem válik problémává. A kódban lévő megjegyzés kiemeli a fájl legfontosabb sorát: rögzítsd a műveletet, az indoklást és a hosszúságot, soha ne a nyers szöveget. A felhasználói üzenetek naplófájlban történő tárolása olyan adatvédelmi kötelezettségeknek tesz ki, amelyek sokkal súlyosabbak, mint maga a nyújtott szolgáltatás.
import json
import time
from pathlib import Path
class ModerationLog:
"""Minden moderálási döntés naplózása auditálási céllal."""
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")
Ha mégis szükség van arra, hogy vita esetén egy adott üzenetet vissza tudj keresni, akkor a szöveg hash-értékét naplózd a szöveg helyett. Ez lehetővé teszi, hogy megerősítsd: egy adott tartalom megegyezik egy rögzített döntéssel, anélkül, hogy magát a tartalmat megtartanád a saját oldaladon.
Főbb megállapítások
- Moderáld mind a bemeneteket (promptok), mind a kimeneteket (válaszok)
- Használd a Moderations API-t első, gyors és ingyenes rétegként
- Állítsd be a küszöbértékeket kategóriánként a hamis negatív döntés valós költsége alapján
- Adj hozzá injekcióészlelést, tudva, hogy csak a naiv kísérleteket fogja el
- Naplózz minden döntést auditálás céljából, nyers tartalom tárolása nélkül