---
title: Moderación de contenido
url: https://platform.claude.com/docs/es/about-claude/use-case-guides/content-moderation
description: La moderación de contenido es un aspecto crítico para mantener un entorno seguro, respetuoso y productivo en las aplicaciones digitales. Esta guía analiza cómo se puede usar Claude para moderar contenido dentro de tu aplicación digital.
---
> Visita el [cookbook de moderación de contenido](https://platform.claude.com/cookbook/misc-building-moderation-filter) para ver un ejemplo de implementación de moderación de contenido usando Claude.
Esta guía se centra en la moderación de contenido generado por usuarios dentro de tu aplicación. Si buscas orientación sobre cómo moderar las interacciones con Claude, consulta
[Mitigar jailbreaks e inyecciones de prompts](https://platform.claude.com/docs/es/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks)
.
## Antes de construir con Claude
### Decide si usar Claude para la moderación de contenido
Estos son algunos indicadores clave de que deberías usar un "large language model" (modelo de lenguaje grande), o LLM, como Claude en lugar de un enfoque tradicional de ML o basado en reglas para la moderación de contenido:
Los métodos tradicionales de ML requieren recursos de ingeniería significativos, experiencia en ML y costos de infraestructura. Los sistemas de moderación humana incurren en costos aún más altos. Con Claude, puedes tener un sistema de moderación sofisticado en funcionamiento en mucho menos tiempo y a un costo mucho menor.
Los enfoques tradicionales de ML, como los modelos de bolsa de palabras o la simple coincidencia de patrones, a menudo tienen dificultades para comprender el tono, la intención y el contexto del contenido. Si bien los sistemas de moderación humana sobresalen en la comprensión del significado semántico, requieren tiempo para que el contenido sea revisado. Claude aborda ambas necesidades al combinar la comprensión semántica con la capacidad de entregar decisiones de moderación rápidamente.
Al aprovechar sus capacidades avanzadas de razonamiento, Claude puede interpretar y aplicar pautas de moderación complejas de manera uniforme. Esta consistencia ayuda a garantizar un trato justo de todo el contenido, reduciendo el riesgo de decisiones de moderación inconsistentes o sesgadas que pueden socavar la confianza de los usuarios.
Una vez que se ha establecido un enfoque tradicional de ML, cambiarlo es una tarea laboriosa e intensiva en datos. Por otro lado, a medida que evolucionan las necesidades de tu producto o de tus clientes, Claude puede adaptarse fácilmente a cambios o adiciones en las políticas de moderación sin un extenso reetiquetado de los datos de entrenamiento.
Si quieres proporcionar a los usuarios o reguladores explicaciones claras detrás de las decisiones de moderación, Claude puede generar justificaciones detalladas y coherentes. Esta transparencia es importante para generar confianza y garantizar la rendición de cuentas en las prácticas de moderación de contenido.
Los enfoques tradicionales de ML normalmente requieren modelos separados o extensos procesos de traducción para cada idioma admitido. La moderación humana requiere contratar personal que domine cada idioma admitido. Las capacidades multilingües de Claude le permiten clasificar tickets en varios idiomas sin necesidad de modelos separados ni extensos procesos de traducción, lo que agiliza la moderación para bases de clientes globales.
Las capacidades multimodales de Claude le permiten analizar e interpretar contenido tanto en texto como en imágenes. Esto lo convierte en una herramienta versátil para una moderación de contenido integral en entornos donde diferentes tipos de medios deben evaluarse en conjunto.
Todos los modelos Claude están entrenados con comportamientos de seguridad incorporados. Esto puede hacer que Claude modere contenido considerado particularmente peligroso (de acuerdo con la
[Política de Uso Aceptable](https://www.anthropic.com/legal/aup)
), independientemente del prompt utilizado. Por ejemplo, un sitio web para adultos que quiera permitir a los usuarios publicar contenido sexual explícito puede encontrar que Claude sigue marcando el contenido explícito como que requiere moderación, incluso si especifica en su prompt que no modere contenido sexual explícito. Considera revisar la AUP antes de construir una solución de moderación.
### Genera ejemplos de contenido para moderar
Antes de desarrollar una solución de moderación de contenido, primero crea ejemplos de contenido que debería marcarse y contenido que no debería marcarse. Asegúrate de incluir casos límite y escenarios desafiantes que puedan ser difíciles de manejar eficazmente para un sistema de moderación de contenido. Después, revisa tus ejemplos para crear una lista bien definida de categorías de moderación. Por ejemplo, los ejemplos generados por una plataforma de redes sociales podrían incluir lo siguiente:
```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!",
]
# Comentarios de usuario de ejemplo para probar la moderación de contenido
user_comments = allowed_user_comments + disallowed_user_comments
# Categorías consideradas inseguras para la moderación de contenido
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!"
];
// Comentarios de usuario de ejemplo para probar la moderación de contenido
const userComments = [...allowedUserComments, ...disallowedUserComments];
// Categorías consideradas inseguras para la moderación de contenido
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!",
];
// Comentarios de usuario de ejemplo para probar la moderación de contenido
string[] userComments = [.. allowedUserComments, .. disallowedUserComments];
// Categorías consideradas inseguras para la moderación de contenido
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!",
}
// Comentarios de usuario de ejemplo para probar la moderación de contenido
var userComments = slices.Concat(allowedUserComments, disallowedUserComments)
// Categorías consideradas inseguras para la moderación de contenido
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!");
// Comentarios de usuario de ejemplo para probar la moderación de contenido
final List userComments =
Stream.concat(allowedUserComments.stream(), disallowedUserComments.stream()).toList();
// Categorías consideradas no seguras para la moderación de contenido
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!',
];
// Comentarios de usuario de ejemplo para probar la moderación de contenido
$userComments = [...$allowedUserComments, ...$disallowedUserComments];
// Categorías consideradas inseguras para la moderación de contenido
$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!"
]
# Comentarios de usuario de ejemplo para probar la moderación de contenido
USER_COMMENTS = ALLOWED_USER_COMMENTS + DISALLOWED_USER_COMMENTS
# Categorías consideradas inseguras para la moderación de contenido
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 eficazmente estos ejemplos requiere una comprensión matizada del lenguaje. En el comentario `This movie was great, I really enjoyed it. The main actor really killed it!`, el sistema de moderación de contenido necesita reconocer que "killed it" es una metáfora, no una indicación de violencia real. Por el contrario, a pesar de la falta de menciones explícitas de violencia, el comentario `Delete this post now or you better hide. I am coming after you and your family.` debería ser marcado por el sistema de moderación de contenido.
Las categorías no seguras se pueden personalizar para adaptarse a tus necesidades específicas. Por ejemplo, si quieres evitar que menores de edad creen contenido en tu sitio web, podrías agregar "Underage Posting" a las categorías.
***
## Cómo moderar contenido usando Claude
### Selecciona el modelo Claude adecuado
Al seleccionar un modelo, es importante considerar el tamaño de tus datos. Si los costos son una preocupación, un modelo más pequeño como Claude Haiku 5.5 es una excelente opción por su rentabilidad. A continuación se muestra una estimación del costo de moderar texto para una plataforma de redes sociales que recibe mil millones de publicaciones al mes:
* **Tamaño del contenido**
* Publicaciones por mes: 1 mil millones
* Caracteres por publicación: 100
* Total de caracteres: 100 mil millones
* **Tokens estimados**
* Tokens de entrada: 28.6 mil millones (suponiendo 1 token por cada 3.5 caracteres)
* Porcentaje de mensajes marcados: 3%
* Tokens de salida por mensaje marcado: 50
* Total de tokens de salida: 1.5 mil millones
* **Costo estimado de Claude Haiku 5.5**
* Costo de tokens de entrada: 28,600 MTok \* $0.10/MTok = $2,860 USD
* Costo de tokens de salida: 1,500 MTok \* $0.50/MTok = $750 USD
* Costo mensual: $2,860 + $750 = $3,610 USD
* **Costo estimado de Claude Opus 5**
* Costo de tokens de entrada: 28,600 MTok \* $5.00/MTok = $143,000 USD
* Costo de tokens de salida: 1,500 MTok \* $25.00/MTok = $37,500 USD
* Costo mensual: $143,000 + $37,500 = $180,500 USD
* **Costo estimado de Claude Opus 4.8**
* Costo de tokens de entrada: 28,600 MTok \* $5.00/MTok = $143,000 USD
* Costo de tokens de salida: 1,500 MTok \* $25.00/MTok = $37,500 USD
* Costo mensual: $143,000 + $37,500 = $180,500 USD
Los costos reales pueden diferir de estas estimaciones. Estas estimaciones se basan en el prompt destacado en la sección sobre
[procesamiento por lotes](https://platform.claude.com/docs/es/about-claude/use-case-guides/content-moderation#consider-batch-processing)
. Los tokens de salida se pueden reducir aún más eliminando el campo
`explanation`
de la respuesta.
### Construye un prompt sólido
Para usar Claude en la moderación de contenido, Claude debe comprender los requisitos de moderación de tu aplicación. Comienza escribiendo un prompt que te permita definir tus necesidades de moderación:
```python Python
def moderate_message(message, unsafe_categories):
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = "\n".join(unsafe_categories)
# Construye el prompt para Claude, incluyendo el mensaje y las categorías 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."""
# Envía la solicitud a Claude para la moderación de contenido
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}],
)
# Analiza la respuesta JSON de Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrae el estado de violación de la evaluación
contains_violation = assessment["violation"]
# Si hay una violación, obtiene las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
violated_categories = assessment.get("categories", []) if contains_violation else []
explanation = assessment.get("explanation") if contains_violation else None
return contains_violation, violated_categories, explanation
# Procesa cada comentario e imprime los 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
// Estructura de la evaluación JSON que devuelve Claude
interface ModerationAssessment {
violation: boolean;
categories?: string[];
explanation?: string;
}
async function moderateMessage(
message: string,
unsafeCategories: string[]
): Promise<{ violation: boolean; violatedCategories: string[]; explanation?: string }> {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
const unsafeCategoryStr = unsafeCategories.join("\n");
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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.`;
// Envía la solicitud a Claude para la moderación de contenido
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 }]
});
// Analiza la respuesta JSON de 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);
// Extrae el estado de violación de la evaluación
const containsViolation = assessment.violation;
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
const violatedCategories = containsViolation ? (assessment.categories ?? []) : [];
const explanation = containsViolation ? assessment.explanation : undefined;
return { violation: containsViolation, violatedCategories, explanation };
}
// Procesa cada comentario e imprime los 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
)
{
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
var unsafeCategoryText = string.Join("\n", categories);
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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.
""";
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto y luego analiza la respuesta JSON de Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrae el estado de violación de la evaluación
var containsViolation = assessment["violation"]!.GetValue();
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
List violatedCategories = containsViolation
? assessment["categories"]?.AsArray().Select(category => category!.GetValue()).ToList() ?? []
: [];
var explanation = containsViolation ? assessment["explanation"]?.GetValue() : null;
return (containsViolation, violatedCategories, explanation);
}
// Procesa cada comentario e imprime los 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) {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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)
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto antes de leer su texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analiza la respuesta JSON de 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)
}
// Si hay una infracción, devuelve las categorías y la explicación; de lo contrario, usa valores predeterminados vacíos
if !assessment.Violation {
return false, nil, ""
}
return true, assessment.Categories, assessment.Explanation
}
// moderateAllComments procesa cada comentario e imprime los 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 {
// Convierte las categorías no seguras en una cadena, con cada categoría en una nueva línea
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Construye el prompt para Claude, incluyendo el mensaje y las categorías no seguras
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);
// Envía la solicitud a Claude para la moderación de contenido
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());
// Analiza la respuesta JSON de Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrae el estado de violación de la evaluación
boolean containsViolation = assessment.required("violation").asBoolean();
// Si hay una violación, obtiene las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
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);
}
// Procesa cada comentario e imprime los 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 {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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;
// Envía la solicitud a Claude para la moderación de contenido
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analiza la respuesta JSON de Claude. El SDK decodifica cada bloque de contenido
// en su clase concreta, así que busca el TextBlock antes de leer el 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);
// Extrae el estado de violación de la evaluación
$containsViolation = $assessment['violation'];
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
$violatedCategories = $containsViolation ? ($assessment['categories'] ?? []) : [];
$explanation = $containsViolation ? ($assessment['explanation'] ?? null) : null;
return [$containsViolation, $violatedCategories, $explanation];
};
// Procesa cada comentario e imprime los 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)
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = unsafe_categories.join("\n")
# Construye el prompt para Claude, incluyendo el mensaje y las categorías 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
# Envía la solicitud a Claude para la moderación de contenido
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}]
)
# Analiza la respuesta JSON de Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrae el estado de violación de la evaluación
contains_violation = assessment["violation"]
# Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
violated_categories = contains_violation ? assessment.fetch("categories", []) : []
explanation = contains_violation ? assessment["explanation"] : nil
[contains_violation, violated_categories, explanation]
end
# Procesa cada comentario e imprime los 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
```
En este ejemplo, la función `moderate_message` contiene un prompt de evaluación que incluye las categorías de contenido no seguro y el mensaje a evaluar. El prompt le pide a Claude que evalúe si el mensaje debe ser moderado, basándose en las categorías no seguras que definiste anteriormente.
Luego, la evaluación del modelo se analiza para determinar si existe una infracción. Si existe una infracción, Claude también devuelve una lista de las categorías infringidas y una explicación de por qué el mensaje no es seguro.
### Evalúa tu prompt
La moderación de contenido es un problema de clasificación. Por lo tanto, puedes usar las mismas técnicas descritas en el [cookbook de clasificación](https://platform.claude.com/cookbook/capabilities-classification-guide) para determinar la precisión de tu sistema de moderación de contenido.
Una consideración adicional es que, en lugar de tratar la moderación de contenido como un problema de clasificación binaria, puedes crear múltiples categorías para representar varios niveles de riesgo. Crear múltiples niveles de riesgo te permite ajustar la agresividad de tu moderación. Por ejemplo, podrías querer bloquear automáticamente las consultas de usuarios que se consideren de alto riesgo, mientras que los usuarios con muchas consultas de riesgo medio se marcan para revisión humana.
```python Python
def assess_risk_level(message, unsafe_categories):
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = "\n".join(unsafe_categories)
# Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
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."""
# Envía la solicitud a Claude para la evaluación de riesgo
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}],
)
# Analiza la respuesta JSON de Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
risk_level = assessment["risk_level"]
violated_categories = assessment["categories"]
explanation = assessment.get("explanation")
return risk_level, violated_categories, explanation
# Procesa cada comentario e imprime los 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
// Estructura de la evaluación de riesgo JSON que devuelve Claude
interface RiskAssessment {
risk_level: number;
categories: string[];
explanation?: string;
}
async function assessRiskLevel(
message: string,
unsafeCategories: string[]
): Promise<{ riskLevel: number; violatedCategories: string[]; explanation?: string }> {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
const unsafeCategoryStr = unsafeCategories.join("\n");
// Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
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.`;
// Envía la solicitud a Claude para la evaluación de riesgo
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 }]
});
// Analiza la respuesta JSON de 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);
// Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
const { risk_level: riskLevel, categories: violatedCategories, explanation } = assessment;
return { riskLevel, violatedCategories, explanation };
}
// Procesa cada comentario e imprime los 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
)
{
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
var unsafeCategoryText = string.Join("\n", categories);
// Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
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.
""";
// Envía la solicitud a Claude para la evaluación de riesgo
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 el primer bloque de contenido a un bloque de texto y luego analiza la respuesta JSON de Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
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);
}
// Procesa cada comentario e imprime los 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) {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
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)
// Envía la solicitud a Claude para la evaluación de riesgo
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 el primer bloque de contenido a un bloque de texto antes de leer su texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analiza la respuesta JSON de 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)
}
// Devuelve el nivel de riesgo, las categorías infringidas y la explicación de la evaluación
return assessment.RiskLevel, assessment.Categories, assessment.Explanation
}
// assessAllRiskLevels procesa cada comentario e imprime los 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 {
// Convierte las categorías no seguras en una cadena, con cada categoría en una nueva línea
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Construye el prompt para Claude, incluyendo el mensaje, las categorías no seguras y las definiciones de niveles de riesgo
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);
// Envía la solicitud a Claude para la evaluación de riesgo
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());
// Analiza la respuesta JSON de Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
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);
}
// Procesa cada comentario e imprime los 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 {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
$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;
// Envía la solicitud a Claude para la evaluación de riesgo
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analiza la respuesta JSON de Claude. El SDK decodifica cada bloque de contenido
// en su clase concreta, así que busca el TextBlock antes de leer el 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);
// Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
$riskLevel = $assessment['risk_level'];
$violatedCategories = $assessment['categories'];
$explanation = $assessment['explanation'] ?? null;
return [$riskLevel, $violatedCategories, $explanation];
};
// Procesa cada comentario e imprime los 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)
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = unsafe_categories.join("\n")
# Construye el prompt para Claude, incluyendo el mensaje, las categorías inseguras y las definiciones de niveles de riesgo
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
# Envía la solicitud a Claude para la evaluación de riesgo
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}]
)
# Analiza la respuesta JSON de Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrae el nivel de riesgo, las categorías violadas y la explicación de la evaluación
risk_level = assessment["risk_level"]
violated_categories = assessment["categories"]
explanation = assessment["explanation"]
[risk_level, violated_categories, explanation]
end
# Procesa cada comentario e imprime los 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 una función `assess_risk_level` que usa Claude para evaluar el nivel de riesgo de un mensaje. La función acepta un mensaje y las categorías no seguras como entradas.
Dentro de la función, se genera un prompt para Claude que incluye el mensaje a evaluar, las categorías no seguras e instrucciones específicas para evaluar el nivel de riesgo. El prompt le indica a Claude que responda con un objeto JSON que incluya el nivel de riesgo, las categorías infringidas y una explicación opcional.
Este enfoque permite una moderación de contenido flexible mediante la asignación de niveles de riesgo. Se puede integrar sin problemas en un sistema más grande para automatizar el filtrado de contenido o marcar comentarios para revisión humana según su nivel de riesgo evaluado. Por ejemplo, al ejecutar este código, el comentario `Delete this post now or you better hide. I am coming after you and your family.` se identifica como de alto riesgo debido a su peligrosa amenaza. Por el contrario, el comentario `Stay away from the 5G cellphones!! They are using 5G to control you.` se categoriza como de riesgo medio.
### Despliega tu prompt
Una vez que estés seguro de la calidad de tu solución, es momento de desplegarla en producción. Estas son algunas buenas prácticas a seguir al usar la moderación de contenido en producción:
1. **Proporciona retroalimentación clara a los usuarios:** Cuando la entrada de un usuario se bloquea o una respuesta se marca debido a la moderación de contenido, proporciona retroalimentación informativa y constructiva para ayudar a los usuarios a comprender por qué su mensaje fue marcado y cómo pueden reformularlo apropiadamente. En los ejemplos de código anteriores, esto se hace a través del campo `explanation` en la respuesta de Claude.
2. **Analiza el contenido moderado:** Lleva un registro de los tipos de contenido que marca tu sistema de moderación para identificar tendencias y posibles áreas de mejora.
3. **Evalúa y mejora continuamente:** Evalúa regularmente el rendimiento de tu sistema de moderación de contenido usando métricas como el seguimiento de precisión y exhaustividad (recall). Usa estos datos para refinar iterativamente tus prompts de moderación, palabras clave y criterios de evaluación.
***
## Mejora el rendimiento
En escenarios complejos, puede ser útil considerar estrategias adicionales para mejorar el rendimiento más allá de las [técnicas de ingeniería de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/overview) estándar. Estas son algunas estrategias avanzadas:
### Define temas y proporciona ejemplos
Además de enumerar las categorías no seguras en el prompt, se pueden lograr mejoras adicionales proporcionando definiciones y frases relacionadas con cada categoría.
```python Python
# Categorías consideradas inseguras para la moderación de contenido, con sus definiciones
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):
# Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
unsafe_category_str = "\n".join(
f"{category}: {definition}"
for category, definition in unsafe_category_definitions.items()
)
# Construye el prompt para Claude, incluyendo el mensaje y las categorías 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."""
# Envía la solicitud a Claude para la moderación de contenido
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}],
)
# Analiza la respuesta JSON de Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
# Extrae el estado de violación de la evaluación
contains_violation = assessment["violation"]
# Si hay una violación, obtiene las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
violated_categories = assessment.get("categories", []) if contains_violation else []
explanation = assessment.get("explanation") if contains_violation else None
return contains_violation, violated_categories, explanation
# Procesa cada comentario e imprime los 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
// Estructura de la evaluación JSON que devuelve Claude
interface DefinitionBasedAssessment {
violation: boolean;
categories?: string[];
explanation?: string;
}
// Categorías consideradas inseguras para la moderación de contenido, con sus definiciones
// (las claves del objeto conservan el orden de inserción, así que las categorías se muestran en este orden)
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 }> {
// Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
const unsafeCategoryStr = Object.entries(unsafeCategoryDefinitions)
.map(([category, definition]) => `${category}: ${definition}`)
.join("\n");
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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.`;
// Envía la solicitud a Claude para la moderación de contenido
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 }]
});
// Analiza la respuesta JSON de 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);
// Extrae el estado de violación de la evaluación
const containsViolation = assessment.violation;
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
const violatedCategories = containsViolation ? (assessment.categories ?? []) : [];
const explanation = containsViolation ? assessment.explanation : undefined;
return { violation: containsViolation, violatedCategories, explanation };
}
// Procesa cada comentario e imprime los 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#
// Categorías consideradas inseguras para la moderación de contenido, con sus definiciones.
// Las entradas mantienen el orden de inserción, por lo que el prompt generado lista las categorías
// exactamente en este orden.
(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
)
{
// Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
var unsafeCategoryText = string.Join(
"\n",
categoryDefinitions.Select(entry => $"{entry.Category}: {entry.Definition}")
);
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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.
""";
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto y luego analiza la respuesta JSON de Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
var assessment = JsonNode.Parse(textBlock.Text)!;
// Extrae el estado de violación de la evaluación
var containsViolation = assessment["violation"]!.GetValue();
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
List violatedCategories = containsViolation
? assessment["categories"]?.AsArray().Select(category => category!.GetValue()).ToList() ?? []
: [];
var explanation = containsViolation ? assessment["explanation"]?.GetValue() : null;
return (containsViolation, violatedCategories, explanation);
}
// Procesa cada comentario e imprime los 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
// Categorías consideradas inseguras para la moderación de contenido, con sus definiciones.
// Un slice de pares categoría/definición (en lugar de un map) mantiene estable el orden
// de renderizado; los maps de Go iteran en orden aleatorio.
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) {
// Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
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")
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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)
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto antes de leer su texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analiza la respuesta JSON de 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)
}
// Si hay una infracción, devuelve las categorías y la explicación; de lo contrario, usa valores predeterminados vacíos
if !assessment.Violation {
return false, nil, ""
}
return true, assessment.Categories, assessment.Explanation
}
// moderateAllCommentsWithDefinitions procesa cada comentario e imprime los 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
// Categorías consideradas no seguras para la moderación de contenido, con sus definiciones
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 {
// Formatea la cadena de categorías no seguras, con cada categoría y su definición en una nueva línea
String unsafeCategoryStr = unsafeCategoryDefinitions.stream()
.map(categoryDefinition ->
categoryDefinition.category() + ": " + categoryDefinition.definition())
.collect(Collectors.joining("\n"));
// Construye el prompt para Claude, incluyendo el mensaje y las categorías no seguras
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);
// Envía la solicitud a Claude para la moderación de contenido
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());
// Analiza la respuesta JSON de Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
ObjectMapper mapper = new ObjectMapper();
JsonNode assessment = mapper.readTree(assessmentJson);
// Extrae el estado de violación de la evaluación
boolean containsViolation = assessment.required("violation").asBoolean();
// Si hay una violación, obtiene las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
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);
}
// Procesa cada comentario e imprime los 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
// Categorías consideradas inseguras para la moderación de contenido, con sus definiciones
$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 {
// Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
$categoryLines = [];
foreach ($unsafeCategoryDefinitions as $category => $definition) {
$categoryLines[] = "{$category}: {$definition}";
}
$unsafeCategoryStr = implode("\n", $categoryLines);
// Construye el prompt para Claude, incluyendo el mensaje y las categorías 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;
// Envía la solicitud a Claude para la moderación de contenido
$response = $client->messages->create(
model: 'claude-haiku-4-5-20251001', // Using the Haiku model for lower costs
maxTokens: 200,
messages: [['role' => 'user', 'content' => $assessmentPrompt]],
);
// Analiza la respuesta JSON de Claude. El SDK decodifica cada bloque de contenido
// en su clase concreta, así que busca el TextBlock antes de leer el 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);
// Extrae el estado de violación de la evaluación
$containsViolation = $assessment['violation'];
// Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
$violatedCategories = $containsViolation ? ($assessment['categories'] ?? []) : [];
$explanation = $containsViolation ? ($assessment['explanation'] ?? null) : null;
return [$containsViolation, $violatedCategories, $explanation];
};
// Procesa cada comentario e imprime los 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
# Categorías consideradas inseguras para la moderación de contenido, con sus definiciones
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)
# Formatea la cadena de categorías inseguras, con cada categoría y su definición en una nueva línea
unsafe_category_str = unsafe_category_definitions
.map { |category, definition| "#{category}: #{definition}" }
.join("\n")
# Construye el prompt para Claude, incluyendo el mensaje y las categorías 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
# Envía la solicitud a Claude para la moderación de contenido
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}]
)
# Analiza la respuesta JSON de Claude
text_block = response.content.find { it.type == :text }
assessment = JSON.parse(text_block.text)
# Extrae el estado de violación de la evaluación
contains_violation = assessment["violation"]
# Si hay una violación, obtén las categorías y la explicación; de lo contrario, usa valores vacíos por defecto
violated_categories = contains_violation ? assessment.fetch("categories", []) : []
explanation = contains_violation ? assessment["explanation"] : nil
[contains_violation, violated_categories, explanation]
end
# Procesa cada comentario e imprime los 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
```
La función `moderate_message_with_definitions` amplía la función anterior `moderate_message` al permitir que cada categoría no segura se asocie con una definición detallada. Esto ocurre en el código al reemplazar la colección `unsafe_categories` de la función original con un mapeo `unsafe_category_definitions`. Este mapeo asocia cada categoría no segura con su definición correspondiente. Tanto los nombres de las categorías como sus definiciones se incluyen en el prompt.
Cabe destacar que la definición de la categoría `Specialized Advice` ahora especifica los tipos de asesoramiento financiero que deberían prohibirse. Como resultado, el comentario `It is a great time to invest in gold!`, que anteriormente pasaba la evaluación de `moderate_message`, ahora genera una infracción.
### Considera el procesamiento por lotes
Para reducir costos en situaciones donde la moderación en tiempo real no es necesaria, considera moderar los mensajes por lotes. Incluye múltiples mensajes dentro del contexto del prompt y pídele a Claude que evalúe qué mensajes deben ser moderados.
```python Python
def batch_moderate_messages(messages, unsafe_categories):
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = "\n".join(unsafe_categories)
# Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
messages_str = "\n".join(
[f"{msg}" for idx, msg in enumerate(messages)]
)
# Construye el prompt para Claude, incluyendo los mensajes y las categorías 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."""
# Envía la solicitud a Claude para la moderación de contenido
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}],
)
# Analiza la respuesta JSON de Claude
text_block = next(block for block in response.content if block.type == "text")
assessment = json.loads(text_block.text)
return assessment
# Procesa el lote de comentarios y obtiene la respuesta
response_obj = batch_moderate_messages(user_comments, unsafe_categories)
# Imprime los resultados de cada violación detectada
for violation in response_obj["violations"]:
print(f"""Comment: {user_comments[violation["id"]]}
Violated Categories: {", ".join(violation["categories"])}
Explanation: {violation["explanation"]}
""")
```
```typescript TypeScript
// Estructura de la evaluación JSON por lotes que devuelve Claude
interface BatchAssessment {
violations: {
id: number;
categories: string[];
explanation: string;
}[];
}
async function batchModerateMessages(
messages: string[],
unsafeCategories: string[]
): Promise {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
const unsafeCategoryStr = unsafeCategories.join("\n");
// Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
const messagesStr = messages
.map((msg, idx) => `${msg}`)
.join("\n");
// Construye el prompt para Claude, incluyendo los mensajes y las categorías 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.`;
// Envía la solicitud a Claude para la moderación de contenido
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 }]
});
// Analiza la respuesta JSON de 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;
}
// Procesa el lote de comentarios y obtén la respuesta
const batchAssessment = await batchModerateMessages(userComments, unsafeCategories);
// Imprime los resultados de cada violación 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)
{
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
var unsafeCategoryText = string.Join("\n", categories);
// Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
var messagesText = string.Join(
"\n",
messages.Select((message, index) => $"{message}")
);
// Construye el prompt para Claude, incluyendo los mensajes y las categorías 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.
""";
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto y luego analiza la respuesta JSON de Claude
if (!response.Content[0].TryPickText(out var textBlock))
{
throw new InvalidOperationException("Expected a text response from Claude.");
}
return JsonNode.Parse(textBlock.Text)!;
}
// Procesa el lote de comentarios y obtén la respuesta
var moderationResults = await BatchModerateMessages(userComments, unsafeCategories);
// Imprime los resultados de cada violación 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 es una entrada en el arreglo "violations" de Claude: el índice del
// mensaje infractor más las categorías que infringió y el motivo.
type batchViolation struct {
ID int `json:"id"`
Categories []string `json:"categories"`
Explanation string `json:"explanation"`
}
func batchModerateMessages(messages []string, unsafeCategories []string) []batchViolation {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafeCategoryStr := strings.Join(unsafeCategories, "\n")
// Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
messageLines := make([]string, len(messages))
for i, message := range messages {
messageLines[i] = fmt.Sprintf("%s", i, message)
}
messagesStr := strings.Join(messageLines, "\n")
// Construye el prompt para Claude, incluyendo los mensajes y las categorías 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)
// Envía la solicitud a Claude para la moderación de contenido
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 el primer bloque de contenido a un bloque de texto antes de leer su texto
textBlock, ok := response.Content[0].AsAny().(anthropic.TextBlock)
if !ok {
log.Fatalf("expected a text block, got %q", response.Content[0].Type)
}
// Analiza la respuesta JSON de 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 el lote completo de comentarios en una sola
// solicitud e imprime los resultados de cada infracción detectada.
func moderateAllCommentsAsBatch() {
// Procesa el lote de comentarios y obtiene la respuesta
violations := batchModerateMessages(userComments, unsafeCategories)
// Imprime los resultados de cada infracción 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 {
// Convierte las categorías no seguras en una cadena, con cada categoría en una nueva línea
String unsafeCategoryStr = String.join("\n", unsafeCategories);
// Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
String messagesStr = IntStream.range(0, messages.size())
.mapToObj(idx -> "%s".formatted(idx, messages.get(idx)))
.collect(Collectors.joining("\n"));
// Construye el prompt para Claude, incluyendo los mensajes y las categorías no seguras
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);
// Envía la solicitud a Claude para la moderación de contenido
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());
// Analiza la respuesta JSON de Claude
String assessmentJson = response.content().stream()
.flatMap(contentBlock -> contentBlock.text().stream())
.findFirst()
.orElseThrow()
.text();
return new ObjectMapper().readTree(assessmentJson);
}
// Procesa el lote de comentarios e imprime los resultados de cada violación 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 {
// Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
$unsafeCategoryStr = implode("\n", $unsafeCategories);
// Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
$messageLines = [];
foreach ($messages as $idx => $msg) {
$messageLines[] = "{$msg}";
}
$messagesStr = implode("\n", $messageLines);
// Construye el prompt para Claude, incluyendo los mensajes y las categorías 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;
// Envía la solicitud a Claude para la moderación de contenido
$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]],
);
// Analiza la respuesta JSON de Claude. El SDK decodifica cada bloque de contenido
// en su clase concreta, así que busca el TextBlock antes de leer el 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);
};
// Procesa el lote de comentarios y obtén la respuesta
$responseObj = $batchModerateMessages($userComments, $unsafeCategories);
// Imprime los resultados de cada violación 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)
# Convierte las categorías inseguras en una cadena, con cada categoría en una nueva línea
unsafe_category_str = unsafe_categories.join("\n")
# Formatea la cadena de mensajes, con cada mensaje envuelto en etiquetas tipo XML y con un ID asignado
messages_str = messages
.map.with_index { |message, index| "#{message}" }
.join("\n")
# Construye el prompt para Claude, incluyendo los mensajes y las categorías 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
# Envía la solicitud a Claude para la moderación de contenido
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}]
)
# Analiza la respuesta JSON de Claude
text_block = response.content.find { it.type == :text }
JSON.parse(text_block.text)
end
# Procesa el lote de comentarios y obtén la respuesta
response_obj = batch_moderate_messages(USER_COMMENTS, UNSAFE_CATEGORIES)
# Imprime los resultados de cada violación detectada
response_obj["violations"].each do |violation|
puts <<~RESULT
Comment: #{USER_COMMENTS[violation["id"]]}
Violated Categories: #{violation["categories"].join(", ")}
Explanation: #{violation["explanation"]}
RESULT
end
```
En este ejemplo, la función `batch_moderate_messages` maneja la moderación de un lote completo de mensajes con una sola llamada a la API de Claude. Dentro de la función, se crea un prompt que incluye la lista de mensajes a evaluar y las categorías de contenido no seguro. El prompt le indica a Claude que devuelva un objeto JSON que enumere todos los mensajes que contienen infracciones. Cada mensaje en la respuesta se identifica por su `id`, que corresponde a la posición del mensaje en el lote. Ten en cuenta que encontrar el tamaño de lote óptimo para tus necesidades específicas puede requerir cierta experimentación. Si bien los tamaños de lote más grandes pueden reducir los costos, también podrían provocar una ligera disminución en la calidad. Además, es posible que necesites aumentar el parámetro `max_tokens` en la llamada a la API de Claude para dar cabida a respuestas más largas. Para obtener detalles sobre el número máximo de tokens que puede generar el modelo que elegiste, consulta la [tabla de comparación de modelos](https://platform.claude.com/docs/es/models/overview#latest-models-comparison).
Consulta un ejemplo basado en código completamente implementado de cómo usar Claude para la moderación de contenido.
Explora técnicas de protección para moderar las interacciones con Claude.