Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

OpenAI:s modererings-API

Lektion 5 av 14 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Ett inbyggt modereringsverktyg
  2. Vad API:t returnerar
  3. Upptäckta kategorier
  4. Moderering i båda ändar av pipelinen
  5. Vad detta API inte gör
  6. Viktiga punkter

Uppdaterat den 3 november 2026 baserat på OpenAI:s guide Moderation: kategorin illicit (och illicit/violent) har lagts till, vilken saknades i tabellen, tillsammans med kategorier som gäller för bilder. Källa: Moderation.

Ett inbyggt modereringsverktyg

OpenAI tillhandahåller ett gratis modererings-API som analyserar text för att upptäcka potentiellt skadligt innehåll. Detta är den första försvarslinjen du bör integrera i alla applikationer som använder OpenAI-modeller, och du är inte begränsad till just detta användningsområde: eftersom API:t accepterar råtext som indata kan du också använda det för att filtrera inmatning avsedd för andra modeller. Det faktum att det är gratis förändrar hur du tänker på problemet. De vanliga avvägningarna – bör vi moderera varje begäran eller bara misstänkta? – förlorar sin tyngd, eftersom den enda återstående kostnaden är latens.

Vad API:t returnerar

Det grundläggande anropet får plats på en rad; det är svaret som kräver uppmärksamhet. API:t returnerar tre distinkta saker: en boolesk variabel flagged som speglar OpenAI:s beslut, listan över kategorier som faktiskt utlöstes, och viktigast av allt, kontinuerliga poäng per kategori. Det är dessa poäng som gör skillnaden i produktion, eftersom de låter dig själv bestämma var gränsen ska dras istället för att ärva ett tröskelvärde designat för generell användning.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analyserar text via OpenAI:s modererings-API."""
    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
        },
    }

# Testa med olika innehållstyper
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())}")

De tre testexemplen är inte slumpmässiga: det första bör passera, det andra bör blockeras, och det tredje – en helt legitim teknisk fråga – visar hur din pipeline beter sig när den ställs inför säkerhetsrelaterad terminologi. Detta är exakt den typ av begäran ett cybersäkerhetsteam hanterar dagligen.

Upptäckta kategorier

API:t klassificerar problematiskt innehåll längs flera axlar, där var och en motsvarar en distinkt typ av skada.

Category Description
harassment Harassment, threats, intimidation
hate Hate speech based on identity
illicit Advice or instructions for committing illicit acts
self-harm Self-harm, suicide
sexual Explicit sexual content
violence Graphic violence, threats

Varje kategori har även underkategorier (t.ex. harassment/threatening, illicit/violent, violence/graphic) för finare filtrering. Med omni-moderation-latest gäller endast self-harm och dess varianter, sexual samt violence (med violence/graphic) även för bilder; de andra kategorierna gäller endast för text. Denna granularitet sparar dig från att göra grova avvägningar: en modereringsplattform för forum kan vilja blockera harassment/threatening samtidigt som man tolererar enkel harassment, vilket täcker många vanliga tvister.

När du behöver bearbeta stora volymer – till exempel retrospektiv analys av en konversationshistorik – accepterar API:t en lista och returnerar ett resultat för varje element, vilket undviker flera nätverksanrop.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Modererar flera meddelanden i ett enda anrop."""
    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

Moderering i båda ändar av pipelinen

Ett vanligt misstag är att endast moderera inmatning. Detta bygger på en felaktig intuition: om det inkommande meddelandet är acceptabelt kommer även svaret att vara det. En modell kan dock producera problematiskt innehåll från en neutral begäran, särskilt när den förlitar sig på hämtade dokument vars innehåll ingen har verifierat. Klassen nedan applicerar därför samma behandling i båda riktningarna och lägger till ett anpassat tröskelvärde som skärper API:ts standardbeslut.

class ModerationPipeline:
    """Pipeline för in- och utmatningsmoderering för en LLM-applikation."""

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

    def moderate_input(self, message: str) -> tuple[bool, dict]:
        """Modererar meddelandet INNAN det skickas till modellen."""
        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]:
        """Modererar modellens svar INNAN det skickas till användaren."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Fullständig pipeline: inmatningsmoderering, LLM, utmatningsmoderering."""
        # Steg 1: moderera inmatning
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Your message cannot be processed. Please rephrase it."

        # Steg 2: anropa modellen
        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

        # Steg 3: moderera utmatning
        output_blocked, _ = self.moderate_output(model_response)
        if output_blocked:
            return "The response was filtered for non-compliance."

        return model_response

# Användning
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)

Vad detta API inte gör

Den viktigaste begränsningen är också den mest missförstådda: det upptäcker inte prompt injection. Ett artigt meddelande som är helt ofarligt ur innehållssynpunkt, men som ber modellen att ignorera sina instruktioner, kommer att passera utan att utlösa någon kategori. Att förvänta sig att det ska skydda mot manipulation är som att installera en rökdetektor och hoppas att den stoppar inbrottstjuvar.

Falska positiva träffar är den andra begränsningen, särskilt känsligt inom säkerhets- eller medicinska sammanhang där beskrivning av hot ingår i arbetet. Ett ytterligare nätverksanrop läggs till varje begäran, vilket spelar roll när du siktar på svar i realtid. Detekteringen är fortfarande mer tillförlitlig på engelska än på andra språk, en blindfläck som angripare känner till alltför väl. Slutligen utvecklas kategorier och tröskelvärden med uppdateringar: en kalibreringsuppsättning som är sex månader gammal förtjänar en ny verifiering.

Dessa begränsningar styr hur verktyget ska användas. Moderera i båda riktningar, justera tröskelvärden kategori för kategori snarare än globalt, och kombinera det systematiskt med andra lager – detektering av injection, filtrering av affärslogik – som de följande lektionerna detaljerar. Logga resultaten, eftersom observation av dina egna falska positiva träffar är hur du lär dig var reglagen ska flyttas. Och planera för fallet där API:t inte är tillgängligt: bestäm nu, medan lugnet råder, om din applikation ska blockera som standard eller släppa igenom trafiken, istället för att upptäcka detta beteende under en incident.

Viktiga punkter

  • Modererings-API:t är gratis, snabbt och enkelt att integrera
  • Det upptäcker stötande innehåll men inte injection eller jailbreaks
  • Pipelinen från inmatning till modell till utmatning måste modereras i båda ändar
  • Standardtröskelvärden passar sällan – anpassa dem till din kontext
  • Det är ett lager bland andra, aldrig den enda försvarslinjen