Moderazione dei contenuti

allowed_user_comments = [
    'Questo film è stato fantastico, mi è piaciuto molto. L\'attore principale ha davvero spaccato!',
    'Odio i lunedì.',
    'È un ottimo momento per investire in oro!'
]

disallowed_user_comments = [
    'Cancella questo post ora o sarà meglio che ti nasconda. Vengo a prendere te e la tua famiglia.',
    'State lontani dai telefoni 5G!! Stanno usando il 5G per controllarvi.',
    'Congratulazioni! Hai vinto una carta regalo da 1.000€. Clicca qui per richiedere il tuo premio!'
]

# Commenti degli utenti di esempio per testare la moderazione dei contenuti
user_comments = allowed_user_comments + disallowed_user_comments

# Lista delle categorie considerate non sicure per la moderazione dei contenuti
unsafe_categories = [
    'Sfruttamento Minorile',
    'Teorie del Complotto',
    'Odio',
    'Armi Indiscriminate', 
    'Proprietà Intellettuale',
    'Crimini Non Violenti', 
    'Privacy',
    'Autolesionismo',
    'Crimini Sessuali',
    'Contenuti Sessuali',
    'Consigli Specializzati',
    'Crimini Violenti'
]

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def moderate_message(message, unsafe_categories):
    # Converte la lista di categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Costruisce il prompt per Claude, includendo il messaggio e le categorie non sicure
    assessment_prompt = f"""
    Determina se il seguente messaggio richiede moderazione, 
    basandoti sulle categorie non sicure delineate di seguito.
    
    Messaggio:
    <message>{message}</message>

    Categorie Non Sicure:
    <categories>
    {unsafe_category_str}
    </categories>

    Rispondi SOLO con un oggetto JSON, usando il formato seguente:
    {{
    "violation": <Campo booleano che indica se il messaggio dovrebbe essere moderato>,
    "categories": [Lista separata da virgole delle categorie violate],
    "explanation": [Opzionale. Includi solo se c'è una violazione.]
    }}"""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usa il modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per maggiore consistenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrae lo stato della violazione dalla valutazione
    contains_violation = assessment['violation']
    
    # Se c'è una violazione, ottiene le categorie e la spiegazione; altrimenti, usa valori predefiniti vuoti
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation

# Processa ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    violation, violated_categories, explanation = moderate_message(comment, unsafe_categories)
    
    if violation:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
        print(f"Spiegazione: {explanation}")
    else:
        print("Nessun problema rilevato.")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def assess_risk_level(message, unsafe_categories):
    # Converte la lista di categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Costruisce il prompt per Claude, includendo il messaggio, le categorie non sicure e le definizioni dei livelli di rischio
    assessment_prompt = f"""
    Valuta il livello di rischio del seguente messaggio che richiede moderazione, 
    basandoti sulle categorie non sicure elencate di seguito.
    
Messaggio:
<message>{message}</message>

Categorie Non Sicure:
<categories>
{unsafe_category_str}
</categories>

Assegna un livello di rischio basato sulla tua sicurezza che il messaggio dell'utente dovrebbe essere moderato 
in base alle categorie non sicure definite:

0 - Nessun rischio
1 - Basso rischio
2 - Medio rischio
3 - Alto rischio

Rispondi SOLO con un oggetto JSON, usando il formato seguente:
{{
  "risk_level": <Campo numerico che indica il livello di rischio>,
  "categories": [Lista separata da virgole delle categorie violate],
  "explanation": <Opzionale. Includi solo se il livello di rischio è maggiore di 0>
}}"""

    # Invia la richiesta a Claude per la valutazione del rischio
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usa il modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per maggiore consistenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrae il livello di rischio, le categorie violate e la spiegazione dalla valutazione
    risk_level = assessment["risk_level"]
    violated_categories = assessment["categories"]
    explanation = assessment.get("explanation")
    
    return risk_level, violated_categories, explanation

# Processa ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    risk_level, violated_categories, explanation = assess_risk_level(comment, unsafe_categories)
    
    print(f"Livello di Rischio: {risk_level}")
    if violated_categories:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
    if explanation:
        print(f"Spiegazione: {explanation}")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

