IA que responde dúvidas no grupo de WhatsApp (só quando chamada)

Uma IA que responde dúvidas em grupo de WhatsApp funciona melhor quando fica quieta: ela recebe todas as mensagens pelo webhook da API não oficial, mas só responde quando alguém a chama — por menção, comando ou uma pergunta que ela sabe responder pela base de conhecimento. A resposta vai citando a pergunta, e o que foge da base vira chamado para um administrador humano. É o oposto do chatbot de atendimento 1:1, e é por isso que precisa de outro desenho.

Grupo de clientes, alunos ou comunidade repete as mesmas perguntas toda semana: "qual o link da aula?", "até quando vai a inscrição?", "onde vejo o boleto?". Os admins respondem cansados, ou a pergunta fica sem resposta. Uma IA bem comportada resolve isso sem virar o membro chato que comenta tudo.

A camada não oficial da WAME é independente e não é afiliada, endossada ou suportada pelo WhatsApp ou pela Meta. O uso é de responsabilidade de quem envia.

Por que grupo é diferente de conversa individual

No privado, toda mensagem é para o bot. No grupo, quase nenhuma é. As pessoas conversam entre si, comentam, mandam figurinha. Uma IA que tenta responder tudo:

• interrompe a conversa entre membros;
• responde o que ninguém perguntou;
• gasta tokens com "kkkk" e "bom dia";
• enche o grupo de mensagens automáticas, o que irrita e gera saídas.

A regra de ouro: a IA é um membro que só fala quando chamado. Bot em grupo é um recurso da camada não oficial — a Cloud API tem suporte a grupos bem mais restrito —, e o bot de comandos em grupo mostra a estrutura básica que vamos estender aqui.

Os três gatilhos

A IA só entra em ação em três casos:

1. Menção ao número do bot ("@Assistente, qual o horário da live?").
2. Comando explícito (!pergunta como emito a segunda via?).
3. Resposta a uma mensagem do bot — a pessoa citou a resposta da IA e perguntou mais. O webhook traz context com o id da mensagem citada.

Pergunta direta sem menção ("alguém sabe o link da aula?") é tentadora, mas é onde a IA mais erra de timing. Se quiser cobrir esse caso, deixe para uma segunda fase, só com alta confiança na base.

const MEU_NUMERO = '5511999990000';
const minhasMensagens = new Set(); // ids que o bot enviou (use Redis com expiração)

function gatilho(msg) {
  const texto = msg.text?.body ?? '';
  if (texto.startsWith('!pergunta')) return texto.replace('!pergunta', '').trim();
  if (texto.includes(`@${MEU_NUMERO}`)) return texto.replaceAll(`@${MEU_NUMERO}`, '').trim();
  if (msg.context?.id && minhasMensagens.has(msg.context.id)) return texto.trim();
  return null;
}

Um detalhe: em grupos que usam LID, a menção no texto aparece como @ seguido do LID do número do bot, não do telefone. Guarde os dois identificadores do bot e teste os dois no gatilho. O que é LID e como resolvê-lo está em LID no WhatsApp.

Receber e filtrar

No webhook meta, a mensagem de grupo traz group_id e from (quem perguntou):

app.post('/webhook/grupos', async (req, res) => {
  res.sendStatus(200); // IA leva segundos; responda o webhook antes

  const msg = req.body?.entry?.[0]?.changes?.[0]?.value?.messages?.[0];
  if (!msg?.group_id || msg.from_me || msg.type !== 'text') return;
  if (!GRUPOS_COM_IA.has(msg.group_id)) return;

  const pergunta = gatilho(msg);
  if (!pergunta) return;

  await tratar({ grupo: msg.group_id, autor: msg.from, id: msg.id, pergunta });
});

Duas guardas importantes: from_me impede a IA de responder a si mesma, e GRUPOS_COM_IA evita que o bot comece a falar num grupo onde ninguém pediu por ele.

A base de conhecimento

IA de grupo não pode improvisar. A resposta precisa sair de um conteúdo seu: FAQ do curso, regras do grupo, datas do calendário, links oficiais. O padrão é RAG — buscar os trechos relevantes a cada pergunta e entregar ao modelo com a instrução de responder só com base neles:

