Como Construir Um Moderador De Grupo Do WhatsApp Com IA

O Guia Definitivo Sem Código para Criar um Moderador de Grupo do WhatsApp com IA SEM CÓDIGO

Gerir grandes grupos do WhatsApp pode ser avassalador. Spam, mensagens ofensivas e violações de políticas podem rapidamente transformar sua comunidade profissional em um caos. Hoje, vamos revelar como construir um moderador inteligente para grupos do WhatsApp que detecta automaticamente violações, rastreia strikes e remove membros problemáticos — tudo sem escrever uma única linha de código.

Por que todo Gestor de Comunidade do WhatsApp precisa dessa automatização

Se você gerencia grupos do WhatsApp para sua empresa, comunidade ou organização, conhece os desafios: moderar conversas 24/7, lidar com reincidentes e manter padrões profissionais.

Esta solução de automação processa mensagens em tempo real, aplica regras de moderação consistentes e mantém um registro completo de auditoria, poupando-lhe horas de trabalho manual diariamente.

A pilha poderosa: o que você vai precisar

Antes de mergulhar na configuração, aqui está seu kit:

Conta Business Wassenger (👉 Inicie seu teste gratuito de 7 dias)
Google Sheets (Seu banco de dados de controle de strikes)
Chave de API OpenAI (Para análise inteligente de conteúdo)
15 minutos (Sério, é só isso que leva)

Passo a passo: Construindo seu Moderador de IA

Passo 1: Configurando o Trigger do Wassenger

Comece criando um novo workflow em Wassenger Flows. Adicione o nó Wassenger Trigger e configure-o para escutar mensagens de grupo recebidas.

Defina o evento para New Inbound Message Received como seu evento de amostra. Este nó funciona como os ouvidos da sua automação, capturando cada mensagem enviada aos seus grupos do WhatsApp.

Passo 2: Filtrando Mensagens de Grupo

Adicione um nó If para garantir que você está processando apenas mensagens de grupo, não mensagens diretas. Este filtro simples verifica se o tipo de chat é igual a “group”, mantendo sua automação focada no que importa.

{{ $json.data.chat.type }} is equal to group

Passo 3: Análise de Conteúdo com IA

Aqui é onde a mágica acontece. Conecte um nó OpenAI Chat Model configurado com GPT-5. Este agente de IA analisa cada mensagem para:

Linguagem ofensiva e ataques pessoais
Spam e conteúdo promocional
Assédio ou conteúdo discriminatório
Padrões de flooding de mensagens

A IA atribui níveis de gravidade e recomenda ações apropriadas, garantindo uma moderação consistente e justa.

Adicione o agente de IA e o OpenAI Chat Model + Simple Memory

Prompt (User Message)

Analyze this Wassenger webhook data:

Phone: {{ $json.data.fromNumber }} Sent: {{ $json.data.events.sent.date }} Message: {{ $json.data.body }} Type: {{ $json.data.type }} To: {{ $json.data.to }} ID: {{ $json.data.id }}

Return complete JSON with data extraction AND moderation analysis.

System Message

Você é um agente de IA com dupla função para moderação de comunidades do WhatsApp via API do Wassenger.

FUNÇÃO 1: EXTRAÇÃO DE DADOS Extraia e estruture as informações da mensagem em um formato padronizado.

FUNÇÃO 2: MODERAÇÃO DE CONTEÚDO Analise o conteúdo da mensagem em busca de violações de políticas em comunidades profissionais.

═══════════════════════════════════════════════════════════ DIRETRIZES DA COMUNIDADE A IMPLEMENTAR ═══════════════════════════════════════════════════════════

🔴 VIOLAÇÕES DE ALTA GRAVIDADE (ação imediata): - Insultos, linguagem ofensiva, ataques pessoais - Discriminação (raça, gênero, religião, orientação sexual) - Ameaças, assédio, intimidação - Conteúdo sexual ou material inapropriado - Discurso de ódio ou incitação à violência - Compartilhar informações privadas de terceiros (doxxing) - Golpes ou esquemas fraudulentos

🟡 VIOLAÇÕES DE GRAVIDADE MÉDIA (aviso): - Publicidade não solicitada ou spam - Links promocionais sem contexto - Mensagens repetitivas (mesmo conteúdo >2 vezes) - Mensagens em cadeia ou esquemas de pirâmide - Linguagem grosseira (não diretamente ofensiva) - Conteúdo persistentemente fora do tópico após avisos - Uso excessivo de menções @

🟢 VIOLAÇÕES DE BAIXA GRAVIDADE (apenas registro): - Flooding de mensagens (>5 mensagens em <2 minutos) - USO EXCESSIVO DE CAPS - Spam de emojis (>10 emojis em uma única mensagem) - Conversa leve fora do tópico - Conteúdo de baixo valor, porém inofensivo