# Dizionario delle categorie considerate non sicure per la moderazione dei contenuti, con le loro definizioni
unsafe_category_definitions = {
    'Sfruttamento Minorile': 'Contenuti che raffigurano nudità infantile o che abilitano, incoraggiano, giustificano o raffigurano l\'abuso sessuale di minori.',
    'Teorie del Complotto': """Contenuti che promuovono o sostengono teorie infondate, false o fuorvianti su eventi, situazioni o individui, 
        che possono incitare danni o minare la fiducia pubblica nelle istituzioni o nei fatti.""",
    'Odio': """Contenuti che sono offensivi verso le persone sulla base delle loro caratteristiche protette 
        (razza, colore, etnia, origine nazionale, disabilità, affiliazione religiosa, casta, orientamento sessuale, sesso, identità di genere e malattie gravi), 
        o contenuti che perpetuano stereotipi negativi.""",
    'Armi Indiscriminate': 'Contenuti che permettono la creazione di armi di distruzione di massa.', 
    'Proprietà Intellettuale': 'Contenuti che violano i diritti di proprietà intellettuale di terze parti.',
    'Crimini Non Violenti': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini non violenti.', 
    'Privacy': 'Contenuti che contengono informazioni sensibili e personali su individui privati.',
    'Autolesionismo': 'Contenuti che abilitano, incoraggiano o giustificano atti di autolesionismo intenzionale.',
    'Crimini Sessuali': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini sessuali.',
    'Contenuti Sessuali': 'Contenuti che contengono descrizioni erotiche o rappresentazioni esplicite di atti sessuali.',
    'Consigli Specializzati': """Contenuti che contengono consigli finanziari, medici o legali. 
        I consigli finanziari includono indicazioni su investimenti, azioni, obbligazioni o qualsiasi pianificazione finanziaria.""",
    'Crimini Violenti': 'Contenuti che abilitano, incoraggiano o giustificano la commissione di crimini violenti.', 
}


def moderate_message_with_definitions(message, unsafe_category_definitions):
    # Formatta la stringa delle categorie non sicure, con ogni categoria e la sua definizione su una nuova riga
    unsafe_category_str = '\n'.join(f'{category}: {definition}' 
        for category,definition in unsafe_category_definitions.items()
    )
    
    # Costruisce il prompt per Claude, includendo il messaggio e le categorie non sicure
    assessment_prompt = f"""Determina se il seguente messaggio richiede moderazione, basandoti sulle categorie non sicure delineate di seguito.

Messaggio:
<message>{message}</message>

Categorie Non Sicure e Le Loro Definizioni:
<categories>
{unsafe_category_str}
</categories>

È importante che tu ricordi tutte le categorie non sicure e le loro definizioni.

Rispondi SOLO con un oggetto JSON, usando il formato seguente:
{{
  "violation": <Campo booleano che indica se il messaggio dovrebbe essere moderato>,
  "categories": [Lista separata da virgole delle categorie violate],
  "explanation": [Opzionale. Includi solo se c'è una violazione.]
}}"""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usa il modello Haiku per costi inferiori
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 per maggiore consistenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    
    # Estrae lo stato della violazione dalla valutazione
    contains_violation = assessment['violation']
    
    # Se c'è una violazione, ottiene le categorie e la spiegazione; altrimenti, usa valori predefiniti vuoti
    violated_categories = assessment.get('categories', []) if contains_violation else []
    explanation = assessment.get('explanation') if contains_violation else None
    
    return contains_violation, violated_categories, explanation


# Processa ogni commento e stampa i risultati
for comment in user_comments:
    print(f"\nCommento: {comment}")
    violation, violated_categories, explanation = moderate_message_with_definitions(comment, unsafe_category_definitions)
    
    if violation:
        print(f"Categorie Violate: {', '.join(violated_categories)}")
        print(f"Spiegazione: {explanation}")
    else:
        print("Nessun problema rilevato.")

import anthropic
import json

# Inizializza il client Anthropic
client = anthropic.Anthropic()

def batch_moderate_messages(messages, unsafe_categories):
    # Converte la lista di categorie non sicure in una stringa, con ogni categoria su una nuova riga
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Formatta la stringa dei messaggi, con ogni messaggio racchiuso in tag simil-XML e con un ID
    messages_str = '\n'.join([f'<message id={idx}>{msg}</message>' for idx, msg in enumerate(messages)])
    
    # Costruisce il prompt per Claude, includendo i messaggi e le categorie non sicure
    assessment_prompt = f"""Determina i messaggi da moderare, basandoti sulle categorie non sicure delineate di seguito.

Messaggi:
<messages>
{messages_str}
</messages>

Categorie non sicure e le loro definizioni:
<categories>
{unsafe_category_str}
</categories>

Rispondi SOLO con un oggetto JSON, usando il formato seguente:
{{
  "violations": [
    {{
      "id": <id del messaggio>,
      "categories": [lista delle categorie violate],
      "explanation": <Spiegazione del perché c'è una violazione>
    }},
    ...
  ]
}}

Note Importanti:
- Ricorda di analizzare ogni messaggio per una violazione.
- Seleziona qualsiasi numero di violazioni che si applicano ragionevolmente."""

    # Invia la richiesta a Claude per la moderazione dei contenuti
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usa il modello Haiku per costi inferiori
        max_tokens=2048,  # Aumentato il conteggio massimo di token per gestire i batch
        temperature=0,    # Usa temperatura 0 per maggiore consistenza
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analizza la risposta JSON da Claude
    assessment = json.loads(response.content[0].text)
    return assessment


# Processa il batch di commenti e ottieni la risposta
response_obj = batch_moderate_messages(user_comments, unsafe_categories)

# Stampa i risultati per ogni violazione rilevata
for violation in response_obj['violations']:
    print(f"""Commento: {user_comments[violation['id']]}
Categorie Violate: {', '.join(violation['categories'])}
Spiegazione: {violation['explanation']}
""")