Criando um bot com IA para seu WhatsApp com Node.js

Já pensou em equipar seu próprio WhatsApp com um bot super inteligente utilizando de inteligência artificial para responder suas mensagens de forma automática?

Nesse post vou te mostrar como é fácil transformar seu próprio WhatsApp com um bot “powered by OpenAIApi“.

Antes de irmos pro código, apenas um aviso: Usar a API da OpenAI não é grátis. Você irá precisar se inscrever e cadastrar um cartão de crédito (a cobrança é mensal e baseada no uso, portanto não tem um valor fixo).

Para capturarmos eventos do nosso WhatsApp vamos utilizar uma biblioteca chamada “venom-bot”. “venom-bot” é uma biblioteca Node que fornece uma interface programática para interagir com a plataforma do WhatsApp Web. Ele permite que os desenvolvedores criem bots de mensagens automatizadas para o WhatsApp, como enviar e receber mensagens, criar grupos, enviar mídia, entre outras funcionalidades. O “venom-bot” é muito simples de usar e oferece uma ampla gama de recursos para customização.

Vamos ao código e em seguida a explicação:

const venom = require('venom-bot');
const { OpenAIApi, Configuration } = require('openai');

venom
   .create({
      session: 'session-1', //name of session
   })
   .then((client) => start(client))
   .catch((erro) => {
      console.log(erro);
   });

function start(client) {
   const chatGptKey = 'SUA_OPENAI_API_KEY';

   const configuration = new Configuration({
      apiKey: chatGptKey,
   });
   const openai = new OpenAIApi(configuration);

   client.onMessage(async (message) => {
      console.dir(message, { depth: null, colors: true });
      if (message.isGroupMsg === false) {
         const messageBody = message.body;
         try {
            const result = await openai.createChatCompletion({
               model: 'gpt-3.5-turbo',
               messages: [{ role: 'user', content: messageBody }],
            });
            const responseText = result.data.choices.shift().message.content;
            client
               .sendText(message.from, responseText)
               .then((result) => {
                  console.log('Result: ', result); //return object success
               })
               .catch((erro) => {
                  console.error('Error when sending: ', erro); //return object error
               });
         } catch (error) {
            console.log(error);
         }
      }
   });
}

Vamos criar nosso projeto e importar as bibliotecas necessárias:

mkdir whatsapp-bot
cd whatsapp-bot
yarn init -y // ou npm init -y
yarn add venom-bot openai // ou npm install --save venom-bot openai
touch app.js

Começamos importando as bibliotecas “venom-bot” e “openai”no seu arquivo app.js:

const venom = require('venom-bot'); 
const { OpenAIApi, Configuration } = require('openai');

Em seguida inicializamos o “venom-bot”. Passamos para o método “create” o nome da nossa sessão. Esse nome é de sua livre escolha. Em seguida  chamamos o método “start” passando como parâmetro o retorno do método create, no caso “client“:

venom
   .create({
      session: 'session-1', //name of session
   })
   .then((client) => start(client))
   .catch((erro) => {
      console.log(erro);
   });

Na função “start” recebemos o “client” do “venom-bot” como parâmetro. Começamos inicializando as configurações da “OpenAIApi”. Instanciamos a classe “Configuration” passando nossa api-key da “OpenAI” ao construtor. Em seguida instanciamos a classe “OpenAIApi“ e passamos o objeto de configuração anterior ao construtor:

const chatGptKey = 'SUA_OPEN_AI_API_KEY'; //gere sua API KEY no link https://platform.openai.com/account/api-keys
const configuration = new Configuration({
   apiKey: chatGptKey,
});
const openai = new OpenAIApi(configuration);

Em seguida, nosso cliente do “venom-bot” começa a escutar os eventos do nosso WhatsApp em “client.OnMessage()“. Esse é o único evento que vamos usar nesse post, existem muitos outros. O evento “onMessage” é chamado quando uma nova mensagem chega no nosso WhatsApp. A partir dali podemos fazer o que quisermos com ela. Veja que chamamos um “console.dir(message)” para que você possa se familiarizar com a estrutura da resposta e poder utilizar o objeto de retorno como queira. A resposta vem em formato JSON:

client.onMessage(async (message) => {
console.dir(message, { depth: null, colors: true });

A seguir utilizo a chave do objeto “message” chamada “isGroup” para checar se a mensagem veio a partir de um grupo. Se sim, eu ignoro. (Não queremos ficar respondendo automaticamente toda mensagem de grupos, certo?). Se a mensagem não for de um grupo, prossigo:

if (message.isGroupMsg === false) {...)

Capturamos a mensagem em si na chave “body” do objeto “message”. Aqui é onde a mágica acontece. Após capturar a mensagem na variável “messageBody” faço a chamada para a “OpenAiApi” passando “messageBody” como conteúdo. Faço esse “request” para “OpenAIApi” utilizando o objeto “openai” que instanciamos no começo do script. O método se chama “createChatCompletion“. Esse método recebe como parâmetro o modelo do chatGPT que quer utilizar (3.5 ou 4 ou etc). Utilizar o modelo 4, mais avançado é limitado por usuário e mais caro, por isso estou utilizando o 3.5-turbo que serve muito bem ao propósito:

const messageBody = message.body;
const result = await openai.createChatCompletion({
   model: 'gpt-3.5-turbo',
   messages: [{ role: 'user', content: messageBody }],
});

Capturamos o retorno da “OpenAIApi” na constante “responseText“. Veja que estamos pegando apenas a primeira mensagem que é retornada para nós dentro do array “result.data.choices” utilizando a função “shift”. Isso porque é possível você criar um contexto de conversa enviando sempre todas as mensagens em um array e recebendo sempre todas as mensagens do contexto em um array. Aqui para fins didáticos vamos apenas tratar mensagens individualmente. Se você tiver interesse em como criar contextos de conversas deixe um comentário que mostro em outro post.

const responseText = result.data.choices.shift().message.content;

Em seguida pregamos a resposta recebida da “OpenAIApi” salva em “responseText” e reenviamos pelo WhatsApp como resposta ao remetente da mensagem. Veja que o remetente fica salvo em “message.from“. Pra terminar apenas imprimimos o resultado do envio ou o possível erro.

client
   .sendText(message.from, responseText)
   .then((result) => {
       console.log('Result: ', result); //return object success
    }).catch((erro) => {
       console.error('Error when sending: ', erro); //return object error
    });

Logo que iniciar esse script com node app.js você verá no terminal um “qrcode“. Você deve abrir o seu WhatsApp no seu cel e escanear o código para criar uma nova sessão web do WhatsApp. A partir daí o script começa a ouvir os eventos.

Veja que esse é um script bem simples apenas para fins didáticos, tendo margem para muita otimização. E também é uma versão bem básica do que pode-se utilizar da biblioteca “venom-bot” e da “OpenAiApi”. Existem muitos mais recursos a sua disposição, permitindo uma gama enorme de customização do seu bot, o céu o limite. Encorajo após rodar esse script simplificado explorar mais opções nas documentações do “venom-bot” e da “OpenAiApi.” Observe também que você pode utilizar o “venom-bot” independente da “OpenAIApi”. Crie sua própria inteligência com respostas customizadas para diferentes contextos no WhatsApp.

Espero que tenha gostado e se divirta como esse script. Só fique de olho na utilização da “OpenAIApi” pois é cobrado por uso. Apenas alguns poucos usos por dia acabam até saindo de graça ou custando centavos. Você pode inclusive incluir um limitador de gasto mensal na sua subscrição da “OpenAIApi” para não ter surpresas na fatura do cartão de crédito.

Até a próxima e happy coding!