---
title: Moderação de conteúdo
url: https://platform.claude.com/docs/pt-BR/about-claude/use-case-guides/content-moderation
description: A moderação de conteúdo é um aspecto crítico para manter um ambiente seguro, respeitoso e produtivo em aplicações digitais. Este guia discute como o Claude pode ser usado para moderar conteúdo dentro da sua aplicação digital.
---
> Visite o [cookbook de moderação de conteúdo](https://platform.claude.com/cookbook/misc-building-moderation-filter) para ver um exemplo de implementação de moderação de conteúdo usando o Claude.
Este guia é focado na moderação de conteúdo gerado por usuários dentro da sua aplicação. Se você está procurando orientação sobre como moderar interações com o Claude, consulte
[Mitigar jailbreaks e injeções de prompt](https://platform.claude.com/docs/pt-BR/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks)
.
## Antes de construir com o Claude
### Decida se deve usar o Claude para moderação de conteúdo
Aqui estão alguns indicadores-chave de que você deve usar um "large language model" (modelo de linguagem grande), ou LLM, como o Claude em vez de uma abordagem tradicional de ML ou baseada em regras para moderação de conteúdo:
Os métodos tradicionais de ML exigem recursos significativos de engenharia, expertise em ML e custos de infraestrutura. Sistemas de moderação humana incorrem em custos ainda mais altos. Com o Claude, você pode ter um sistema de moderação sofisticado em operação em significativamente menos tempo e a um custo muito menor.
Abordagens tradicionais de ML, como modelos bag-of-words ou correspondência simples de padrões, frequentemente têm dificuldade em entender o tom, a intenção e o contexto do conteúdo. Embora os sistemas de moderação humana sejam excelentes em compreender o significado semântico, eles exigem tempo para que o conteúdo seja revisado. O Claude atende a ambas as necessidades ao combinar compreensão semântica com a capacidade de entregar decisões de moderação rapidamente.
Ao aproveitar suas capacidades avançadas de raciocínio, o Claude pode interpretar e aplicar diretrizes complexas de moderação de forma uniforme. Essa consistência ajuda a garantir um tratamento justo de todo o conteúdo, reduzindo o risco de decisões de moderação inconsistentes ou enviesadas que podem minar a confiança dos usuários.
Uma vez que uma abordagem tradicional de ML foi estabelecida, alterá-la é uma tarefa trabalhosa e intensiva em dados. Por outro lado, à medida que seu produto ou as necessidades dos clientes evoluem, o Claude pode se adaptar facilmente a mudanças ou adições às políticas de moderação sem uma extensa rerrotulagem de dados de treinamento.
Se você deseja fornecer aos usuários ou reguladores explicações claras por trás das decisões de moderação, o Claude pode gerar justificativas detalhadas e coerentes. Essa transparência é importante para construir confiança e garantir responsabilidade nas práticas de moderação de conteúdo.
Abordagens tradicionais de ML normalmente exigem modelos separados ou processos extensos de tradução para cada idioma suportado. A moderação humana exige a contratação de uma força de trabalho fluente em cada idioma suportado. As capacidades multilíngues do Claude permitem que ele classifique tickets em vários idiomas sem a necessidade de modelos separados ou processos extensos de tradução, simplificando a moderação para bases de clientes globais.
As capacidades multimodais do Claude permitem que ele analise e interprete conteúdo tanto em texto quanto em imagens. Isso o torna uma ferramenta versátil para moderação de conteúdo abrangente em ambientes onde diferentes tipos de mídia precisam ser avaliados em conjunto.
Todos os modelos Claude são treinados com comportamentos de segurança integrados. Isso pode resultar no Claude moderando conteúdo considerado particularmente perigoso (em linha com a
[Política de Uso Aceitável](https://www.anthropic.com/legal/aup)
), independentemente do prompt usado. Por exemplo, um site adulto que deseja permitir que usuários publiquem conteúdo sexual explícito pode descobrir que o Claude ainda sinaliza conteúdo explícito como necessitando de moderação, mesmo que especifique em seu prompt para não moderar conteúdo sexual explícito. Considere revisar a AUP antes de construir uma solução de moderação.
### Gere exemplos de conteúdo para moderar
Antes de desenvolver uma solução de moderação de conteúdo, primeiro crie exemplos de conteúdo que deve ser sinalizado e conteúdo que não deve ser sinalizado. Certifique-se de incluir casos extremos e cenários desafiadores que podem ser difíceis para um sistema de moderação de conteúdo lidar de forma eficaz. Depois, revise seus exemplos para criar uma lista bem definida de categorias de moderação. Por exemplo, os exemplos gerados por uma plataforma de mídia social podem incluir o seguinte:
```python Python
client = anthropic.Anthropic()
allowed_user_comments = [
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!",
]
disallowed_user_comments = [
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!",
]
# Comentários de usuários de exemplo para testar a moderação de conteúdo
user_comments = allowed_user_comments + disallowed_user_comments
# Categorias consideradas inseguras para moderação de conteúdo
unsafe_categories = [
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes",
]
```
```typescript TypeScript
const client = new Anthropic();
const allowedUserComments = [
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!"
];
const disallowedUserComments = [
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!"
];
// Comentários de usuários de exemplo para testar a moderação de conteúdo
const userComments = [...allowedUserComments, ...disallowedUserComments];
// Categorias consideradas inseguras para a moderação de conteúdo
const unsafeCategories = [
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes"
];
```
```csharp C#
var client = new AnthropicClient();
string[] allowedUserComments =
[
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!",
];
string[] disallowedUserComments =
[
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!",
];
// Comentários de usuários de exemplo para testar a moderação de conteúdo
string[] userComments = [.. allowedUserComments, .. disallowedUserComments];
// Categorias consideradas inseguras para moderação de conteúdo
string[] unsafeCategories =
[
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes",
];
```
```go Go
var client = anthropic.NewClient()
var allowedUserComments = []string{
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!",
}
var disallowedUserComments = []string{
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!",
}
// Comentários de usuários de exemplo para testar a moderação de conteúdo
var userComments = slices.Concat(allowedUserComments, disallowedUserComments)
// Categorias consideradas inseguras para moderação de conteúdo
var unsafeCategories = []string{
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes",
}
```
```java Java
final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
final List allowedUserComments = List.of(
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!");
final List disallowedUserComments = List.of(
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!");
// Comentários de usuários de exemplo para testar a moderação de conteúdo
final List userComments =
Stream.concat(allowedUserComments.stream(), disallowedUserComments.stream()).toList();
// Categorias consideradas inseguras para moderação de conteúdo
final List unsafeCategories = List.of(
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes");
```
```php PHP
$client = new Client();
$allowedUserComments = [
'This movie was great, I really enjoyed it. The main actor really killed it!',
'I hate Mondays.',
'It is a great time to invest in gold!',
];
$disallowedUserComments = [
'Delete this post now or you better hide. I am coming after you and your family.',
'Stay away from the 5G cellphones!! They are using 5G to control you.',
'Congratulations! You have won a $1,000 gift card. Click here to claim your prize!',
];
// Comentários de usuários de exemplo para testar a moderação de conteúdo
$userComments = [...$allowedUserComments, ...$disallowedUserComments];
// Categorias consideradas inseguras para a moderação de conteúdo
$unsafeCategories = [
'Child Exploitation',
'Conspiracy Theories',
'Hate',
'Indiscriminate Weapons',
'Intellectual Property',
'Non-Violent Crimes',
'Privacy',
'Self-Harm',
'Sex Crimes',
'Sexual Content',
'Specialized Advice',
'Violent Crimes',
];
```
```ruby Ruby
CLIENT = Anthropic::Client.new
ALLOWED_USER_COMMENTS = [
"This movie was great, I really enjoyed it. The main actor really killed it!",
"I hate Mondays.",
"It is a great time to invest in gold!"
]
DISALLOWED_USER_COMMENTS = [
"Delete this post now or you better hide. I am coming after you and your family.",
"Stay away from the 5G cellphones!! They are using 5G to control you.",
"Congratulations! You have won a $1,000 gift card. Click here to claim your prize!"
]
# Comentários de usuários de exemplo para testar a moderação de conteúdo
USER_COMMENTS = ALLOWED_USER_COMMENTS + DISALLOWED_USER_COMMENTS
# Categorias consideradas inseguras para moderação de conteúdo
UNSAFE_CATEGORIES = [
"Child Exploitation",
"Conspiracy Theories",
"Hate",
"Indiscriminate Weapons",
"Intellectual Property",
"Non-Violent Crimes",
"Privacy",
"Self-Harm",
"Sex Crimes",
"Sexual Content",
"Specialized Advice",
"Violent Crimes"
]
```
Moderar esses exemplos de forma eficaz exige uma compreensão sutil da linguagem. No comentário `This movie was great, I really enjoyed it. The main actor really killed it!`, o sistema de moderação de conteúdo precisa reconhecer que "killed it" é uma metáfora, não uma indicação de violência real. Por outro lado, apesar da ausência de menções explícitas à violência, o comentário `Delete this post now or you better hide. I am coming after you and your family.` deve ser sinalizado pelo sistema de moderação de conteúdo.
As categorias inseguras podem ser personalizadas para atender às suas necessidades específicas. Por exemplo, se você deseja impedir que menores criem conteúdo em seu site, você pode adicionar "Underage Posting" às categorias.
***
## Como moderar conteúdo usando o Claude
### Selecione o modelo Claude certo
Ao selecionar um modelo, é importante considerar o tamanho dos seus dados. Se os custos forem uma preocupação, um modelo menor como o Claude Haiku 5.5 é uma excelente escolha devido à sua relação custo-benefício. A seguir está uma estimativa do custo para moderar texto em uma plataforma de mídia social que recebe um bilhão de publicações por mês:
* **Tamanho do conteúdo**
* Posts por mês: 1 bilhão
* Caracteres por post: 100
* Total de caracteres: 100 bilhões
* **Tokens estimados**
* Tokens de entrada: 28,6 bilhões (assumindo 1 token a cada 3,5 caracteres)
* Porcentagem de mensagens sinalizadas: 3%
* Tokens de saída por mensagem sinalizada: 50
* Total de tokens de saída: 1,5 bilhão
* **Custo estimado do Claude Haiku 5.5**
* Custo dos tokens de entrada: 28.600 MTok \* $0,10/MTok = $2.860 USD
* Custo dos tokens de saída: 1.500 MTok \* $0,50/MTok = $750 USD
* Custo mensal: $2.860 + $750 = $3.610 USD
* **Custo estimado do Claude Opus 5**
* Custo de tokens de entrada: 28.600 MTok \* $5,00/MTok = $143.000 USD
* Custo de tokens de saída: 1.500 MTok \* $25,00/MTok = $37.500 USD
* Custo mensal: $143.000 + $37.500 = $180.500 USD
* **Custo estimado do Claude Opus 4.8**
* Custo de tokens de entrada: 28.600 MTok \* $5,00/MTok = $143.000 USD
* Custo de tokens de saída: 1.500 MTok \* $25,00/MTok = $37.500 USD
* Custo mensal: $143.000 + $37.500 = $180.500 USD
Os custos reais podem diferir dessas estimativas. Essas estimativas são baseadas no prompt destacado na seção sobre
[processamento em lote](https://platform.claude.com/docs/pt-BR/about-claude/use-case-guides/content-moderation#consider-batch-processing)
. Os tokens de saída podem ser reduzidos ainda mais removendo o campo
`explanation`
da resposta.
### Construa um prompt forte
Para usar o Claude para moderação de conteúdo, o Claude deve entender os requisitos de moderação da sua aplicação. Comece escrevendo um prompt que permita definir suas necessidades de moderação:
```python Python
def moderate_message(message, unsafe_categories):
# Converte as 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 as categorias inseguras
assessment_prompt = f"""
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
{message}
Unsafe Categories:
{unsafe_category_str}
Respond with ONLY a JSON object, using the format below:
{{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}}
Do not include markdown formatting or code fences in your response."""
# Envia a solicitação ao Claude para moderação de conteúdo
response = client.messages.create(
model="claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens=200,
messages=[{"role": "user", "content": assessment_prompt}],
)
# Analisa a resposta JSON do Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrai o status de violação da avaliação
contains_violation = assessment["violation"]
# Se houver violação, obtém as categorias e a 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"\nComment: {comment}")
violation, violated_categories, explanation = moderate_message(
comment, unsafe_categories
)
if violation:
print(f"Violated Categories: {', '.join(violated_categories)}")
print(f"Explanation: {explanation}")
else:
print("No issues detected.")
```
```typescript TypeScript
// Formato da avaliação JSON que o Claude retorna
interface ModerationAssessment {
violation: boolean;
categories?: string[];
explanation?: string;
}
async function moderateMessage(
message: string,
unsafeCategories: string[]
): Promise<{ violation: boolean; violatedCategories: string[]; explanation?: string }> {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
const unsafeCategoryStr = unsafeCategories.join("\n");
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
const assessmentPrompt = `
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
${message}
Unsafe Categories:
${unsafeCategoryStr}
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.`;
// Envia a solicitação ao Claude para moderação de conteúdo
const response = await client.messages.create({
model: "claude-haiku-4-5-20251001", // Using the Haiku model for lower costs
max_tokens: 200,
messages: [{ role: "user", content: assessmentPrompt }]
});
// Analisa a resposta JSON do Claude
const textBlock = response.content.find((block) => block.type === "text");
if (!textBlock) {
throw new Error("Expected a text block in the response");
}
const assessment: ModerationAssessment = JSON.parse(textBlock.text);
// Extrai o status de violação da avaliação
const containsViolation = assessment.violation;
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
const violatedCategories = containsViolation ? (assessment.categories ?? []) : [];
const explanation = containsViolation ? assessment.explanation : undefined;
return { violation: containsViolation, violatedCategories, explanation };
}
// Processa cada comentário e imprime os resultados
for (const comment of userComments) {
console.log(`\nComment: ${comment}`);
const { violation, violatedCategories, explanation } = await moderateMessage(
comment,
unsafeCategories
);
if (violation) {
console.log(`Violated Categories: ${violatedCategories.join(", ")}`);
console.log(`Explanation: ${explanation}`);
} else {
console.log("No issues detected.");
}
}
```
```csharp C#
async Task<(bool ContainsViolation, List ViolatedCategories, string? Explanation)> ModerateMessage(
string message,
IReadOnlyList categories
)
{
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
var unsafeCategoryText = string.Join("\n", categories);
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
var assessmentPrompt = $$"""
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
{{message}}
Unsafe Categories:
{{unsafeCategoryText}}
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
""";
// Envia a solicitação ao Claude para moderação de conteúdo
var response = await client.Messages.Create(
new()
{
Model = Model.ClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens = 200,
Messages = [new() { Role = Role.User, Content = assessmentPrompt }],
}
);
// Restringe o primeiro bloco de conteúdo a um bloco de texto e, em seguida, analisa a resposta JSON do Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrai o status de violação da avaliação
var containsViolation = assessment["violation"]!.GetValue();
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa valores padrão vazios
List violatedCategories = containsViolation
? assessment["categories"]?.AsArray().Select(category => category!.GetValue()).ToList() ?? []
: [];
var explanation = containsViolation ? assessment["explanation"]?.GetValue() : null;
return (containsViolation, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
foreach (var comment in userComments)
{
Console.WriteLine($"\nComment: {comment}");
var (violation, violatedCategories, explanation) = await ModerateMessage(comment, unsafeCategories);
if (violation)
{
Console.WriteLine($"Violated Categories: {string.Join(", ", violatedCategories)}");
Console.WriteLine($"Explanation: {explanation}");
}
else
{
Console.WriteLine("No issues detected.");
}
}
```
```go Go
func moderateMessage(message string, unsafeCategories []string) (bool, []string, string) {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
assessmentPrompt := fmt.Sprintf(`
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
%s
Unsafe Categories:
%s
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.`, message, unsafeCategoryStr)
// Envia a solicitação ao Claude para moderação de conteúdo
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens: 200,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock(assessmentPrompt)),
},
})
if err != nil {
log.Fatal(err)
}
// Restringe o primeiro bloco de conteúdo a um bloco de texto antes de ler seu texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analisa a resposta JSON do Claude
var assessment struct {
Violation bool `json:"violation"`
Categories []string `json:"categories"`
Explanation string `json:"explanation"`
}
if err := json.Unmarshal([]byte(textBlock.Text), &assessment); err != nil {
log.Fatal(err)
}
// Se houver violação, retorna as categorias e a explicação; caso contrário, usa padrões vazios
if !assessment.Violation {
return false, nil, ""
}
return true, assessment.Categories, assessment.Explanation
}
// moderateAllComments processa cada comentário e imprime os resultados.
func moderateAllComments() {
for _, comment := range userComments {
fmt.Printf("\nComment: %s\n", comment)
violation, violatedCategories, explanation := moderateMessage(comment, unsafeCategories)
if violation {
fmt.Printf("Violated Categories: %s\n", strings.Join(violatedCategories, ", "))
fmt.Printf("Explanation: %s\n", explanation)
} else {
fmt.Println("No issues detected.")
}
}
}
```
```java Java
record ModerationResult(boolean violation, List violatedCategories, String explanation) {}
ModerationResult moderateMessage(String message, List unsafeCategories)
throws JsonProcessingException {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
String assessmentPrompt = """
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
%s
Unsafe Categories:
%s
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response."""
.formatted(message, unsafeCategoryStr);
// Envia a solicitação ao Claude para moderação de conteúdo
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_HAIKU_4_5_20251001) // Using the Haiku model for lower costs
.maxTokens(200)
.addUserMessage(assessmentPrompt)
.build());
// Analisa a resposta JSON do Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrai o status de violação da avaliação
boolean containsViolation = assessment.required("violation").asBoolean();
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
List violatedCategories = containsViolation && assessment.has("categories")
? mapper.convertValue(assessment.get("categories"), new TypeReference>() {})
: List.of();
String explanation = containsViolation && assessment.hasNonNull("explanation")
? assessment.get("explanation").asText()
: null;
return new ModerationResult(containsViolation, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
void printModerationResults() throws JsonProcessingException {
for (String comment : userComments) {
IO.println("\nComment: " + comment);
ModerationResult result = moderateMessage(comment, unsafeCategories);
if (result.violation()) {
IO.println("Violated Categories: " + String.join(", ", result.violatedCategories()));
IO.println("Explanation: " + result.explanation());
} else {
IO.println("No issues detected.");
}
}
}
```
```php PHP
$moderateMessage = function (string $message, array $unsafeCategories) use ($client): array {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
$assessmentPrompt = <<{$message}
Unsafe Categories:
{$unsafeCategoryStr}
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
PROMPT;
// Envia a solicitação ao Claude para moderação de conteúdo
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analisa a resposta JSON do Claude. O SDK decodifica cada bloco de conteúdo
// em sua classe concreta, então encontre o TextBlock antes de ler o texto.
$textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
?? throw new \RuntimeException('Expected a text block in the response.');
$assessment = json_decode($textBlock->text, associative: true, flags: JSON_THROW_ON_ERROR);
// Extrai o status de violação da avaliação
$containsViolation = $assessment['violation'];
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa valores padrão vazios
$violatedCategories = $containsViolation ? ($assessment['categories'] ?? []) : [];
$explanation = $containsViolation ? ($assessment['explanation'] ?? null) : null;
return [$containsViolation, $violatedCategories, $explanation];
};
// Processa cada comentário e imprime os resultados
foreach ($userComments as $comment) {
echo "\nComment: {$comment}\n";
[$violation, $violatedCategories, $explanation] = $moderateMessage($comment, $unsafeCategories);
if ($violation) {
echo 'Violated Categories: ' . implode(', ', $violatedCategories) . "\n";
echo "Explanation: {$explanation}\n";
} else {
echo "No issues detected.\n";
}
}
```
```ruby Ruby
def moderate_message(message, unsafe_categories)
# Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafe_category_str = unsafe_categories.join("\n")
# Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
assessment_prompt = <<~PROMPT.chomp
Determine whether the following message warrants moderation,
based on the unsafe categories outlined below.
Message:
#{message}
Unsafe Categories:
#{unsafe_category_str}
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
PROMPT
# Envia a solicitação ao Claude para moderação de conteúdo
response = CLIENT.messages.create(
model: "claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens: 200,
messages: [{role: :user, content: assessment_prompt}]
)
# Analisa a resposta JSON do Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrai o status de violação da avaliação
contains_violation = assessment["violation"]
# Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
violated_categories = contains_violation ? assessment.fetch("categories", []) : []
explanation = contains_violation ? assessment["explanation"] : nil
[contains_violation, violated_categories, explanation]
end
# Processa cada comentário e imprime os resultados
USER_COMMENTS.each do |comment|
puts "\nComment: #{comment}"
violation, violated_categories, explanation = moderate_message(comment, UNSAFE_CATEGORIES)
if violation
puts "Violated Categories: #{violated_categories.join(", ")}"
puts "Explanation: #{explanation}"
else
puts "No issues detected."
end
end
```
Neste exemplo, a função `moderate_message` contém um prompt de avaliação que inclui as categorias de conteúdo inseguro e a mensagem a ser avaliada. O prompt pede ao Claude que avalie se a mensagem deve ser moderada, com base nas categorias inseguras que você definiu anteriormente.
A avaliação do modelo é então analisada para determinar se há uma violação. Se houver uma violação, o Claude também retorna uma lista das categorias violadas e uma explicação sobre por que a mensagem é insegura.
### Avalie seu prompt
A moderação de conteúdo é um problema de classificação. Assim, você pode usar as mesmas técnicas descritas no [cookbook de classificação](https://platform.claude.com/cookbook/capabilities-classification-guide) para determinar a precisão do seu sistema de moderação de conteúdo.
Uma consideração adicional é que, em vez de tratar a moderação de conteúdo como um problema de classificação binária, você pode criar múltiplas categorias para representar vários níveis de risco. Criar múltiplos níveis de risco permite ajustar a agressividade da sua moderação. Por exemplo, você pode querer bloquear automaticamente consultas de usuários consideradas de alto risco, enquanto usuários com muitas consultas de risco médio são sinalizados para revisão humana.
```python Python
def assess_risk_level(message, unsafe_categories):
# Converte as 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, as categorias inseguras e as definições de nível de risco
assessment_prompt = f"""
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
{message}
Unsafe Categories:
{unsafe_category_str}
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}}
Do not include markdown formatting or code fences in your response."""
# Envia a solicitação ao Claude para avaliação de risco
response = client.messages.create(
model="claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens=200,
messages=[{"role": "user", "content": assessment_prompt}],
)
# Analisa a resposta JSON do Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrai o nível de risco, as categorias violadas e a 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"\nComment: {comment}")
risk_level, violated_categories, explanation = assess_risk_level(
comment, unsafe_categories
)
print(f"Risk Level: {risk_level}")
if violated_categories:
print(f"Violated Categories: {', '.join(violated_categories)}")
if explanation:
print(f"Explanation: {explanation}")
```
```typescript TypeScript
// Formato da avaliação de risco JSON que o Claude retorna
interface RiskAssessment {
risk_level: number;
categories: string[];
explanation?: string;
}
async function assessRiskLevel(
message: string,
unsafeCategories: string[]
): Promise<{ riskLevel: number; violatedCategories: string[]; explanation?: string }> {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
const unsafeCategoryStr = unsafeCategories.join("\n");
// Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de nível de risco
const assessmentPrompt = `
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
${message}
Unsafe Categories:
${unsafeCategoryStr}
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response.`;
// Envia a solicitação ao Claude para avaliação de risco
const response = await client.messages.create({
model: "claude-haiku-4-5-20251001", // Using the Haiku model for lower costs
max_tokens: 200,
messages: [{ role: "user", content: assessmentPrompt }]
});
// Analisa a resposta JSON do Claude
const textBlock = response.content.find((block) => block.type === "text");
if (!textBlock) {
throw new Error("Expected a text block in the response");
}
const assessment: RiskAssessment = JSON.parse(textBlock.text);
// Extrai o nível de risco, as categorias violadas e a explicação da avaliação
const { risk_level: riskLevel, categories: violatedCategories, explanation } = assessment;
return { riskLevel, violatedCategories, explanation };
}
// Processa cada comentário e imprime os resultados
for (const comment of userComments) {
console.log(`\nComment: ${comment}`);
const { riskLevel, violatedCategories, explanation } = await assessRiskLevel(
comment,
unsafeCategories
);
console.log(`Risk Level: ${riskLevel}`);
if (violatedCategories.length > 0) {
console.log(`Violated Categories: ${violatedCategories.join(", ")}`);
}
if (explanation) {
console.log(`Explanation: ${explanation}`);
}
}
```
```csharp C#
async Task<(int RiskLevel, List ViolatedCategories, string? Explanation)> AssessRiskLevel(
string message,
IReadOnlyList categories
)
{
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
var unsafeCategoryText = string.Join("\n", categories);
// Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de níveis de risco
var assessmentPrompt = $$"""
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
{{message}}
Unsafe Categories:
{{unsafeCategoryText}}
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response.
""";
// Envia a solicitação ao Claude para avaliação de risco
var response = await client.Messages.Create(
new()
{
Model = Model.ClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens = 200,
Messages = [new() { Role = Role.User, Content = assessmentPrompt }],
}
);
// Restringe o primeiro bloco de conteúdo a um bloco de texto e, em seguida, analisa a resposta JSON do Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrai o nível de risco, as categorias violadas e a explicação da avaliação
var riskLevel = assessment["risk_level"]!.GetValue();
var violatedCategories = assessment["categories"]!
.AsArray()
.Select(category => category!.GetValue())
.ToList();
var explanation = assessment["explanation"]?.GetValue();
return (riskLevel, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
foreach (var comment in userComments)
{
Console.WriteLine($"\nComment: {comment}");
var (riskLevel, violatedCategories, explanation) = await AssessRiskLevel(comment, unsafeCategories);
Console.WriteLine($"Risk Level: {riskLevel}");
if (violatedCategories.Count > 0)
{
Console.WriteLine($"Violated Categories: {string.Join(", ", violatedCategories)}");
}
if (!string.IsNullOrEmpty(explanation))
{
Console.WriteLine($"Explanation: {explanation}");
}
}
```
```go Go
func assessRiskLevel(message string, unsafeCategories []string) (int, []string, string) {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de nível de risco
assessmentPrompt := fmt.Sprintf(`
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
%s
Unsafe Categories:
%s
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response.`, message, unsafeCategoryStr)
// Envia a solicitação ao Claude para avaliação de risco
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens: 200,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock(assessmentPrompt)),
},
})
if err != nil {
log.Fatal(err)
}
// Restringe o primeiro bloco de conteúdo a um bloco de texto antes de ler seu texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analisa a resposta JSON do Claude
var assessment struct {
RiskLevel int `json:"risk_level"`
Categories []string `json:"categories"`
Explanation string `json:"explanation"`
}
if err := json.Unmarshal([]byte(textBlock.Text), &assessment); err != nil {
log.Fatal(err)
}
// Retorna o nível de risco, as categorias violadas e a explicação da avaliação
return assessment.RiskLevel, assessment.Categories, assessment.Explanation
}
// assessAllRiskLevels processa cada comentário e imprime os resultados.
func assessAllRiskLevels() {
for _, comment := range userComments {
fmt.Printf("\nComment: %s\n", comment)
riskLevel, violatedCategories, explanation := assessRiskLevel(comment, unsafeCategories)
fmt.Printf("Risk Level: %d\n", riskLevel)
if len(violatedCategories) > 0 {
fmt.Printf("Violated Categories: %s\n", strings.Join(violatedCategories, ", "))
}
if explanation != "" {
fmt.Printf("Explanation: %s\n", explanation)
}
}
}
```
```java Java
record RiskAssessment(int riskLevel, List violatedCategories, String explanation) {}
RiskAssessment assessRiskLevel(String message, List unsafeCategories)
throws JsonProcessingException {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de níveis de risco
String assessmentPrompt = """
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
%s
Unsafe Categories:
%s
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response."""
.formatted(message, unsafeCategoryStr);
// Envia a solicitação ao Claude para avaliação de risco
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_HAIKU_4_5_20251001) // Using the Haiku model for lower costs
.maxTokens(200)
.addUserMessage(assessmentPrompt)
.build());
// Analisa a resposta JSON do Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrai o nível de risco, as categorias violadas e a explicação da avaliação
int riskLevel = assessment.required("risk_level").asInt();
JsonNode categoriesNode = assessment.required("categories");
List violatedCategories = categoriesNode.isNull()
? List.of()
: mapper.convertValue(categoriesNode, new TypeReference>() {});
String explanation = assessment.hasNonNull("explanation")
? assessment.get("explanation").asText()
: null;
return new RiskAssessment(riskLevel, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
void printRiskLevels() throws JsonProcessingException {
for (String comment : userComments) {
IO.println("\nComment: " + comment);
RiskAssessment assessment = assessRiskLevel(comment, unsafeCategories);
IO.println("Risk Level: " + assessment.riskLevel());
if (!assessment.violatedCategories().isEmpty()) {
IO.println("Violated Categories: " + String.join(", ", assessment.violatedCategories()));
}
if (assessment.explanation() != null && !assessment.explanation().isEmpty()) {
IO.println("Explanation: " + assessment.explanation());
}
}
}
```
```php PHP
$assessRiskLevel = function (string $message, array $unsafeCategories) use ($client): array {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de níveis de risco
$assessmentPrompt = <<{$message}
Unsafe Categories:
{$unsafeCategoryStr}
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response.
PROMPT;
// Envia a solicitação ao Claude para avaliação de risco
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analisa a resposta JSON do Claude. O SDK decodifica cada bloco de conteúdo
// em sua classe concreta, então encontre o TextBlock antes de ler o texto.
$textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
?? throw new \RuntimeException('Expected a text block in the response.');
$assessment = json_decode($textBlock->text, associative: true, flags: JSON_THROW_ON_ERROR);
// Extrai o nível de risco, as categorias violadas e a explicação da avaliação
$riskLevel = $assessment['risk_level'];
$violatedCategories = $assessment['categories'];
$explanation = $assessment['explanation'] ?? null;
return [$riskLevel, $violatedCategories, $explanation];
};
// Processa cada comentário e imprime os resultados
foreach ($userComments as $comment) {
echo "\nComment: {$comment}\n";
[$riskLevel, $violatedCategories, $explanation] = $assessRiskLevel($comment, $unsafeCategories);
echo "Risk Level: {$riskLevel}\n";
if ($violatedCategories) {
echo 'Violated Categories: ' . implode(', ', $violatedCategories) . "\n";
}
if ($explanation) {
echo "Explanation: {$explanation}\n";
}
}
```
```ruby Ruby
def assess_risk_level(message, unsafe_categories)
# Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafe_category_str = unsafe_categories.join("\n")
# Constrói o prompt para o Claude, incluindo a mensagem, as categorias inseguras e as definições de níveis de risco
assessment_prompt = <<~PROMPT.chomp
Assess the risk level of the following message,
based on the unsafe categories listed below.
Message:
#{message}
Unsafe Categories:
#{unsafe_category_str}
Assign a risk level based on your confidence that the user's message should be moderated
based on the defined unsafe categories:
0 - No risk
1 - Low risk
2 - Medium risk
3 - High risk
Respond with ONLY a JSON object, using the format below:
{
"risk_level": ,
"categories": [Comma-separated list of violated categories],
"explanation":
}
Do not include markdown formatting or code fences in your response.
PROMPT
# Envia a solicitação ao Claude para avaliação de risco
response = CLIENT.messages.create(
model: "claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens: 200,
messages: [{role: :user, content: assessment_prompt}]
)
# Analisa a resposta JSON do Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrai o nível de risco, as categorias violadas e a explicação da avaliação
risk_level = assessment["risk_level"]
violated_categories = assessment["categories"]
explanation = assessment["explanation"]
[risk_level, violated_categories, explanation]
end
# Processa cada comentário e imprime os resultados
USER_COMMENTS.each do |comment|
puts "\nComment: #{comment}"
risk_level, violated_categories, explanation = assess_risk_level(comment, UNSAFE_CATEGORIES)
puts "Risk Level: #{risk_level}"
puts "Violated Categories: #{violated_categories.join(", ")}" if violated_categories&.any?
puts "Explanation: #{explanation}" if explanation
end
```
Este código implementa uma função `assess_risk_level` que usa o Claude para avaliar o nível de risco de uma mensagem. A função aceita uma mensagem e as categorias inseguras como entradas.
Dentro da função, um prompt é gerado para o Claude, incluindo a mensagem a ser avaliada, as categorias inseguras e instruções específicas para avaliar o nível de risco. O prompt instrui o Claude a responder com um objeto JSON que inclui o nível de risco, as categorias violadas e uma explicação opcional.
Essa abordagem permite uma moderação de conteúdo flexível ao atribuir níveis de risco. Ela pode ser integrada perfeitamente a um sistema maior para automatizar a filtragem de conteúdo ou sinalizar comentários para revisão humana com base no nível de risco avaliado. Por exemplo, ao executar este código, o comentário `Delete this post now or you better hide. I am coming after you and your family.` é identificado como de alto risco devido à sua ameaça perigosa. Por outro lado, o comentário `Stay away from the 5G cellphones!! They are using 5G to control you.` é categorizado como de risco médio.
### Implante seu prompt
Quando você estiver confiante na qualidade da sua solução, é hora de implantá-la em produção. Aqui estão algumas práticas recomendadas a seguir ao usar moderação de conteúdo em produção:
1. **Forneça feedback claro aos usuários:** Quando a entrada do usuário é bloqueada ou uma resposta é sinalizada devido à moderação de conteúdo, forneça feedback informativo e construtivo para ajudar os usuários a entender por que sua mensagem foi sinalizada e como podem reformulá-la adequadamente. Nos exemplos de código anteriores, isso é feito por meio do campo `explanation` na resposta do Claude.
2. **Analise o conteúdo moderado:** Acompanhe os tipos de conteúdo sendo sinalizados pelo seu sistema de moderação para identificar tendências e possíveis áreas de melhoria.
3. **Avalie e melhore continuamente:** Avalie regularmente o desempenho do seu sistema de moderação de conteúdo usando métricas como acompanhamento de precisão e recall. Use esses dados para refinar iterativamente seus prompts de moderação, palavras-chave e critérios de avaliação.
***
## Melhore o desempenho
Em cenários complexos, pode ser útil considerar estratégias adicionais para melhorar o desempenho além das [técnicas de engenharia de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/overview) padrão. Aqui estão algumas estratégias avançadas:
### Defina tópicos e forneça exemplos
Além de listar as categorias inseguras no prompt, melhorias adicionais podem ser feitas fornecendo definições e frases relacionadas a cada categoria.
```python Python
# Categorias consideradas inseguras para moderação de conteúdo, com suas definições
unsafe_category_definitions = {
"Child Exploitation": "Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children.",
"Conspiracy Theories": """Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.""",
"Hate": """Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.""",
"Indiscriminate Weapons": "Content that enables the creation of weapons of mass destruction.",
"Intellectual Property": "Content that violates the intellectual property rights of third parties.",
"Non-Violent Crimes": "Content that enables, encourages, or excuses the commission of non-violent crimes.",
"Privacy": "Content that contains sensitive, personal information about private individuals.",
"Self-Harm": "Content that enables, encourages, or excuses acts of intentional self-harm.",
"Sex Crimes": "Content that enables, encourages, or excuses the commission of sex crimes.",
"Sexual Content": "Content that contains erotic descriptions or explicit depictions of sex acts.",
"Specialized Advice": """Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.""",
"Violent Crimes": "Content that enables, encourages, or excuses the commission of violent crimes.",
}
def moderate_message_with_definitions(message, unsafe_category_definitions):
# Formata a 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 as categorias inseguras
assessment_prompt = f"""Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
{message}
Unsafe Categories and Their Definitions:
{unsafe_category_str}
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}}
Do not include markdown formatting or code fences in your response."""
# Envia a solicitação ao Claude para moderação de conteúdo
response = client.messages.create(
model="claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens=200,
messages=[{"role": "user", "content": assessment_prompt}],
)
# Analisa a resposta JSON do Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrai o status de violação da avaliação
contains_violation = assessment["violation"]
# Se houver violação, obtém as categorias e a 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"\nComment: {comment}")
violation, violated_categories, explanation = moderate_message_with_definitions(
comment, unsafe_category_definitions
)
if violation:
print(f"Violated Categories: {', '.join(violated_categories)}")
print(f"Explanation: {explanation}")
else:
print("No issues detected.")
```
```typescript TypeScript
// Formato da avaliação JSON que o Claude retorna
interface DefinitionBasedAssessment {
violation: boolean;
categories?: string[];
explanation?: string;
}
// Categorias consideradas inseguras para a moderação de conteúdo, com suas definições
// (as chaves do objeto preservam a ordem de inserção, então as categorias aparecem nesta ordem)
const unsafeCategoryDefinitions: Record = {
"Child Exploitation":
"Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children.",
"Conspiracy Theories": `Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.`,
Hate: `Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.`,
"Indiscriminate Weapons":
"Content that enables the creation of weapons of mass destruction.",
"Intellectual Property":
"Content that violates the intellectual property rights of third parties.",
"Non-Violent Crimes":
"Content that enables, encourages, or excuses the commission of non-violent crimes.",
Privacy: "Content that contains sensitive, personal information about private individuals.",
"Self-Harm": "Content that enables, encourages, or excuses acts of intentional self-harm.",
"Sex Crimes": "Content that enables, encourages, or excuses the commission of sex crimes.",
"Sexual Content":
"Content that contains erotic descriptions or explicit depictions of sex acts.",
"Specialized Advice": `Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.`,
"Violent Crimes":
"Content that enables, encourages, or excuses the commission of violent crimes."
};
async function moderateMessageWithDefinitions(
message: string,
unsafeCategoryDefinitions: Record
): Promise<{ violation: boolean; violatedCategories: string[]; explanation?: string }> {
// Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
const unsafeCategoryStr = Object.entries(unsafeCategoryDefinitions)
.map(([category, definition]) => `${category}: ${definition}`)
.join("\n");
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
const assessmentPrompt = `Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
${message}
Unsafe Categories and Their Definitions:
${unsafeCategoryStr}
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.`;
// Envia a solicitação ao Claude para moderação de conteúdo
const response = await client.messages.create({
model: "claude-haiku-4-5-20251001", // Using the Haiku model for lower costs
max_tokens: 200,
messages: [{ role: "user", content: assessmentPrompt }]
});
// Analisa a resposta JSON do Claude
const textBlock = response.content.find((block) => block.type === "text");
if (!textBlock) {
throw new Error("Expected a text block in the response");
}
const assessment: DefinitionBasedAssessment = JSON.parse(textBlock.text);
// Extrai o status de violação da avaliação
const containsViolation = assessment.violation;
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
const violatedCategories = containsViolation ? (assessment.categories ?? []) : [];
const explanation = containsViolation ? assessment.explanation : undefined;
return { violation: containsViolation, violatedCategories, explanation };
}
// Processa cada comentário e imprime os resultados
for (const comment of userComments) {
console.log(`\nComment: ${comment}`);
const { violation, violatedCategories, explanation } = await moderateMessageWithDefinitions(
comment,
unsafeCategoryDefinitions
);
if (violation) {
console.log(`Violated Categories: ${violatedCategories.join(", ")}`);
console.log(`Explanation: ${explanation}`);
} else {
console.log("No issues detected.");
}
}
```
```csharp C#
// Categorias consideradas inseguras para moderação de conteúdo, com suas definições.
// As entradas permanecem na ordem de inserção, então o prompt renderizado lista as categorias
// exatamente nesta ordem.
(string Category, string Definition)[] unsafeCategoryDefinitions =
[
(
"Child Exploitation",
"Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children."
),
(
"Conspiracy Theories",
"""
Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.
"""
),
(
"Hate",
"""
Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.
"""
),
("Indiscriminate Weapons", "Content that enables the creation of weapons of mass destruction."),
("Intellectual Property", "Content that violates the intellectual property rights of third parties."),
("Non-Violent Crimes", "Content that enables, encourages, or excuses the commission of non-violent crimes."),
("Privacy", "Content that contains sensitive, personal information about private individuals."),
("Self-Harm", "Content that enables, encourages, or excuses acts of intentional self-harm."),
("Sex Crimes", "Content that enables, encourages, or excuses the commission of sex crimes."),
("Sexual Content", "Content that contains erotic descriptions or explicit depictions of sex acts."),
(
"Specialized Advice",
"""
Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.
"""
),
("Violent Crimes", "Content that enables, encourages, or excuses the commission of violent crimes."),
];
async Task<(bool ContainsViolation, List ViolatedCategories, string? Explanation)> ModerateMessageWithDefinitions(
string message,
IReadOnlyList<(string Category, string Definition)> categoryDefinitions
)
{
// Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
var unsafeCategoryText = string.Join(
"\n",
categoryDefinitions.Select(entry => $"{entry.Category}: {entry.Definition}")
);
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
var assessmentPrompt = $$"""
Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
{{message}}
Unsafe Categories and Their Definitions:
{{unsafeCategoryText}}
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
""";
// Envia a solicitação ao Claude para moderação de conteúdo
var response = await client.Messages.Create(
new()
{
Model = Model.ClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens = 200,
Messages = [new() { Role = Role.User, Content = assessmentPrompt }],
}
);
// Restringe o primeiro bloco de conteúdo a um bloco de texto e, em seguida, analisa a resposta JSON do Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrai o status de violação da avaliação
var containsViolation = assessment["violation"]!.GetValue();
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa valores padrão vazios
List violatedCategories = containsViolation
? assessment["categories"]?.AsArray().Select(category => category!.GetValue()).ToList() ?? []
: [];
var explanation = containsViolation ? assessment["explanation"]?.GetValue() : null;
return (containsViolation, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
foreach (var comment in userComments)
{
Console.WriteLine($"\nComment: {comment}");
var (violation, violatedCategories, explanation) = await ModerateMessageWithDefinitions(
comment,
unsafeCategoryDefinitions
);
if (violation)
{
Console.WriteLine($"Violated Categories: {string.Join(", ", violatedCategories)}");
Console.WriteLine($"Explanation: {explanation}");
}
else
{
Console.WriteLine("No issues detected.");
}
}
```
```go Go
// Categorias consideradas inseguras para moderação de conteúdo, com suas definições.
// Um slice de pares categoria/definição (em vez de um map) mantém a ordem de
// renderização estável; maps em Go iteram em ordem aleatória.
type categoryDefinition struct {
category string
definition string
}
var unsafeCategoryDefinitions = []categoryDefinition{
{"Child Exploitation", "Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children."},
{"Conspiracy Theories", `Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.`},
{"Hate", `Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.`},
{"Indiscriminate Weapons", "Content that enables the creation of weapons of mass destruction."},
{"Intellectual Property", "Content that violates the intellectual property rights of third parties."},
{"Non-Violent Crimes", "Content that enables, encourages, or excuses the commission of non-violent crimes."},
{"Privacy", "Content that contains sensitive, personal information about private individuals."},
{"Self-Harm", "Content that enables, encourages, or excuses acts of intentional self-harm."},
{"Sex Crimes", "Content that enables, encourages, or excuses the commission of sex crimes."},
{"Sexual Content", "Content that contains erotic descriptions or explicit depictions of sex acts."},
{"Specialized Advice", `Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.`},
{"Violent Crimes", "Content that enables, encourages, or excuses the commission of violent crimes."},
}
func moderateMessageWithDefinitions(message string, unsafeCategoryDefinitions []categoryDefinition) (bool, []string, string) {
// Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
categoryLines := make([]string, len(unsafeCategoryDefinitions))
for i, entry := range unsafeCategoryDefinitions {
categoryLines[i] = fmt.Sprintf("%s: %s", entry.category, entry.definition)
}
unsafeCategoryStr := strings.Join(categoryLines, "\n")
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
assessmentPrompt := fmt.Sprintf(`Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
%s
Unsafe Categories and Their Definitions:
%s
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.`, message, unsafeCategoryStr)
// Envia a solicitação ao Claude para moderação de conteúdo
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens: 200,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock(assessmentPrompt)),
},
})
if err != nil {
log.Fatal(err)
}
// Restringe o primeiro bloco de conteúdo a um bloco de texto antes de ler seu texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analisa a resposta JSON do Claude
var assessment struct {
Violation bool `json:"violation"`
Categories []string `json:"categories"`
Explanation string `json:"explanation"`
}
if err := json.Unmarshal([]byte(textBlock.Text), &assessment); err != nil {
log.Fatal(err)
}
// Se houver violação, retorna as categorias e a explicação; caso contrário, usa padrões vazios
if !assessment.Violation {
return false, nil, ""
}
return true, assessment.Categories, assessment.Explanation
}
// moderateAllCommentsWithDefinitions processa cada comentário e imprime os resultados.
func moderateAllCommentsWithDefinitions() {
for _, comment := range userComments {
fmt.Printf("\nComment: %s\n", comment)
violation, violatedCategories, explanation := moderateMessageWithDefinitions(comment, unsafeCategoryDefinitions)
if violation {
fmt.Printf("Violated Categories: %s\n", strings.Join(violatedCategories, ", "))
fmt.Printf("Explanation: %s\n", explanation)
} else {
fmt.Println("No issues detected.")
}
}
}
```
```java Java
// Categorias consideradas inseguras para moderação de conteúdo, com suas definições
record CategoryDefinition(String category, String definition) {}
final List unsafeCategoryDefinitions = List.of(
new CategoryDefinition(
"Child Exploitation",
"Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children."),
new CategoryDefinition(
"Conspiracy Theories",
"""
Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts."""),
new CategoryDefinition(
"Hate",
"""
Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes."""),
new CategoryDefinition(
"Indiscriminate Weapons",
"Content that enables the creation of weapons of mass destruction."),
new CategoryDefinition(
"Intellectual Property",
"Content that violates the intellectual property rights of third parties."),
new CategoryDefinition(
"Non-Violent Crimes",
"Content that enables, encourages, or excuses the commission of non-violent crimes."),
new CategoryDefinition(
"Privacy",
"Content that contains sensitive, personal information about private individuals."),
new CategoryDefinition(
"Self-Harm",
"Content that enables, encourages, or excuses acts of intentional self-harm."),
new CategoryDefinition(
"Sex Crimes",
"Content that enables, encourages, or excuses the commission of sex crimes."),
new CategoryDefinition(
"Sexual Content",
"Content that contains erotic descriptions or explicit depictions of sex acts."),
new CategoryDefinition(
"Specialized Advice",
"""
Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning."""),
new CategoryDefinition(
"Violent Crimes",
"Content that enables, encourages, or excuses the commission of violent crimes."));
record ModerationDecision(boolean violation, List violatedCategories, String explanation) {}
ModerationDecision moderateMessageWithDefinitions(
String message, List unsafeCategoryDefinitions)
throws JsonProcessingException {
// Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
String unsafeCategoryStr = unsafeCategoryDefinitions.stream()
.map(categoryDefinition ->
categoryDefinition.category() + ": " + categoryDefinition.definition())
.collect(Collectors.joining("\n"));
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
String assessmentPrompt = """
Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
%s
Unsafe Categories and Their Definitions:
%s
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response."""
.formatted(message, unsafeCategoryStr);
// Envia a solicitação ao Claude para moderação de conteúdo
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_HAIKU_4_5_20251001) // Using the Haiku model for lower costs
.maxTokens(200)
.addUserMessage(assessmentPrompt)
.build());
// Analisa a resposta JSON do Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrai o status de violação da avaliação
boolean containsViolation = assessment.required("violation").asBoolean();
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
List violatedCategories = containsViolation && assessment.has("categories")
? mapper.convertValue(assessment.get("categories"), new TypeReference>() {})
: List.of();
String explanation = containsViolation && assessment.hasNonNull("explanation")
? assessment.get("explanation").asText()
: null;
return new ModerationDecision(containsViolation, violatedCategories, explanation);
}
// Processa cada comentário e imprime os resultados
void printModerationResultsWithDefinitions() throws JsonProcessingException {
for (String comment : userComments) {
IO.println("\nComment: " + comment);
ModerationDecision result = moderateMessageWithDefinitions(comment, unsafeCategoryDefinitions);
if (result.violation()) {
IO.println("Violated Categories: " + String.join(", ", result.violatedCategories()));
IO.println("Explanation: " + result.explanation());
} else {
IO.println("No issues detected.");
}
}
}
```
```php PHP
// Categorias consideradas inseguras para a moderação de conteúdo, com suas definições
$unsafeCategoryDefinitions = [
'Child Exploitation' => 'Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children.',
'Conspiracy Theories' => 'Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.',
'Hate' => 'Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.',
'Indiscriminate Weapons' => 'Content that enables the creation of weapons of mass destruction.',
'Intellectual Property' => 'Content that violates the intellectual property rights of third parties.',
'Non-Violent Crimes' => 'Content that enables, encourages, or excuses the commission of non-violent crimes.',
'Privacy' => 'Content that contains sensitive, personal information about private individuals.',
'Self-Harm' => 'Content that enables, encourages, or excuses acts of intentional self-harm.',
'Sex Crimes' => 'Content that enables, encourages, or excuses the commission of sex crimes.',
'Sexual Content' => 'Content that contains erotic descriptions or explicit depictions of sex acts.',
'Specialized Advice' => 'Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.',
'Violent Crimes' => 'Content that enables, encourages, or excuses the commission of violent crimes.',
];
$moderateMessageWithDefinitions = function (string $message, array $unsafeCategoryDefinitions) use ($client): array {
// Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
$categoryLines = [];
foreach ($unsafeCategoryDefinitions as $category => $definition) {
$categoryLines[] = "{$category}: {$definition}";
}
$unsafeCategoryStr = implode("\n", $categoryLines);
// Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
$assessmentPrompt = <<{$message}
Unsafe Categories and Their Definitions:
{$unsafeCategoryStr}
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
PROMPT;
// Envia a solicitação ao Claude para moderação de conteúdo
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analisa a resposta JSON do Claude. O SDK decodifica cada bloco de conteúdo
// em sua classe concreta, então encontre o TextBlock antes de ler o texto.
$textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
?? throw new \RuntimeException('Expected a text block in the response.');
$assessment = json_decode($textBlock->text, associative: true, flags: JSON_THROW_ON_ERROR);
// Extrai o status de violação da avaliação
$containsViolation = $assessment['violation'];
// Se houver violação, obtém as categorias e a explicação; caso contrário, usa valores padrão vazios
$violatedCategories = $containsViolation ? ($assessment['categories'] ?? []) : [];
$explanation = $containsViolation ? ($assessment['explanation'] ?? null) : null;
return [$containsViolation, $violatedCategories, $explanation];
};
// Processa cada comentário e imprime os resultados
foreach ($userComments as $comment) {
echo "\nComment: {$comment}\n";
[$violation, $violatedCategories, $explanation] = $moderateMessageWithDefinitions($comment, $unsafeCategoryDefinitions);
if ($violation) {
echo 'Violated Categories: ' . implode(', ', $violatedCategories) . "\n";
echo "Explanation: {$explanation}\n";
} else {
echo "No issues detected.\n";
}
}
```
```ruby Ruby
# Categorias consideradas inseguras para moderação de conteúdo, com suas definições
UNSAFE_CATEGORY_DEFINITIONS = {
"Child Exploitation" => "Content that depicts child nudity or that enables, encourages, excuses, or depicts the sexual abuse of children.",
"Conspiracy Theories" => "Content that promotes or endorses unfounded, false, or misleading theories about events, situations, or individuals,
which can incite harm or undermine public trust in institutions or facts.",
"Hate" => "Content that is hateful toward people on the basis of their protected characteristics
(race, color, ethnicity, national origin, disability, religious affiliation, caste, sexual orientation, sex, gender identity and serious disease),
or content that perpetuates negative stereotypes.",
"Indiscriminate Weapons" => "Content that enables the creation of weapons of mass destruction.",
"Intellectual Property" => "Content that violates the intellectual property rights of third parties.",
"Non-Violent Crimes" => "Content that enables, encourages, or excuses the commission of non-violent crimes.",
"Privacy" => "Content that contains sensitive, personal information about private individuals.",
"Self-Harm" => "Content that enables, encourages, or excuses acts of intentional self-harm.",
"Sex Crimes" => "Content that enables, encourages, or excuses the commission of sex crimes.",
"Sexual Content" => "Content that contains erotic descriptions or explicit depictions of sex acts.",
"Specialized Advice" => "Content that contains financial, medical, or legal advice.
Financial advice includes guidance on investments, stocks, bonds, or any financial planning.",
"Violent Crimes" => "Content that enables, encourages, or excuses the commission of violent crimes."
}
def moderate_message_with_definitions(message, unsafe_category_definitions)
# Formata a string de categorias inseguras, com cada categoria e sua definição em uma nova linha
unsafe_category_str = unsafe_category_definitions
.map { |category, definition| "#{category}: #{definition}" }
.join("\n")
# Constrói o prompt para o Claude, incluindo a mensagem e as categorias inseguras
assessment_prompt = <<~PROMPT.chomp
Determine whether the following message warrants moderation, based on the unsafe categories outlined below.
Message:
#{message}
Unsafe Categories and Their Definitions:
#{unsafe_category_str}
It's important that you remember all unsafe categories and their definitions.
Respond with ONLY a JSON object, using the format below:
{
"violation": ,
"categories": [Comma-separated list of violated categories],
"explanation": [Optional. Only include if there is a violation.]
}
Do not include markdown formatting or code fences in your response.
PROMPT
# Envia a solicitação ao Claude para moderação de conteúdo
response = CLIENT.messages.create(
model: "claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens: 200,
messages: [{role: :user, content: assessment_prompt}]
)
# Analisa a resposta JSON do Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrai o status de violação da avaliação
contains_violation = assessment["violation"]
# Se houver violação, obtém as categorias e a explicação; caso contrário, usa padrões vazios
violated_categories = contains_violation ? assessment.fetch("categories", []) : []
explanation = contains_violation ? assessment["explanation"] : nil
[contains_violation, violated_categories, explanation]
end
# Processa cada comentário e imprime os resultados
USER_COMMENTS.each do |comment|
puts "\nComment: #{comment}"
violation, violated_categories, explanation = moderate_message_with_definitions(comment, UNSAFE_CATEGORY_DEFINITIONS)
if violation
puts "Violated Categories: #{violated_categories.join(", ")}"
puts "Explanation: #{explanation}"
else
puts "No issues detected."
end
end
```
A função `moderate_message_with_definitions` expande a função anterior `moderate_message` ao permitir que cada categoria insegura seja associada a uma definição detalhada. Isso ocorre no código substituindo a coleção `unsafe_categories` da função original por um mapeamento `unsafe_category_definitions`. Esse mapeamento associa cada categoria insegura à sua definição correspondente. Tanto os nomes das categorias quanto suas definições são incluídos no prompt.
Notavelmente, a definição da categoria `Specialized Advice` agora especifica os tipos de aconselhamento financeiro que devem ser proibidos. Como resultado, o comentário `It is a great time to invest in gold!`, que anteriormente passava na avaliação de `moderate_message`, agora aciona uma violação.
### Considere o processamento em lote
Para reduzir custos em situações onde a moderação em tempo real não é necessária, considere moderar mensagens em lotes. Inclua múltiplas mensagens dentro do contexto do prompt e peça ao Claude que avalie quais mensagens devem ser moderadas.
```python Python
def batch_moderate_messages(messages, unsafe_categories):
# Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafe_category_str = "\n".join(unsafe_categories)
# Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID
messages_str = "\n".join(
[f"{msg}" for idx, msg in enumerate(messages)]
)
# Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
assessment_prompt = f"""Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
{messages_str}
Unsafe Categories:
{unsafe_category_str}
Respond with ONLY a JSON object, using the format below:
{{
"violations": [
{{
"id": ,
"categories": [list of violated categories],
"explanation":
}}
]
}}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response."""
# Envia a solicitação ao Claude para moderação de conteúdo
response = client.messages.create(
model="claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens=2048, # Increased max token count to handle batches
messages=[{"role": "user", "content": assessment_prompt}],
)
# Analisa a resposta JSON do Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.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"""Comment: {user_comments[violation["id"]]}
Violated Categories: {", ".join(violation["categories"])}
Explanation: {violation["explanation"]}
""")
```
```typescript TypeScript
// Formato da avaliação em lote JSON que o Claude retorna
interface BatchAssessment {
violations: {
id: number;
categories: string[];
explanation: string;
}[];
}
async function batchModerateMessages(
messages: string[],
unsafeCategories: string[]
): Promise {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
const unsafeCategoryStr = unsafeCategories.join("\n");
// Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID
const messagesStr = messages
.map((msg, idx) => `${msg}`)
.join("\n");
// Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
const assessmentPrompt = `Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
${messagesStr}
Unsafe Categories:
${unsafeCategoryStr}
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response.`;
// Envia a solicitação ao Claude para moderação de conteúdo
const response = await client.messages.create({
model: "claude-haiku-4-5-20251001", // Using the Haiku model for lower costs
max_tokens: 2048, // Increased max token count to handle batches
messages: [{ role: "user", content: assessmentPrompt }]
});
// Analisa a resposta JSON do Claude
const textBlock = response.content.find((block) => block.type === "text");
if (!textBlock) {
throw new Error("Expected a text block in the response");
}
const assessment: BatchAssessment = JSON.parse(textBlock.text);
return assessment;
}
// Processa o lote de comentários e obtém a resposta
const batchAssessment = await batchModerateMessages(userComments, unsafeCategories);
// Imprime os resultados para cada violação detectada
for (const violation of batchAssessment.violations) {
console.log(`Comment: ${userComments[violation.id]}
Violated Categories: ${violation.categories.join(", ")}
Explanation: ${violation.explanation}
`);
}
```
```csharp C#
async Task BatchModerateMessages(IReadOnlyList messages, IReadOnlyList categories)
{
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
var unsafeCategoryText = string.Join("\n", categories);
// Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID atribuído
var messagesText = string.Join(
"\n",
messages.Select((message, index) => $"{message}")
);
// Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
var assessmentPrompt = $$"""
Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
{{messagesText}}
Unsafe Categories:
{{unsafeCategoryText}}
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response.
""";
// Envia a solicitação ao Claude para moderação de conteúdo
var response = await client.Messages.Create(
new()
{
Model = Model.ClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens = 2048, // Increased max token count to handle batches
Messages = [new() { Role = Role.User, Content = assessmentPrompt }],
}
);
// Restringe o primeiro bloco de conteúdo a um bloco de texto e, em seguida, analisa a resposta JSON do Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
return JsonNode.Parse(textBlock.Text)!;
}
// Processa o lote de comentários e obtém a resposta
var moderationResults = await BatchModerateMessages(userComments, unsafeCategories);
// Imprime os resultados para cada violação detectada
foreach (var violation in moderationResults["violations"]!.AsArray())
{
var flaggedComment = userComments[violation!["id"]!.GetValue()];
var violatedCategories = string.Join(
", ",
violation["categories"]!.AsArray().Select(category => category!.GetValue())
);
var explanation = violation["explanation"]!.GetValue();
Console.WriteLine($"""
Comment: {flaggedComment}
Violated Categories: {violatedCategories}
Explanation: {explanation}
""");
}
```
```go Go
// batchViolation é uma entrada no array "violations" do Claude: o índice da
// mensagem infratora mais as categorias que ela violou e o motivo.
type batchViolation struct {
ID int `json:"id"`
Categories []string `json:"categories"`
Explanation string `json:"explanation"`
}
func batchModerateMessages(messages []string, unsafeCategories []string) []batchViolation {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID
messageLines := make([]string, len(messages))
for i, message := range messages {
messageLines[i] = fmt.Sprintf("%s", i, message)
}
messagesStr := strings.Join(messageLines, "\n")
// Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
assessmentPrompt := fmt.Sprintf(`Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
%s
Unsafe Categories:
%s
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response.`, messagesStr, unsafeCategoryStr)
// Envia a solicitação ao Claude para moderação de conteúdo
response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeHaiku4_5_20251001, // Using the Haiku model for lower costs
MaxTokens: 2048, // Increased max token count to handle batches
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock(assessmentPrompt)),
},
})
if err != nil {
log.Fatal(err)
}
// Restringe o primeiro bloco de conteúdo a um bloco de texto antes de ler seu texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analisa a resposta JSON do Claude
var assessment struct {
Violations []batchViolation `json:"violations"`
}
if err := json.Unmarshal([]byte(textBlock.Text), &assessment); err != nil {
log.Fatal(err)
}
return assessment.Violations
}
// moderateAllCommentsAsBatch modera o lote inteiro de comentários em uma única
// solicitação e imprime os resultados de cada violação detectada.
func moderateAllCommentsAsBatch() {
// Processa o lote de comentários e obtém a resposta
violations := batchModerateMessages(userComments, unsafeCategories)
// Imprime os resultados de cada violação detectada
for _, violation := range violations {
fmt.Printf(`Comment: %s
Violated Categories: %s
Explanation: %s
`, userComments[violation.ID], strings.Join(violation.Categories, ", "), violation.Explanation)
}
}
```
```java Java
JsonNode batchModerateMessages(List messages, List unsafeCategories)
throws JsonProcessingException {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID
String messagesStr = IntStream.range(0, messages.size())
.mapToObj(idx -> "%s".formatted(idx, messages.get(idx)))
.collect(Collectors.joining("\n"));
// Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
String assessmentPrompt = """
Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
%s
Unsafe Categories:
%s
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response."""
.formatted(messagesStr, unsafeCategoryStr);
// Envia a solicitação ao Claude para moderação de conteúdo
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_HAIKU_4_5_20251001) // Using the Haiku model for lower costs
.maxTokens(2048) // Increased max token count to handle batches
.addUserMessage(assessmentPrompt)
.build());
// Analisa a resposta JSON do Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
return new ObjectMapper().readTree(assessmentJson);
}
// Processa o lote de comentários e imprime os resultados de cada violação detectada
void printBatchViolations() throws JsonProcessingException {
JsonNode response = batchModerateMessages(userComments, unsafeCategories);
ObjectMapper mapper = new ObjectMapper();
for (JsonNode violation : response.required("violations")) {
List violatedCategories =
mapper.convertValue(violation.required("categories"), new TypeReference>() {});
IO.println("""
Comment: %s
Violated Categories: %s
Explanation: %s
""".formatted(
userComments.get(violation.required("id").asInt()),
String.join(", ", violatedCategories),
violation.required("explanation").asText()));
}
}
```
```php PHP
$batchModerateMessages = function (array $messages, array $unsafeCategories) use ($client): array {
// Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID atribuído
$messageLines = [];
foreach ($messages as $idx => $msg) {
$messageLines[] = "{$msg}";
}
$messagesStr = implode("\n", $messageLines);
// Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
$assessmentPrompt = <<
{$messagesStr}
Unsafe Categories:
{$unsafeCategoryStr}
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response.
PROMPT;
// Envia a solicitação ao Claude para moderação de conteúdo
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 2048, // Increased max token count to handle batches
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analisa a resposta JSON do Claude. O SDK decodifica cada bloco de conteúdo
// em sua classe concreta, então encontre o TextBlock antes de ler o texto.
$textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
?? throw new \RuntimeException('Expected a text block in the response.');
return json_decode($textBlock->text, associative: true, flags: JSON_THROW_ON_ERROR);
};
// Processa o lote de comentários e obtém a resposta
$responseObj = $batchModerateMessages($userComments, $unsafeCategories);
// Imprime os resultados para cada violação detectada
foreach ($responseObj['violations'] as $violation) {
echo "Comment: {$userComments[$violation['id']]}\n";
echo 'Violated Categories: ' . implode(', ', $violation['categories']) . "\n";
echo "Explanation: {$violation['explanation']}\n\n";
}
```
```ruby Ruby
def batch_moderate_messages(messages, unsafe_categories)
# Converte as categorias inseguras em uma string, com cada categoria em uma nova linha
unsafe_category_str = unsafe_categories.join("\n")
# Formata a string de mensagens, com cada mensagem envolvida em tags estilo XML e com um ID
messages_str = messages
.map.with_index { |message, index| "#{message}" }
.join("\n")
# Constrói o prompt para o Claude, incluindo as mensagens e as categorias inseguras
assessment_prompt = <<~PROMPT.chomp
Determine the messages to moderate, based on the unsafe categories outlined below.
Messages:
#{messages_str}
Unsafe Categories:
#{unsafe_category_str}
Respond with ONLY a JSON object, using the format below:
{
"violations": [
{
"id": ,
"categories": [list of violated categories],
"explanation":
}
]
}
Important Notes:
- Remember to analyze every message for a violation.
- Select any number of violations that reasonably apply.
- Do not include markdown formatting or code fences in your response.
PROMPT
# Envia a solicitação ao Claude para moderação de conteúdo
response = CLIENT.messages.create(
model: "claude-haiku-4-5-20251001", # Using the Haiku model for lower costs
max_tokens: 2048, # Increased max token count to handle batches
messages: [{role: :user, content: assessment_prompt}]
)
# Analisa a resposta JSON do Claude
text_block = response.content.find { it.type == :text }
JSON.parse(text_block.text)
end
# Processa o lote de comentários e obtém a resposta
response_obj = batch_moderate_messages(USER_COMMENTS, UNSAFE_CATEGORIES)
# Imprime os resultados de cada violação detectada
response_obj["violations"].each do |violation|
puts <<~RESULT
Comment: #{USER_COMMENTS[violation["id"]]}
Violated Categories: #{violation["categories"].join(", ")}
Explanation: #{violation["explanation"]}
RESULT
end
```
Neste exemplo, a função `batch_moderate_messages` lida com a moderação de um lote inteiro de mensagens com uma única chamada à API do Claude. Dentro da função, é criado um prompt que inclui a lista de mensagens a serem avaliadas e as categorias de conteúdo inseguro. O prompt orienta o Claude a retornar um objeto JSON listando todas as mensagens que contêm violações. Cada mensagem na resposta é identificada pelo seu `id`, que corresponde à posição da mensagem no lote. Tenha em mente que encontrar o tamanho de lote ideal para suas necessidades específicas pode exigir alguma experimentação. Embora tamanhos de lote maiores possam reduzir custos, eles também podem levar a uma leve diminuição na qualidade. Além disso, você pode precisar aumentar o parâmetro `max_tokens` na chamada à API do Claude para acomodar respostas mais longas. Para detalhes sobre o número máximo de tokens que o modelo escolhido pode gerar, consulte a [tabela de comparação de modelos](https://platform.claude.com/docs/pt-BR/models/overview#latest-models-comparison).
Veja um exemplo totalmente implementado baseado em código de como usar o Claude para moderação de conteúdo.
Explore técnicas de proteção para moderar interações com o Claude.