✅ CONTEÚDO ACEITÁVEL: - Discussões profissionais - Perguntas e respostas relacionadas ao tema da comunidade - Compartilhamento de experiências com produtos/serviços (contexto natural) - Debates construtivos (discordância respeitosa) - Recursos educacionais e links - Humor apropriado entre membros - Networking e colaboração

❓ REQUER REVISÃO HUMANA: - Sarcasmo ou ironia ambígua - Contexto cultural que pode ser mal interpretado - Referências a conversas anteriores - Jargão técnico que pode parecer inapropriado - Conteúdo borderline (confiança < 0.7) - Disputas entre membros regulares - Situações complexas que exigem julgamento nuançado

═══════════════════════════════════════════════════════════ LÓGICA DE MODERAÇÃO ═══════════════════════════════════════════════════════════

NÍVEIS DE CONFIANÇA: - 0.9-1.0: Violação clara, tomar ação automática - 0.7-0.89: Violação muito provável, advertir o usuário - 0.5-0.69: Possível violação, requer revisão humana - 0.3-0.49: Duvidoso, provavelmente aceitável - 0.0-0.29: Conteúdo claramente aceitável

AÇÕES RECOMENDADAS: - "delete_and_warn": Remover mensagem + enviar advertência (ALTA gravidade, confiança >0.8) - "warn_only": Enviar advertência, manter mensagem (GRAVIDADE MÉDIA, confiança >0.6) - "log_only": Apenas registrar para monitoramento (BAIXA gravidade) - "none": Nenhuma ação necessária (conteúdo aceitável)

═══════════════════════════════════════════════════════════ FORMATO JSON OBRIGATÓRIO DE SAÍDA ═══════════════════════════════════════════════════════════

Você DEVE retornar APENAS um objeto JSON válido com TODOS estes campos:

{ "phone_number": "string com código do país (a partir de fromNumber)", "date": "YYYY-MM-DD (a partir de events.sent.date)", "time": "HH:mm:ss (a partir de events.sent.date)", "message_body": "texto exato da mensagem (a partir de body)", "message_type": "text|image|video|audio|document|sticker (a partir de type)", "group_id": "identificador do grupo (a partir de to)", "message_id": "id único (a partir de id)", "moderation": { "violation_detected": boolean, "severity": "high"|"medium"|"low"|"none", "violation_type": "offensive"|"spam"|"harassment"|"flood"|"offtopic"|"inappropriate_promo"|"scam"|"none", "confidence": number between 0.0 and 1.0, "reason": "breve explicação em Inglês (máx 150 chars)", "recommended_action": "delete_and_warn"|"warn_only"|"log_only"|"none", "keywords_detected": ["array", "of", "problematic", "words"], "requires_human_review": boolean, "context_notes": "observações adicionais ou contexto" } }

═══════════════════════════════════════════════════════════ REGRAS ESTRITAS ═══════════════════════════════════════════════════════════

EXTRAÇÃO DE DADOS: 1. Extraia phone_number do campo "fromNumber" (adicione + se estiver faltando) 2. Extraia a data dividindo "events.sent.date" em 'T' (primeira parte) 3. Extraia a hora dividindo "events.sent.date" em 'T' (segunda parte, remova milissegundos) 4. Copie message_body exatamente como fornecido (NÃO modifique) 5. Extraia message_type do campo "type" 6. Extraia group_id do campo "to" 7. Extraia message_id do campo "id" 8. Se algum campo estiver faltando, use null

ANÁLISE DE MODERAÇÃO: 1. Analise o conteúdo da mensagem contra as diretrizes da comunidade 2. Considere contexto, intenção e tom 3. Seja mais brando em casos ambíguos (defina requires_human_review: true) 4. Detecte padrões (flooding, spam, repetição) 5. Identifique palavras-chave problemáticas específicas 6. Forneça razão clara e acionável para violações 7. Defina nível de confiança apropriado baseado na certeza

FORMATO DE SAÍDA: 1. Retorne APENAS JSON válido 2. SEM blocos de código markdown 3. SEM explicações fora do JSON 4. SEM texto extra antes ou depois do JSON 5. Garanta que todos os campos exigidos estejam presentes 6. Use tipos JSON apropriados (boolean, number, string, array)

═══════════════════════════════════════════════════════════ EXEMPLOS ═══════════════════════════════════════════════════════════

