Moderering av innehåll i stor skala
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation:
temperatureochtop_paccepteras endast med en resonemangsinsats (reasoning effort) pånone, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificerareasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.
Skydda dina användare i produktion
Så snart din applikation tas i drift måste du hantera olämpligt innehåll – både vid inmatning (skadliga prompts) och utmatning (problemfulla svar). Detta krav på två vägar tar ofta team på sängen. De flesta tänker först på att filtrera vad användare skickar, men ryktesrisken koncentreras till det din applikation publicerar under ditt namn. En väl avstämd modell genererar sällan chockerande innehåll på egen hand, men den kan göra det om den pressas – och ditt varumärke hamnar högst upp i skärmdumpen.
Vi går från ett enskilt API-anrop till en asynkron pipeline med hög genomströmning och skalar upp steg för steg.
Det första lagret: Moderations-API:t
Moderations-API:t klassificerar text över flera riskkategorier och returnerar både en binär dom och detaljerade poäng. Det är snabbt och gratis, vilket gör det till det naturliga första filtret för varje offentlig applikation. Funktionen nedan lyfter endast fram kategorier med poäng över 0,3 – en medvetet låg tröskel. I detta skede vill du se vad som närmar sig gränsen, inte bara vad som korsar den.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Kontrollera om text innehåller olämpligt innehåll."""
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
},
}
# Exempel
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flaggad: {result['flagged']}")
I produktion räcker inte en binär dom. Beroende på innehåll och kontext kan du vilja tillåta det, skriva om det, blockera det eller eskalera det till en människa – fyra distinkta beslut som du bör namnge explicit i koden istället för att improvisera med booleska värden. Pipelinen nedan formaliserar dessa åtgärder, tillämpar tröskelvärden per kategori och lägger till ett andra lager för detektering av prompt-injektion.
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:
"""Modereringspipeline i flera lager."""
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:
"""Moderera inmatat innehåll (användarprompt)."""
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"Olämpligt innehåll: {', '.join(problematic_categories)}",
)
# Detektering av prompt-injektion
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Försök till prompt-injektion upptäckt",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Moderera utmatat innehåll (LLM-svar)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Genererat svar innehåller olämpligt innehåll",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Detektera försök till prompt-injektion."""
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)
Tröskelvärdet 0,5 för self-harm – striktare än 0,7 som används för andra kategorier – illustrerar det resonemang du bör tillämpa på varje tröskel. Här är kostnaden för en falsk positiv långt ifrån kostnaden för en falsk negativ, så du sänker ribban. Gör denna avvägning kategori för kategori baserat på din målgrupp, istället för att tillämpa ett enhetligt värde.
Injektionsdetektering baserad på nyckelord har en hake. Den fångar naiva försök, vilket utgör bulkvolymen, och inget mer: en något annorlunda formulering eller en översatt version smiter igenom. Behandla det som ett brusfilter, inte ett försvar. Verkligt skydd mot injektion är arkitektoniskt – ge aldrig modellen förmågor som en kapad prompt skulle kunna utnyttja.
Hantera belastning
I en applikation med hög trafik blir synkron moderering en flaskhals: varje meddelande väntar på sin dom innan bearbetning fortsätter. En asynkron moderator kopplar bort dessa steg genom att köa innehåll för konsumtion av flera arbetare, samtidigt som den spårar användbar statistik längs vägen.
import asyncio
class AsyncModerator:
"""Moderera innehåll asynkront för hög genomströmning."""
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 "Inget innehåll modererat."
return (
f"Totalt: {total} | "
f"Tillåtet: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blockerat: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Blockeringsfrekvensen som produceras av report är din primära kalibreringsmetrik. Om den plötsligt hoppar till 15 % efter att ha legat på 0,5 % finns bara två förklaringar: du utsätts för en samordnad attack, eller så har du just förstört dina tröskelvärden. I båda fallen vill du veta det inom timmen, inte vid nästa månatliga genomgång.
En sista begränsning förtjänar att nämnas: Moderations-API:t vet ingenting om din verksamhet. Ett meddelande som är helt acceptabelt i allmänhet kan bryta mot dina egna regler – att begära medicinsk rådgivning från en bankassistent, försöka få en off-grid-taxa eller kringgå en procedur. Kontextuell moderering lägger till detta lager genom att skicka meddelandet till en modell med dina explicita regler, men först efter att standardfiltret har släppt igenom det.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Kontextmedveten moderering skräddarsydd för applikationen."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Applikationskontext: {app_context}\n\n"
f"Affärsregler att verifiera:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nAnvändarmeddelande: {text}\n\n"
"Uppfyller meddelandet alla regler? "
"Svara ja eller nej med en kort motivering."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kräver 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)
Ordningen på dessa två kontroller är avgörande. Det gratis, snabba filtret körs först, och anropet till den betalda modellen sker endast för meddelanden som passerar det. Vid riktig trafik täcker detta nästan alla meddelanden. Att göra tvärtom – att betala för ett modellanrop på innehåll som Moderations-API:t skulle ha avvisat på millisekunder – skulle vara slöseri.
Föra en försvarbar journal
Ett modereringsbeslut är ett beslut du kommer att hållas ansvarig för, på ett eller annat sätt. Du behöver en logg – men en som inte blir ett problem i sig själv. Kommentaren i koden lyfter fram den viktigaste raden i filen: registrera åtgärden, anledningen och längden, aldrig råtexten. Att lagra användarmeddelanden i en loggfil utsätter dig för dataskyddsskyldigheter som är långt tyngre än den tillhandahållna tjänsten.
import json
import time
from pathlib import Path
class ModerationLog:
"""Logga alla modereringsbeslut för granskning."""
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),
# LOGGA INTE råtext av integritetsskäl
}
with open(self.path, "a") as f:
f.write(json.dumps(entry) + "\n")
Om du ändå måste kunna hämta ett specifikt meddelande vid en tvist, logga en hash av texten istället för själva texten. Detta låter dig bekräfta att ett givet innehåll matchar ett registrerat beslut utan att behålla innehållet på din sida.
Viktiga punkter
- Moderera både inmatningar (prompts) och utmatningar (svar)
- Använd Moderations-API:t som ditt första, snabba och gratis lager
- Justera tröskelvärden kategori för kategori baserat på den verkliga kostnaden för en falsk negativ
- Lägg till injektionsdetektering med vetskap om att den bara fångar naiva försök
- Logga alla beslut för granskning utan att lagra råinnehåll