Salt la conținutul principal
Română— Alege o limbă
Meniu

API-ul de Moderare OpenAI

Lecția 5 din 14 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Un instrument de moderare integrat
  2. Ce returnează API-ul
  3. Categorii detectate
  4. Moderarea ambelor capete ale pipeline-ului
  5. Ce nu face acest API
  6. Puncte cheie

Actualizat la 3 noiembrie 2026 pe baza ghidului Moderation de la OpenAI: am adăugat categoria illicit (și illicit/violent), care lipsea din tabel, împreună cu categoriile care se aplică imaginilor. Sursă: Moderation.

Un instrument de moderare integrat

OpenAI pune la dispoziție un API de Moderare gratuit care analizează textul pentru a detecta conținut potențial dăunător. Aceasta este prima linie de apărare pe care trebuie să o integrați în orice aplicație care utilizează modele OpenAI, iar utilizarea nu se limitează doar la acest caz: deoarece acceptă text brut ca intrare, îl puteți folosi și pentru a filtra intrările destinate altor modele. Faptul că este gratuit schimbă modul în care abordați problema. Compromisurile obișnuite—ar trebui să moderăm fiecare cerere sau doar pe cele suspecte?—își pierd greutatea, deoarece singurul cost rămas este latența.

Ce returnează API-ul

Apelul de bază încap pe un singur rând; răspunsul este cel care necesită atenție. API-ul returnează trei elemente distincte: un boolean flagged care reflectă decizia OpenAI, lista categoriilor declanșate efectiv și, cel mai important, scoruri continue per categorie. Aceste scoruri fac diferența în producție, deoarece vă permit să decideți singuri unde trageți linia, în loc să moșteniți un prag conceput pentru uz generic.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analizează textul prin intermediul API-ului de Moderare 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
        },
    }

# Testare cu diferite tipuri de conținut
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())}")

Cele trei exemple de test nu sunt aleatorii: primul ar trebui să treacă, al doilea ar trebui blocat, iar al treilea—o întrebare tehnică perfect legitimă—vă arată cum se comportă pipeline-ul dumneavoastră atunci când este confruntat cu vocabular de securitate. Acesta este exact genul de cerere pe care o echipă de securitate cibernetică o gestionează zilnic.

Categorii detectate

API-ul clasifică conținutul problematic pe mai multe axe, fiecare corespunzând unui tip distinct de prejudiciu.

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

Fiecare categorie are, de asemenea, subcategorii (de exemplu, harassment/threatening, illicit/violent, violence/graphic) pentru o filtrare mai fină. Cu omni-moderation-latest, doar self-harm și variantele sale, sexual și violence (cu violence/graphic) se aplică și imaginilor; celelalte categorii se aplică doar textului. Această granularitate vă scutește de a face compromisuri grosiere: o platformă de moderare a forumurilor ar putea dori să blocheze harassment/threatening, tolerând în același timp simpla harassment, care acoperă multe dispute obișnuite.

Când trebuie să procesați volume mari—de exemplu, o analiză retrospectivă a istoricului unei conversații—API-ul acceptă o listă și returnează un rezultat pentru fiecare element, evitând astfel multiple dus-întorsuri prin rețea.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Moderează mai multe mesaje într-un singur apel."""
    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

Moderarea ambelor capete ale pipeline-ului

O greșeală frecventă este moderarea doar a intrărilor. Aceasta se bazează pe o intuiție falsă: dacă mesajul incoming este acceptabil, și răspunsul va fi la fel. Totuși, un model poate produce conținut problematic pornind de la o cerere neutră, mai ales când se bazează pe documente recuperate al căror conținut nu a fost verificat de nimeni. Clasa de mai jos aplică, prin urmare, același tratament în ambele direcții, adăugând un prag personalizat care înăsprește decizia implicită a API-ului.

class ModerationPipeline:
    """Pipeline de moderare input + output pentru o aplicație 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]:
        """Moderează mesajul ÎNAINTE de a-l trimite modelului."""
        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]:
        """Moderează răspunsul modelului ÎNAINTE de a-l trimite utilizatorului."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Pipeline complet: moderare input, LLM, moderare output."""
        # Pasul 1: moderare input
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Your message cannot be processed. Please rephrase it."

        # Pasul 2: apelarea modelului
        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

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

        return model_response

# Utilizare
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)

Ce nu face acest API

Cea mai importantă limitare este și cea mai puțin înțeleasă: nu detectează injectarea de prompturi (prompt injection). Un mesaj politicos, perfect inofensiv din perspectiva conținutului, dar care cere modelului să își ignore instrucțiunile, va trece fără a declanșa nicio categorie. A te aștepta să te protejeze împotriva manipulării este ca și cum ai instala un detector de fum sperând că va opri hoții.

Fals pozitivele reprezintă a doua limitare, fiind deosebit de sensibile în contexte de securitate sau medicale, unde descrierea unei amenințări face parte din activitatea curentă. Se adaugă un apel de rețea suplimentar la fiecare cerere, lucru care contează când vizați răspunsuri în timp real. Detecția rămâne mai fiabilă în engleză decât în alte limbi, un punct orb pe care atacatorii îl cunosc perfect. În final, categoriile și pragurile evoluează odată cu actualizările: un set de calibrare realizat acum șase luni merită reverificat.

Aceste limite dictează modul de utilizare a instrumentului. Moderați în ambele direcții, ajustați pragurile categorie cu categorie în loc de global și combinați-l sistematic cu alte straturi—detecția injecțiilor, filtrarea logicii de afaceri—pe care lecțiile următoare le detaliază. Înregistrați rezultatele, deoarece observarea propriilor fals pozitive este modul în care învățați unde să mutați cursoarele. Și planificați cazul în care API-ul nu este disponibil: decideți acum, cât timp lucrurile sunt calme, dacă aplicația dumneavoastră ar trebui să blocheze implicit sau să lase traficul să treacă, în loc să descoperiți acel comportament în timpul unui incident.

Puncte cheie

  • API-ul de Moderare este gratuit, rapid și simplu de integrat
  • Detectează conținut ofensiv, dar nu injecții sau jailbreak-uri
  • Pipeline-ul input-model-output trebuie moderat la ambele capete
  • Pragurile implicite rareori se potrivesc—adaptați-le la contextul dumneavoastră
  • Este un strat printre altele, niciodată singura linie de apărare