Moderação de conteúdo

allowed_user_comments = [
    'Este filme foi ótimo, eu realmente gostei. O ator principal arrasou!',
    'Eu odeio segundas-feiras.',
    'É um ótimo momento para investir em ouro!'
]

disallowed_user_comments = [
    'Delete este post agora ou é melhor você se esconder. Estou indo atrás de você e sua família.',
    'Fique longe dos celulares 5G!! Eles estão usando 5G para controlar você.',
    'Parabéns! Você ganhou um vale-presente de R$ 1.000. Clique aqui para resgatar seu prêmio!'
]

# Comentários de usuários de exemplo para testar a moderação de conteúdo
user_comments = allowed_user_comments + disallowed_user_comments

# Lista de categorias consideradas inseguras para moderação de conteúdo
unsafe_categories = [
    'Exploração Infantil',
    'Teorias da Conspiração',
    'Ódio',
    'Armas Indiscriminadas', 
    'Propriedade Intelectual',
    'Crimes Não Violentos', 
    'Privacidade',
    'Automutilação',
    'Crimes Sexuais',
    'Conteúdo Sexual',
    'Conselhos Especializados',
    'Crimes Violentos'
]

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def moderate_message(message, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Constrói o prompt para o Claude, incluindo a mensagem e categorias inseguras
    assessment_prompt = f"""
    Determine se a seguinte mensagem requer moderação, 
    com base nas categorias inseguras descritas abaixo.
    
    Mensagem:
    <message>{message}</message>

    Categorias Inseguras:
    <categories>
    {unsafe_category_str}
    </categories>

    Responda APENAS com um objeto JSON, usando o formato abaixo:
    {{
    "violation": <Campo booleano indicando se a mensagem deve ser moderada>,
    "categories": [Lista separada por vírgulas das categorias violadas],
    "explanation": [Opcional. Incluir apenas se houver uma violação.]
    }}"""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o status de violação da avaliação
    contains_violation = assessment['violation']
    
    # Se houver uma violação, obtém as categorias e explicação; caso contrário, usa padrões vazios
    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 cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    violation, violated_categories, explanation = moderate_message(comment, unsafe_categories)
    
    if violation:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
        print(f"Explicação: {explanation}")
    else:
        print("Nenhum problema detectado.")

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def assess_risk_level(message, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Constrói o prompt para o Claude, incluindo a mensagem, categorias inseguras e definições de nível de risco
    assessment_prompt = f"""
    Avalie o nível de risco da seguinte mensagem requer moderação, 
    com base nas categorias inseguras listadas abaixo.
    
Mensagem:
<message>{message}</message>

Categorias Inseguras:
<categories>
{unsafe_category_str}
</categories>

Atribua um nível de risco com base em sua confiança de que a mensagem do usuário deve ser moderada 
com base nas categorias inseguras definidas:

0 - Sem risco
1 - Baixo risco
2 - Risco médio
3 - Alto risco

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "risk_level": <Campo numérico indicando o nível de risco>,
  "categories": [Lista separada por vírgulas das categorias violadas],
  "explanation": <Opcional. Incluir apenas se o nível de risco for maior que 0>
}}"""

    # Envia a requisição ao Claude para avaliação de risco
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o nível de risco, categorias violadas e explicação da avaliação
    risk_level = assessment["risk_level"]
    violated_categories = assessment["categories"]
    explanation = assessment.get("explanation")
    
    return risk_level, violated_categories, explanation

# Processa cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    risk_level, violated_categories, explanation = assess_risk_level(comment, unsafe_categories)
    
    print(f"Nível de Risco: {risk_level}")
    if violated_categories:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
    if explanation:
        print(f"Explicação: {explanation}")

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

# Dicionário de categorias consideradas inseguras para moderação de conteúdo, com suas definições
unsafe_category_definitions = {
    'Exploração Infantil': 'Conteúdo que retrata nudez infantil ou que permite, encoraja, desculpa ou retrata o abuso sexual de crianças.',
    'Teorias da Conspiração': """Conteúdo que promove ou endossa teorias infundadas, falsas ou enganosas sobre eventos, situações ou indivíduos, 
        que podem incitar danos ou minar a confiança pública em instituições ou fatos.""",
    'Ódio': """Conteúdo que é odioso em relação a pessoas com base em suas características protegidas 
        (raça, cor, etnia, origem nacional, deficiência, afiliação religiosa, casta, orientação sexual, sexo, identidade de gênero e doença grave), 
        ou conteúdo que perpetua estereótipos negativos.""",
    'Armas Indiscriminadas': 'Conteúdo que permite a criação de armas de destruição em massa.', 
    'Propriedade Intelectual': 'Conteúdo que viola os direitos de propriedade intelectual de terceiros.',
    'Crimes Não Violentos': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes não violentos.', 
    'Privacidade': 'Conteúdo que contém informações sensíveis e pessoais sobre indivíduos privados.',
    'Automutilação': 'Conteúdo que permite, encoraja ou desculpa atos de automutilação intencional.',
    'Crimes Sexuais': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes sexuais.',
    'Conteúdo Sexual': 'Conteúdo que contém descrições eróticas ou representações explícitas de atos sexuais.',
    'Conselhos Especializados': """Conteúdo que contém conselhos financeiros, médicos ou jurídicos. 
        Conselhos financeiros incluem orientação sobre investimentos, ações, títulos ou qualquer planejamento financeiro.""",
    'Crimes Violentos': 'Conteúdo que permite, encoraja ou desculpa a prática de crimes violentos.', 
}


def moderate_message_with_definitions(message, unsafe_category_definitions):
    # Formata string de categorias inseguras, com cada categoria e sua definição em uma nova linha
    unsafe_category_str = '\n'.join(f'{category}: {definition}' 
        for category, definition in unsafe_category_definitions.items()
    )
    
    # Constrói o prompt para o Claude, incluindo a mensagem e categorias inseguras
    assessment_prompt = f"""Determine se a seguinte mensagem requer moderação, com base nas categorias inseguras descritas abaixo.

Mensagem:
<message>{message}</message>

Categorias Inseguras e Suas Definições:
<categories>
{unsafe_category_str}
</categories>

É importante que você l

embre todas as categorias inseguras e suas definições.

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "violation": <Campo booleano indicando se a mensagem deve ser moderada>,
  "categories": [Lista separada por vírgulas das categorias violadas],
  "explanation": [Opcional. Incluir apenas se houver uma violação.]
}}"""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=200,
        temperature=0,   # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    
    # Extrai o status de violação da avaliação
    contains_violation = assessment['violation']
    
    # Se houver uma violação, obtém as categorias e explicação; caso contrário, usa padrões vazios
    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 cada comentário e imprime os resultados
for comment in user_comments:
    print(f"\nComentário: {comment}")
    violation, violated_categories, explanation = moderate_message_with_definitions(comment, unsafe_category_definitions)
    
    if violation:
        print(f"Categorias Violadas: {', '.join(violated_categories)}")
        print(f"Explicação: {explanation}")
    else:
        print("Nenhum problema detectado.")

import anthropic
import json

# Inicializa o cliente Anthropic
client = anthropic.Anthropic()

def batch_moderate_messages(messages, unsafe_categories):
    # Converte a lista de categorias inseguras em uma string, com cada categoria em uma nova linha
    unsafe_category_str = '\n'.join(unsafe_categories)
    
    # Formata string de mensagens, com cada mensagem envolta em tags tipo XML e com um ID
    messages_str = '\n'.join([f'<message id={idx}>{msg}</message>' for idx, msg in enumerate(messages)])
    
    # Constrói o prompt para o Claude, incluindo as mensagens e categorias inseguras
    assessment_prompt = f"""Determine as mensagens a moderar, com base nas categorias inseguras descritas abaixo.

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

Categorias inseguras e suas definições:
<categories>
{unsafe_category_str}
</categories>

Responda APENAS com um objeto JSON, usando o formato abaixo:
{{
  "violations": [
    {{
      "id": <id da mensagem>,
      "categories": [lista de categorias violadas],
      "explanation": <Explicação do motivo da violação>
    }},
    ...
  ]
}}

Notas Importantes:
- Lembre-se de analisar cada mensagem para uma violação.
- Selecione qualquer número de violações que se apliquem razoavelmente."""

    # Envia a requisição ao Claude para moderação de conteúdo
    response = client.messages.create(
        model="claude-3-haiku-20240307",  # Usando o modelo Haiku para custos mais baixos
        max_tokens=2048,  # Aumentou o número máximo de tokens para lidar com lotes
        temperature=0,    # Usa temperatura 0 para maior consistência
        messages=[
            {"role": "user", "content": assessment_prompt}
        ]
    )
    
    # Analisa a resposta JSON do Claude
    assessment = json.loads(response.content[0].text)
    return assessment


# Processa o lote de comentários e obtém a resposta
response_obj = batch_moderate_messages(user_comments, unsafe_categories)

# Imprime os resultados para cada violação detectada
for violation in response_obj['violations']:
    print(f"""Comentário: {user_comments[violation['id']]}
Categorias Violadas: {', '.join(violation['categories'])}
Explicação: {violation['explanation']}
""")