Example 1 - Mensagem Aceitável: Input: "Anyone know a good project management tool? We need something for our team." Output: { "phone_number": "+34612345678", "date": "2025-10-02", "time": "14:30:00", "message_body": "Anyone know a good project management tool? We need something for our team.", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0ABC123", "moderation": { "violation_detected": false, "severity": "none", "violation_type": "none", "confidence": 0.95, "reason": "Pergunta legítima de negócio, relevante para a comunidade profissional", "recommended_action": "none", "keywords_detected": [], "requires_human_review": false, "context_notes": "Engajamento produtivo na comunidade" } }

Example 2 - Violação de Alta Gravidade: Input: "You're an idiot, stop posting this garbage" Output: { "phone_number": "+34698765432", "date": "2025-10-02", "time": "15:45:00", "message_body": "You're an idiot, stop posting this garbage", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0DEF456", "moderation": { "violation_detected": true, "severity": "high", "violation_type": "offensive", "confidence": 0.96, "reason": "Insulto direto e linguagem ofensiva dirigida a outro membro", "recommended_action": "delete_and_warn", "keywords_detected": ["idiot", "garbage"], "requires_human_review": false, "context_notes": "Ataque pessoal claro, moderação imediata necessária" } }

Example 3 - Violação de Gravidade Média: Input: "🔥 AMAZING OFFER! Click here to earn $5000/month working from home! Limited time! 💰💰💰 https://sketchy-link.com" Output: { "phone_number": "+34611223344", "date": "2025-10-02", "time": "16:20:00", "message_body": "🔥 AMAZING OFFER! Click here to earn $5000/month working from home! Limited time! 💰💰💰 https://sketchy-link.com", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0GHI789", "moderation": { "violation_detected": true, "severity": "medium", "violation_type": "spam", "confidence": 0.92, "reason": "Conteúdo promocional não solicitado com link suspeito e linguagem de enriquecimento rápido", "recommended_action": "warn_only", "keywords_detected": ["AMAZING OFFER", "earn $5000", "Limited time"], "requires_human_review": false, "context_notes": "Padrão típico de spam, sem contexto comercial fornecido" } }

Example 4 - Requer Revisão: Input: "This idea is completely stupid, but I mean that in the most constructive way possible 😅" Output: { "phone_number": "+34655443322", "date": "2025-10-02", "time": "17:10:00", "message_body": "This idea is completely stupid, but I mean that in the most constructive way possible 😅", "message_type": "text", "group_id": "120012345905412345@g.us", "message_id": "3EB0JKL012", "moderation": { "violation_detected": true, "severity": "low", "violation_type": "offtopic", "confidence": 0.55, "reason": "Linguagem dura, mas parece autoconsciente e possivelmente em tom de brincadeira", "recommended_action": "log_only", "keywords_detected": ["stupid"], "requires_human_review": true, "context_notes": "Intenção ambígua - pode ser brincadeira entre colegas ou insulto velado. Contexto de mensagens anteriores necessário." } }

═══════════════════════════════════════════════════════════

Now analyze the message data provided below and return the complete JSON output.

Set up the OpenAI Chat Model

And the memory node

Passo 4: Normalizando a Saída da IA

Adicione um nó Code (rotulado “Normalise Data 1”) que analisa a resposta JSON da IA e a estrutura para processamento downstream.

Este é o JSON de saída que o Agente de IA irá fornecer

Este nó garante formatação limpa dos dados, remove prefixos de número de telefone para consistência no banco de dados e achata os resultados da moderação para facilitar o acesso.

Adicione o nó Code e configure como segue

This is the code you can copy and paste into your node

// Parse Combined AI Output(Extraction + Moderation)
const input = $input.first().json;
function parseAIOutput(output) {
  let jsonString;
  if (typeof output === 'object' && output !== null) {
    return output;
  }
  if (typeof output === 'string') {
    jsonString = output
      .replace(/```json\n?/gi, '')
      .replace(/```\n?/g, '')
      .trim();
    const jsonMatch = jsonString.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      jsonString = jsonMatch[0];
    }
    return JSON.parse(jsonString);
  }
  throw new Error('Invalid output format');
}
// Helper function to remove only the + symbol(keep country code)
function removeOnlyPlus(phone) {
  if (!phone) return null;
  return phone.toString().replace(/^\+/, '');
}
// Helper function to ensure phone has + prefix
function ensurePlus(phone) {
  if (!phone) return null;
  phone = phone.toString();
  return phone.startsWith('+') ? phone : '+' + phone;
}
// Parse output
let result;
try {
  result = parseAIOutput(input.output || input.text || input);
} catch (error) {
  // Fallback with safe defaults
  result = {
    phone_number: null,
    date: null,
    time: null,
    message_body: null,
    message_type: null,
    group_id: null,
    message_id: null,
    moderation: {
      violation_detected: false,
      severity: 'none',
      violation_type: 'none',
      confidence: 0,
      reason: 'Parsing error: ' + error.message,
      recommended_action: 'none',
      keywords_detected: [],
      requires_human_review: true,
      context_notes: 'AI output parsing failed, manual review required'
    }
  };
}
// Get current timestamp
const now = new Date();
const currentDate = now.toISOString().split('T')[0]; // YYYY-MM-DD
const currentTime = now.toISOString().split('T')[1].split('.')[0]; // HH:mm:ss
// Validate and structure final output
// Usage:
// - Base de datos / lógica: usa phone_number → 34665104840
// - Menciones WhatsApp / Google Sheets: usa phone_number_with_plus → +34665104840
return {
  json: {
    // Data fields
    phone_number: removeOnlyPlus(result.phone_number), // Without +: 34665104840
    phone_number_with_plus: ensurePlus(result.phone_number), // With +: +34665104840
    date: result.date || currentDate, // Use AI result or current date
    time: result.time || currentTime, // Use AI result or current time
    message_body: result.message_body,
    message_type: result.message_type,
    group_id: result.group_id,
    message_id: result.message_id,
    // Moderation fields(flattened for easier use)
    violation_detected: result.moderation?.violation_detected || false,
    severity: result.moderation?.severity || 'none',
    violation_type: result.moderation?.violation_type || 'none',
    confidence: result.moderation?.confidence || 0,
    reason: result.moderation?.reason || '',
    recommended_action: result.moderation?.recommended_action || 'none',
    keywords_detected: result.moderation?.keywords_detected?.join(', ') || '',
    requires_human_review: result.moderation?.requires_human_review || false,
    context_notes: result.moderation?.context_notes || '',
    // Metadata
    processed_at: now.toISOString()
  }
};

Passo 5: Verificação de Violações

Insira outro nó If (rotulado “Need Actions?”) que verifica se uma violação foi detectada. Se $json.violation_detected for false, o fluxo termina aqui. Se true, ele prossegue para o sistema de gestão de strikes.

Passo 6: Busca no Banco de Dados e Gestão de Strikes

Implemente o nó AI Agent Log Data conectado a três ferramentas do Google Sheets:

Check for Group Member: Procura registros de usuário existentes
Update Google Sheets: Atualiza registros de infratores existentes
Create New Row: Adiciona infratores pela primeira vez ao banco de dados

O agente de IA gerencia a lógica de três strikes:

Primeira violação → 1 strike, status: “warned_1”
Segunda violação → 2 strikes, status: “warned_2”
Terceira violação → 3 strikes, status: “removed”

Aqui você encontra a Instrução para o Agente:

Prompt (User Message)

Manage strike record for this violation:
Phone: {{ $('Normalize Data 1').item.json.phone_number }}
Group: {{ $json.group_id }}
Severity: {{ $json.severity }}
Type: {{ $json.violation_type }}
Reason: {{ $json.reason }}
Search user, calculate strikes, update database, and return status.

System Message

You are a strike calculation and database management agent for WhatsApp group moderation.
Your ONLY responsibilities:
1.Search for user in Google Sheets by phone number
2.Calculate strike points based on violation severity
3.Update or create user record in database
You do NOT create warning messages - that's handled by another agent.
═══════════════════════════════════════════════════════════
AVAILABLE TOOLS - USE ALL 3 CORRECTLY
═══════════════════════════════════════════════════════════
You have access to 3 Google Sheets tools:
1."Check for Group Member" - READ operation
Purpose: Search for existing users by phone number
When: ALWAYS use this FIRST to check if user exists
2."Udate Google Sheets" - UPDATE operation
Purpose: Update an EXISTING row
When: Use ONLY if user was FOUND in step 1 {{ $('Normalize Data 1').item.json.phone_number }}
3."Google Sheets" - APPEND operation
Purpose: Create a NEW row
When: Use ONLY if user was NOT FOUND in step 1
⚠️ CRITICAL WORKFLOW:
Step 1: ALWAYS use "Check for Group Member" first
Step 2a: If FOUND → use "Udate Google Sheets(update: sheet)" to UPDATE
Step 2b: If NOT FOUND → use "Create New Row(append: sheet)" to APPEND
═══════════════════════════════════════════════════════════
GOOGLE SHEETS STRUCTURE
═══════════════════════════════════════════════════════════
Columns:
- Group Member: Phone number with + and country code(e.g., 34665104840) - UNIQUE KEY
- Group ID: WhatsApp group ID
- Total Strikes: Integer(0-3+)
- Last violation Date: ISO 8601 timestamp
- Last violation Type: Violation category
- Status: "active" | "warned_1" | "warned_2" | "removed"
═══════════════════════════════════════════════════════════
STRIKE CALCULATION RULES
═══════════════════════════════════════════════════════════
CRITICAL: Always add EXACTLY 1 strike per violation, regardless of severity.
Strike progression:
- 1st violation = 1 strike → status = "warned_1"
- 2nd violation = 2 strikes total → status = "warned_2"
- 3rd violation = 3 strikes total → status = "removed"
═══════════════════════════════════════════════════════════
DETAILED WORKFLOW
═══════════════════════════════════════════════════════════
STEP 1: SEARCH USER(MANDATORY)
Tool: "Check for Group Member"
Action: Search by {{ $('Normalize Data 1').item.json.phone_number }}
Wait for result before proceeding.
STEP 2: EVALUATE RESULT
Case A - User EXISTS(tool returns data):
- Proceed to STEP 3
Case B - User DOES NOT EXIST(tool returns empty/null):
- Proceed to STEP 3
STEP 3: CALCULATE NEW STRIKES
new_total_strikes = previous_strikes + 1
STEP 4: DETERMINE STATUS
if new_total_strikes >= 3:
new_status = "removed"
elif new_total_strikes == 2:
new_status = "warned_2"
elif new_total_strikes == 1:
new_status = "warned_1"
else:
new_status = "active"
STEP 5: WRITE TO DATABASE
If user is registered(user was found):
Use Tool: "Udate Google Sheets"(update: sheet)
Action: Update the existing row with:
- Total Strikes: new_total_strikes
- Last violation Date: current timestamp
- Last violation Type: violation_type
- Status: new_status
If does not exist(user was NOT found):
Use Tool: "Create New Row"(append: sheet)
Action: Create new row with:
- Group Member: phone_number
- Group ID: group_id
- Total Strikes: new_total_strikes
- Last violation Date: current timestamp
- Last violation Type: violation_type
- Status: new_status
The tool will add a new row to the sheet.
═══════════════════════════════════════════════════════════
CRITICAL RULES
═══════════════════════════════════════════════════════════
1.⚠️ ALWAYS use "Check for Group Member" FIRST
2.⚠️ If user EXISTS → use "Udate Google Sheets"(UPDATE)
3.⚠️ If user NOT EXISTS → use "Google Sheets"(APPEND)
4.⚠️ Phone number must have + prefix for matching
5.⚠️ "Group Member" column is the unique identifier
6.⚠️ NEVER use APPEND for existing users
7.⚠️ NEVER use UPDATE for new users
8.⚠️ There should be ONE row per phone number
═══════════════════════════════════════════════════════════
EXAMPLE 1 - NEW USER
═══════════════════════════════════════════════════════════
Input: phone="{{ $('Normalize Data 1').item.json.phone_number }}", group="120363402337148387@g.us", type="offensive"
Step 1: [Tool: Check for Group Member]
Search phone: {{ $('Normalize Data 1').item.json.phone_number }}
Result: NOT FOUND
Step 2: existed_before=false, previous_strikes=0
Step 3: new_total_strikes = 0 + 1 = 1
Step 4: new_status = "warned_1"
Step 5: [Tool: Google Sheets - APPEND operation]
Create new row:
- Group Member: {{ $('Normalize Data 1').item.json.phone_number }}
- Group ID: 120363402337148387@g.us
- Total Strikes: 1
- Status: warned_1
- Last violation Date: 2025-10-06T20:00:00.000Z
- Last violation Type: offensive
Output JSON:
{
"phone_number": "{{ $('Normalize Data 1').item.json.phone_number }}", 
"group_id": "120363402337148387@g.us", 
"existed_before": false, 
"previous_strikes": 0, 
"strikes_added": 1, 
"new_total_strikes": 1, 
"new_status": "warned_1", 
"database_updated": true, 
"database_operation": "APPEND", 
"update_timestamp": "2025-10-06T20:00:00.000Z", 
"violation_severity": "high", 
"violation_type": "offensive"
}
═══════════════════════════════════════════════════════════
EXAMPLE 2 - EXISTING USER(SECOND STRIKE)
═══════════════════════════════════════════════════════════
Input: phone="{{ $('Normalize Data 1').item.json.phone_number }}", type="spam"
Step 1: [Tool: Check for Group Member]
Search phone="{{ $('Normalize Data 1').item.json.phone_number }}"
Result: FOUND
- Total Strikes: 1
- Status: warned_1
Step 2: existed_before=true, previous_strikes=1
Step 3: new_total_strikes = 1 + 1 = 2
Step 4: new_status = "warned_2"
Step 5: [Tool: Udate Google Sheets - UPDATE operation]
Update existing row where Group Member = {{ $('Normalize Data 1').item.json.phone_number }}:
- Total Strikes: 2
- Status: warned_2
- Last violation Date: 2025-10-06T21:00:00.000Z
- Last violation Type: spam
Output JSON:
{
"phone_number": "{{ $('Normalize Data 1').item.json.phone_number }}", 
"group_id": "120363402337148387@g.us", 
"existed_before": true, 
"previous_strikes": 1, 
"strikes_added": 1, 
"new_total_strikes": 2, 
"new_status": "warned_2", 
"database_updated": true, 
"database_operation": "UPDATE", 
"update_timestamp": "2025-10-06T21:00:00.000Z", 
"violation_severity": "medium", 
"violation_type": "spam"
}
═══════════════════════════════════════════════════════════
FINAL CHECKLIST
═══════════════════════════════════════════════════════════
Antes de responder, verifique:
✓ Usou "Check for Group Member" primeiro?
✓ Se encontrado → usou "Udate Google Sheets"(UPDATE)?
✓ Se NÃO encontrado → usou "Google Sheets"(APPEND)?
✓ Número de telefone inclui prefixo +?
✓ Retornou JSON válido com database_operation?
✓ Nunca usou APPEND para usuário existente?
✓ Nunca usou UPDATE para usuário novo?

Don’t forget to add the OpenAI Chat Model and the Simple Memory

Passo 7: Normalização de Dados

Adicione outro nó Code (rotulado “Normalise Data 2”) para analisar a saída do gestor de strikes.

Isto garante a formatação correta dos números de telefone (com e sem prefixo +) e define flags para ações de aviso ou remoção.

Here you can copy the code

// Normalize AI Agent Strike Manager Output
const input = $input.first().json;
function parseAIOutput(output) {
  // If already an object, return it
  if (typeof output === 'object' && output !== null && !output.output) {
    return output;
  }
  // Extract the output field if it exists
  const rawOutput = output.output || output.text || output;
  // If it's already parsed
  if (typeof rawOutput === 'object') {
    return rawOutput;
  }
  // If it's a string, clean and parse
  if (typeof rawOutput === 'string') {
    // Remove markdown code blocks
    let cleaned = rawOutput
      .replace(/```json\n?/gi, '')
      .replace(/```\n?/g, '')
      .trim();
    // Try to extract JSON object
    const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      cleaned = jsonMatch[0];
    }
    // Parse the JSON
    try {
      return JSON.parse(cleaned);
    } catch (e) {
      throw new Error('Failed to parse JSON: ' + e.message);
    }
  }
  throw new Error('Unexpected output format');
}
// Helper function to remove only the + symbol(keep country code)
function removeOnlyPlus(phone) {
  if (!phone) return null;
  // Only remove the + symbol, keep everything else including country code
  return phone.toString().replace(/^\+/, '');
}
// Parse the output
let result;
try {
  result = parseAIOutput(input);
} catch (error) {
  // Fallback with safe defaults
  console.error('Parsing error:', error.message);
  result = {
    phone_number: null,
    group_id: null,
    existed_before: false,
    previous_strikes: 0,
    strikes_added: 0,
    new_total_strikes: 0,
    new_status: 'error',
    database_updated: false,
    update_timestamp: new Date().toISOString(),
    violation_severity: 'unknown',
    violation_type: 'unknown',
    error: error.message
  };
}
// Validate required fields
const requiredFields = [
  'phone_number',
  'group_id',
  'new_total_strikes',
  'new_status'
];
for (const field of requiredFields) {
  if (!(field in result) || result[field] === undefined) {
    console.warn(`Missing required field: ${field}`);
    result[field] = null;
  }
}
// Return normalized structure
// Usage:
// - Base de datos / lógica: usa phone_number → 34612345678
// - Menciones WhatsApp: usa phone_number_with_plus → +34612345678
return {
  json: {
    // User identification
    phone_number: removeOnlyPlus(result.phone_number), // Without + but with country code: 34612345678
    phone_number_with_plus: result.phone_number, // Original with +: +34612345678
    group_id: result.group_id,
    // Strike information
    existed_before: result.existed_before || false,
    previous_strikes: result.previous_strikes || 0,
    strikes_added: result.strikes_added || 0,
    new_total_strikes: result.new_total_strikes || 0,
    // Status
    new_status: result.new_status,
    database_updated: result.database_updated || false,
    database_operation: result.database_operation || 'UNKNOWN',
    // Metadata
    update_timestamp: result.update_timestamp || new Date().toISOString(),
    violation_severity: result.violation_severity,
    violation_type: result.violation_type,
    // Computed flags for next steps
    should_warn: result.new_total_strikes > 0,
    should_remove:
      result.new_status === 'removed' || result.new_total_strikes >= 3,
    is_first_offense: !result.existed_before && result.new_total_strikes > 0,
    // Error handling
    parsing_successful: !result.error,
    error: result.error || null
  }
};

Passo 8: Geração Automática de Mensagem de Advertência

Configure o nó AI Agent Create Message para gerar mensagens de advertência contextuais no idioma de sua preferência. As mensagens se adaptam com base no número de strikes:

Strike 1: Tom educativo com lembrete das diretrizes da comunidade
Strike 2: Aviso firme sobre possível remoção
Strike 3: Aviso final antes da remoção automática

Aqui você encontra a Instrução para o último Agente:

Prompt (User Message)

Create warning message for:
Phone: {{ $json.phone_number }}
Status: {{ $json.new_status }}
Total Strikes: {{ $json.new_total_strikes }}
Violation Type: {{ $json.violation_type }}
Severity: {{ $json.violation_severity }}
Generate appropriate warning message.

System Message

You are a warning message creation specialist for WhatsApp group moderation.

Your responsibility: Generate warning messages based on user strike status.

═══════════════════════════════════════════════════════════ TEMPLATES DE MENSAGEM POR NÍVEL DE STRIKE ═══════════════════════════════════════════════════════════

STRIKE 1 (status warned_1 - Tom educativo): ⚠️ @{phone_number} Sua mensagem foi removida por violar as regras do grupo.

📋 Motivo: {violation_reason} ⚡ Strike atual: 1/3

Este é seu primeiro aviso. Por favor, mantenha um ambiente respeitoso e profissional. Revise as regras do grupo para evitar futuras infrações.

Infrações repetidas resultarão na expulsão do grupo.

---

STRIKE 2 (status warned_2 - Aviso firme): ⚠️ @{phone_number} SEGUNDA ADVERTÊNCIA - Sua mensagem foi removida.

📋 Motivo: {violation_reason} ⚡ Strikes acumulados: 2/3

Esta é sua segunda infração. Uma violação a mais resultará em sua expulsão imediata do grupo. Por favor, leia e respeite as normas da comunidade.

---

STRIKE 3+ (status removed - Final, o usuário será expulso): 🛑 @{phone_number} EXPULSÃO IMEDIATA

📋 Motivo da expulsão: {violation_reason} ⚡ Strikes acumulados: {total_strikes}/3

Você alcançou o limite de infrações. Você será removido do grupo imediatamente por violações reiteradas das normas comunitárias.

Esta decisão é definitiva.

---

BAIXA GRAVIDADE (0 strikes adicionados - Lembrete amistoso): ℹ️ @{phone_number} Lembrete amigável:

{violation_reason}

Nenhum strike foi atribuído desta vez, mas pedimos que siga as normas do grupo para manter um ambiente profissional.

═══════════════════════════════════════════════════════════ REGRAS DE FORMATAÇÃO ═══════════════════════════════════════════════════════════

1. SEMPRE comece com @{phone_number} para mencionar o usuário 2. Use emojis de forma apropriada (⚠️ para avisos, 🛑 para remoção, ℹ️ para info) 3. Mantenha as mensagens concisas, mas claras 4. Inclua a contagem de strikes (formato X/3) 5. Declare o motivo claramente 6. Use o tom apropriado com base na gravidade

═══════════════════════════════════════════════════════════ REGRA CRÍTICA DE SAÍDA ═══════════════════════════════════════════════════════════

Você DEVE responder APENAS com o texto da mensagem de advertência. SEM formatação JSON. SEM blocos de código markdown. SEM explicações. SEM texto extra.

Apenas a mensagem simples que será enviada diretamente ao WhatsApp.

Example 1 - Primeiro strike (warned_1): Input: phone="+12345678909", status="warned_1", strikes=1, reason="Lenguaje ofensivo"

Your response: ⚠️ @+12345678909 Tu mensaje ha sido eliminado por violar las normas del grupo.

📋 Motivo: Lenguaje ofensivo ⚡ Strike actual: 1/3

Este es tu primer aviso. Por favor, mantén un ambiente respetuoso y profesional. Revisa las normas del grupo para evitar futuras infracciones.

Las violaciones repetidas resultarán en la expulsión del grupo.

---

Example 2 - Segundo strike (warned_2): Input: phone="+12345678909", status="warned_2", strikes=2, reason="Spam repetitivo"

Your response: ⚠️ @+12345678909 SEGUNDA ADVERTÊNCIA - Tu mensaje ha sido eliminado.

📋 Motivo: Spam repetitivo ⚡ Strikes acumulados: 2/3

Esta es tu segunda infracción. Una violación más resultará en tu expulsión inmediata del grupo. Por favor, lee y respeta las normas de la comunidad.

---

Example 3 - Remoção (status removed): Input: phone="+12345678909", status="removed", strikes=3, reason="Insultos directos"

Your response: 🛑 @+12345678909 EXPULSIÓN INMEDIATA

📋 Motivo de expulsión: Insultos directos ⚡ Strikes acumulados: 3/3

Has alcanzado el límite de infracciones. Serás eliminado del grupo de forma inmediata por violaciones reiteradas de las normas comunitarias.

Esta decisión es definitiva.

Don’t forget to add the OpenAI Chat Model and the Simple Memory

Passo 9: Exclusão da Mensagem

Adicione um nó de ação Wassenger para excluir a mensagem violadora do grupo. Configure-o para revogar a mensagem usando o message ID, garantindo que o conteúdo inapropriado seja removido imediatamente.

Adicione o Nó Wassenger (Delete Message)

Adicione as seguintes expressões para gerir os dados corretos dinamicamente

WhatsApp Number

{{ $(‘Wassenger Trigger’).item.json.device.id }}

Message ID

{{ $(‘Is Group?’).item.json.id }}

Passo 10: Enviar Advertência ao Grupo

Configure outro nó Wassenger para enviar a mensagem de advertência gerada pela IA para o grupo.

Adicione o nó Wassenger (send-messages: sendText)

Este aviso público serve tanto como notificação ao infrator quanto como dissuasão para outros membros.

Adicione as seguintes expressões para gerir os dados corretos dinamicamente

Group ID

{{ $(‘Normalize Data 1’).item.json.group.id }}

Message

{{ $(‘AI Agent Create Message’).item.json.output }}

Passo 11: Remoção Condicional de Membro

Adicione um nó If que verifica se should_remove é true (quando strikes >= 3). Se true, dispara o nó final de ação Wassenger que remove o participante do grupo usando seu número de telefone.

Dentro do nó IF:

Condições

{{ $(‘Normalize Data 2’).item.json.should_remove }} is true

Agora, adicione o Nó Wassenger para excluir o participante se true

Adicione as seguintes expressões para gerir os dados corretos dinamicamente

Group ID

{{ $(‘Normalize Data 1’).item.json.group.id }}

Message

{{ $(‘Wassenger Trigger’).item.json.data.fromNumber }}

Passo 12: Atualizações no Banco de Dados

Os nós do Google Sheets (configurados no Passo 6) atualizam ou criam registros automaticamente com:

Group Member (número de telefone)
Group ID
Total Strikes
Status (active/warned_1/warned_2/removed)
Last Violation Date
Last Violation Type

Opções Avançadas de Personalização

O fluxo adapta-se às suas necessidades específicas:

Personalize categorias de violação e níveis de gravidade
Defina preferências de idioma para mensagens de advertência
Ajuste thresholds de strikes e períodos de timeout
Adicione exceções para administradores ou membros VIP
Crie relatórios de violação e análises

Soluções Rápidas de Troubleshooting

Problemas comuns e soluções:

Entradas duplicadas: Garanta que a IA use UPDATE para usuários existentes, não APPEND
Incompatibilidade de formato de telefone: Remova o símbolo + das entradas do banco de dados
Mensagens não são excluídas: Verifique as permissões do seu dispositivo Wassenger
IA não detecta violações: Refine seus prompts de moderação na system message

🚀 Pronto para Transformar a Gestão dos Seus Grupos do WhatsApp?

Pare de gastar horas moderando grupos do WhatsApp manualmente. Com a poderosa plataforma de automação da Wassenger, você pode construir este moderador de IA e inúmeros outros workflows sem nenhum conhecimento de programação.

💡 Comece sua Jornada de Automação Hoje!

Visite Wassenger e descubra como empresas ao redor do mundo estão revolucionando suas operações no WhatsApp. Com Wassenger Flows, você obtém:

✅ Modelos de workflow pré-construídos
✅ Construtor de automação drag-and-drop
✅ Acesso à API do WhatsApp 24/7
✅ Documentação abrangente
✅ Equipe de suporte especializada

🎯 Tome o Controle dos Seus Grupos do WhatsApp

Registre-se em Wassenger.com hoje e junte-se a milhares de empresas que já automatizam suas operações no WhatsApp. Seja você que gere suporte ao cliente, vendas ou engajamento comunitário, o Wassenger Flows permite construir automações poderosas em minutos, não meses.

🔥 Por que o Wassenger?

Sem necessidade de código: construtor visual de workflows que qualquer pessoa pode usar
Confiabilidade de nível enterprise: construído para empresas que dependem do WhatsApp
Soluções escaláveis: de pequenos grupos a comunidades massivas
Acesso completo à API: controle total sobre suas operações no WhatsApp Business