async function responder(pergunta) {
  const trechos = await buscarNaBase(pergunta, { limite: 4 }); // seu índice vetorial

  const prompt = [
    'Você é o assistente do grupo. Responda em até 3 frases, em português,',
    'usando SOMENTE as informações abaixo. Se a resposta não estiver nelas,',
    'responda exatamente: NAO_SEI.',
    '',
    ...trechos.map((t) => `- ${t.texto}`),
    '',
    `Pergunta: ${pergunta}`,
  ].join('\n');

  const r = await modelo.gerar(prompt);
  return { texto: r.texto.trim(), confianca: trechos[0]?.score ?? 0 };
}

O guia completo de montar o índice, dividir os documentos e escolher o modelo está em RAG no WhatsApp.

Responder citando, ou chamar um admin

Em grupo, resposta solta se perde no meio da conversa. Cite sempre a pergunta com POST /{key}/message/{id}/text:

const BASE = 'https://us.api-wa.me/SUA_KEY';

async function citar(msgId, grupo, texto) {
  const r = await fetch(`${BASE}/message/${msgId}/text`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ to: grupo, text: texto }),
  }).then((x) => x.json());
  if (r.id) minhasMensagens.add(r.id); // para reconhecer respostas à IA
}

async function tratar(m) {
  if (!cooldownOk(m.grupo, m.autor)) return;

  const { texto, confianca } = await responder(m.pergunta);

  if (texto === 'NAO_SEI' || confianca < 0.75) {
    await citar(m.id, m.grupo, 'Boa pergunta — vou chamar um admin para te responder.');
    await avisarAdmins(m); // no privado dos admins ou no grupo de moderação
    return;
  }
  await citar(m.id, m.grupo, texto);
}

O limite de confiança (0.75 no exemplo) depende do seu índice; calibre olhando perguntas reais. O princípio não muda: na dúvida, a IA passa a bola. Uma resposta errada no grupo é vista por centenas de pessoas; um "vou chamar um admin" não prejudica ninguém. As regras de quando a IA deve se calar estão em quando a IA deve parar de responder.

Cooldown: a IA não pode virar flood

Dois limites simples mantêm o grupo saudável:

const ultimaPorAutor = new Map();
const ultimaPorGrupo = new Map();

function cooldownOk(grupo, autor) {
  const agora = Date.now();
  if (agora - (ultimaPorAutor.get(autor) ?? 0) < 60_000) return false; // 1 por pessoa/min
  if (agora - (ultimaPorGrupo.get(grupo) ?? 0) < 10_000) return false; // 1 a cada 10s no grupo
  ultimaPorAutor.set(autor, agora);
  ultimaPorGrupo.set(grupo, agora);
  return true;
}

Sem isso, alguém descobre que dá para "brincar" com a IA e o grupo vira um chat com o bot. Os valores são ponto de partida.

O que a IA não deve responder em grupo

Algumas categorias vão direto para humano, mesmo com alta confiança:

• Dados pessoais: boleto, pedido, senha, CPF. Em grupo, nunca. Responda "te chamo no privado" e continue a conversa individual.
• Reclamação e conflito: IA respondendo reclamação em público quase sempre piora.
• Decisão de moderação: remover alguém, julgar regra. Isso é do admin ou do bot de moderação, com regra fixa, não da IA.

Para dúvidas que precisam de dado do cliente, a IA pode abrir a conversa no privado — e ali vale o desenho de chatbot de IA com a OpenAI.

Custos e risco

Como a IA só roda quando chamada, o custo de tokens fica proporcional às perguntas reais, não ao volume do grupo. Um grupo agitado com milhares de mensagens por dia pode gerar só algumas dezenas de chamadas ao modelo. Para estimar, veja quanto custa um agente de IA no WhatsApp.

Do lado do número, o desenho acima é de baixo risco: respostas curtas, espaçadas, só quando pedidas. A WAME envia cada resposta com tempo humano de digitação e avisa no webhook de conexão se o número der sinal de restrição. Um bot que só fala quando chamado se comporta como um membro prestativo — e, para quem usa assim, a taxa de bloqueio é muito baixa.

Conclusão

IA em grupo de WhatsApp dá certo quando ela sabe a hora de ficar calada. Com a API não oficial da WAME, você recebe as mensagens do grupo pelo webhook, aciona a IA só por menção, comando ou resposta a ela, busca a resposta na sua base de conhecimento, responde citando a pergunta e, abaixo do limite de confiança, chama um administrador. Cooldown por pessoa e por grupo evita que o assistente vire ruído. O resultado é um grupo em que as dúvidas repetidas se resolvem sozinhas e os admins ficam para o que só gente resolve. Os endpoints estão na documentação.