DEV Community: ogoh cyril

Supercharge Your System Development: Leveraging Pre-Trained LLM APIs for Faster and More Efficient Building

ogoh cyril — Wed, 15 May 2024 03:08:51 +0000

Large Language Models, like those developed by OpenAI, have become invaluable tools for companies looking to innovate and grow in today's competitive landscape.

Discover how companies are revolutionizing their workflows by leveraging the power of OpenAI And Facebook LLM.

By utilizing pre-trained LLM models and APIs, companies can avoid the significant time and resources required to develop and train their own AI models from scratch. This cost-effective approach lowers barriers to entry, particularly for smaller companies with limited budgets, and allows them to compete on a level playing field with larger competitors.

Goals

In this article, I will guide you through the process of constructing a comprehensive system that demonstrates how to utilize and integrate LLM (Large Language Models) effectively. We'll cover:

Consuming OpenAI Docs: We'll start by exploring how to consume OpenAI documentation to create a simple JavaScript code snippet. This will serve as a foundational step in understanding how to interact with OpenAI's APIs and leverage LLM's capabilities.
Building an Express Backend: Next, we'll delve into building an Express backend application and integrating AI functionalities into it. This will involve setting up routes, handling requests, and incorporating LLM to perform specific tasks or provide intelligent responses.
Adding AI to a Client-side Application: Finally, we'll demonstrate how to seamlessly integrate the AI-powered backend into a client-side application. Whether it's a web-based interface, a mobile app, or another type of frontend, we'll show you how to incorporate LLM-powered features to enhance user experiences.

Throughout the article, we'll provide practical examples, code snippets, and step-by-step instructions to help you understand and implement each component effectively. By the end, you'll have a clear understanding of how to consume, build, and integrate LLM into your existing systems, opening up new possibilities for innovation and efficiency.

Consuming OpenAI Docs
Building an Express Backend
Adding AI to a Client-side Application

Consuming OpenAI Docs

Jumping straight into it, here's what you'll need:

A trusty PC (obviously!)
An account on the OpenAI Platform
Generate an API key from your OpenAPI account, which we'll use to authenticate our requests.
Node.js installed on your machine (although you can also run it directly from your browser's terminal)
An IDE for coding - I personally recommend Visual Studio Code (VSCode)

With these essentials in place, you're all set to embark on your journey of integrating LLM into your projects. Let's dive in!

Creating An Account On OpenAI Platform And Getting An API-KEY

Head over to the OpenAI website (https://platform.openai.com/) using your preferred web browser and create an Account.

Once logged in, navigate to your account settings or dashboard to access your API settings. This is where you'll be able to generate your API key.

Locate the option to generate an API key and follow the prompts to generate one. Your API key is a unique identifier that allows you to access OpenAI's APIs and services.

Once generated, make sure to keep your API key secure. Treat it like a password and avoid sharing it publicly or with unauthorized individuals.

I won't discuss setting up Node and VSCode here, but you can refer to this article for guidance:
Installing npm and Node.js on Windows and Mac

Now that we have almost all our Infinity Stones, let's get to the fun part - building!

Coding And Testing

we would first initiate a nodejs project using npm init -y and also install Open Ai Javascript library npm install openai

and create a file called index.js and build our function

//index.js

//importing Open AI Lib And Core Functions
const OpenAI = require("openai");

const configuration = {
   apiKey: "REPLACE WITH SECRET KEY"
};

const openai = new OpenAI(configuration);

// Defining a conversation message with roles and content
let message = [
  {
    role: "system",
    content: "You Are A Banker, Be A very Rude One",
  },
  {
    role: "user",
    content: "do I have money in my account ?",
  },
];

async function getChatResponse() {
  try {
    // Making an asynchronous call to create a chat completion
    const response = await openai.chat.completions.create({
      model: "gpt-3.5-turbo-16k-0613",
      messages: message,
      temperature: 1,
      max_tokens: 256,
      top_p: 1,
      frequency_penalty: 0,
      presence_penalty: 0,
    });

    // Logging the response from OpenAI to the console
    console.log(response.choices[0].message.content.toString());
  } catch (error) {
    // Handling errors if any occur during the API call
    console.error("Error occurred:", error);
  }
}

// Calling the function to get the chat response
getChatResponse();

run node index.js in your console

You should see a response or output like this

Well, if you bothered to check your account balance before asking such a stupid question, you would already know if you have any money. But of course, why take the effort to be responsible when you can just ask me, right? in the console.

If you experience any errors, they are likely due to billing issues. Create a brand new account and test again. Otherwise, well done on consuming the OpenAI API!
View Github For The Code

Offical Docs

Building an Express Backend

While consuming OpenAI's documentation provides valuable insights into leveraging AI models, it's only the first step towards unlocking their full potential. Building an Express backend acts as the bridge that connects these powerful AI capabilities with real-world applications. This intermediary layer not only facilitates seamless communication with OpenAI's services but also enables efficient data processing, authentication, and scalability. In this section, we delve into the pivotal role of tying a backend with OpenAI, exploring how it empowers developers to create dynamic and intelligent applications that deliver transformative experiences to end-users.

What Our Backend Should Be Able to Do

Authentication: Implementing user authentication to track and manage users' interactions securely.
Storage of Messages: Storing user messages and interactions for data analysis and model training.
Sending of Messages: Facilitating the exchange of messages between users and the OpenAI model to generate responses effectively.

In this system, we aim for a user/actor to connect to the backend using a client of choice and send a prompt. This prompt would then be received, processed, stored, and finally passed to a third party, such as OpenAI. Subsequently, the system would receive a response from OpenAI, store and provide it back to the user/actor

More Codes

we would first initiate a Node project using npm init -y and also install Open Ai Javascript library npm install openai, ExpressJs npm install express cookie-parser cors and mongoose A MongoDB ORM npm install mongoose

setting up express

//index.js
var express = require('express');
var cookieParser = require('cookie-parser');
const cors = require('cors')
var http = require('http');

const app = express();
// enabling CORS
app.use(cors({
  origin: '*'
}));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cookieParser());

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  res.status(404).json({
    success: false,
    status: "Resource Not Found",
    error: "404 Content Do Not Exist Or Has Been Deleted",
  });
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});
var server = http.createServer(app);
/**
 * Listen on provided port, on all network interfaces.
 */
const port = 3000
server.listen(port);
server.on('listening', onListening);
function onListening() {
    var addr = server.address();
    var bind = typeof addr === 'string'
      ? 'pipe ' + addr
      : 'port ' + addr.port;
    console.log('Listening on ' + bind);
  }

module.exports = app;

We need to incorporate a database into our system, and for that, we'll use Mongoose.

To set up MongoDB on your machine, follow these steps:

Download MongoDB: Visit the MongoDB website and download the appropriate version for your operating system.

Install MongoDB: Follow the installation instructions provided for your operating system to install MongoDB on your machine.

Set Up MongoDB: After installation, set up MongoDB by following the configuration steps recommended in the MongoDB documentation.

Start MongoDB: Once configured, start the MongoDB service on your machine. You may need to start it manually or configure it to start automatically on system boot, depending on your operating system.

With MongoDB installed and running, we can proceed to integrate it into our backend using Mongoose for seamless data management.

const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost:27017/llm_api");
// schema

const user = mongoose.model("user", {
  email: {
    type: String,
    required: [true, "Please enter your Email address"],
    trim: true,
    unique: true,
    lowercase: true,
    match: [
      /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
      "Please enter a valid Email address",
    ],
  },
  password: {
    type: String,
    required: true,
  },

  name: {
    type: String,
    required: true,
  },
});

// Message table or document
const message = mongoose.model("message", {
  user: {
    type: mongoose.SchemaTypes.ObjectId,
    required: true,
    ref: "user",
  },
  body: {
    type: String,
    required: [true, "Body is Required "],
  },
  fromChat: {
    type: Boolean,
    default: false,
    required: [true, ""],
  },
  type: {
    type: String,
    required: [true, "please a type of message is required"],
    enum: {
      values: ["text", "csv"],
      message: 'Please use a valide Data Type ["text", "csv"]',
    },
  },
});

Building the authentication functions

/**
 * @description Post For Users To Login Using `JWT`
 * @route `/login`
 * @access Public
 * @type Post
 */
app.post("/login", async (req, res, next) => {
  const { email, password } = req.body;

  if (!email || !password) {
    return res.status(400).json("Please provide an email and password", 400);
  }

  const data = await user
    .findOne({ email: email.toLowerCase() })
    .select("+password");

  if (!data) {
    return res.status(400).json("Invalid credentials", 401);
  }

  const isMatch = data.password == password;

  if (!isMatch) {
    return res.status(400).json("Invalid credentials", 401);
  } else {
    res.status(201).cookie("token", data._id.toString(), options).json({
      success: true,
      status: "success",
      data,
    });
  }
});

/**
 * @description Post For Users To Login Using `JWT`
 * @route `/login`
 * @access Public
 * @type Post
 */
app.post("/register", async (req, res, next) => {
  const { name, email, password } = req.body;
  const isUser = await user.findOne({ email: email.toLowerCase() });
  if (isUser) {
    return res.send(`${email} is Assigned to a user sign in instead`);
  }
  const newUser = await user.create({
    name,
    email,
    password,
  });

  res.status(201).cookie("token", newUser._id.toString(), options).json({
    success: true,
    status: "success",
    data: newUser,
  });
});

Our complete code setup should resemble the following:

var express = require("express");
var cookieParser = require("cookie-parser");
const cors = require("cors");
var http = require("http");

const app = express();
const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost:27017/llm_api");
// user table or document
const user = mongoose.model("user", {
  email: {
    type: String,
    required: [true, "Please enter your Email address"],
    trim: true,
    unique: true,
    lowercase: true,
    match: [
      /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
      "Please enter a valid Email address",
    ],
  },
  password: {
    type: String,
    required: true,
  },

  name: {
    type: String,
    required: true,
  },
});

// Message table or document
const message = mongoose.model("message", {
  user: {
    type: mongoose.SchemaTypes.ObjectId,
    required: true,
    ref: "user",
  },
  body: {
    type: String,
    required: [true, "Body is Required "],
  },
  fromChat: {
    type: Boolean,
    default: false,
    required: [true, ""],
  },
  type: {
    type: String,
    required: [true, "please a type of message is required"],
    enum: {
      values: ["text", "csv"],
      message: 'Please use a valide Data Type ["text", "csv"]',
    },
  },
});

// enabling CORS
app.use(
  cors({
    origin: "*",
  })
);
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cookieParser());

const options = {
  expires: new Date(Date.now() + 10 * 24 * 60 * 60 * 1000),
  httpOnly: true,
};


const protected = (req, res, next) => {
    let token;
    if (req.cookies.token) {
      token = req.cookies.token;
    }
    if (!token) {
      return res.status(401).json({
        success: false,
        status: "Not Authorized",
        error: "401 Invalid Authorization",
      });
    }
    req.user = {
      _id: token,
    };
    next();
  };

/**
 * @description Post For Users To Login Using `JWT`
 * @route `/login`
 * @access Public
 * @type Post
 */
app.post("/login", async (req, res, next) => {
  const { email, password } = req.body;

  if (!email || !password) {
    return res.status(400).json("Please provide an email and password", 400);
  }

  const data = await user
    .findOne({ email: email.toLowerCase() })
    .select("+password");

  if (!data) {
    return res.status(400).json("Invalid credentials", 401);
  }

  const isMatch = data.password == password;

  if (!isMatch) {
    return res.status(400).json("Invalid credentials", 401);
  } else {
    res.status(201).cookie("token", data._id.toString(), options).json({
      success: true,
      status: "success",
      data,
    });
  }
});

/**
 * @description Post For Users To Login Using `JWT`
 * @route `/login`
 * @access Public
 * @type Post
 */
app.post("/register", async (req, res, next) => {
  const { name, email, password } = req.body;
  const isUser = await user.findOne({ email: email.toLowerCase() });
  if (isUser) {
    return res.send(`${email} is Assigned to a user sign in instead`);
  }
  const newUser = await user.create({
    name,
    email,
    password,
  });

  res.status(201).cookie("token", newUser._id.toString(), options).json({
    success: true,
    status: "success",
    data: newUser,
  });
});

app.get("/messages", protected, async (req, res, next) => {
  const myMessage = await message.find({ user: req.user._id }).sort({
    _id: -1,
  });
  res.status(200).json({
    success: true,
    status: " success",
    prompt: myMessage,
  });
});

//importing Open AI Lib And Core Functions
const OpenAI = require("openai");

const configuration = {
    apiKey: "REPLACE WITH SECRET KEY"
};

const openai = new OpenAI(configuration);

const resFromChat = async (messages, user) => {
    const allMessages = await message.find({ user: user }).sort({ _id: 1 });

    let data = [];
    let chat;
    for (let i = 0; i < allMessages.length; i++) {
      const e = allMessages[i];

      if (!e.fromChat) {
        chat = {
          role: "user",
          content: e.body,
        };
      }
      if (e.fromChat) {
        chat = {
          role: "assistant",
          content: e.body,
        };
      }
      data.push(chat);
    }

    let upload = [
      {
        role: "system",
        content:
          "You Are A Banker, Be A very Rude One",
      },
    ];
    upload = upload.concat(data);
    try {
      const response =await openai.chat.completions.create({
        model: "gpt-3.5-turbo-16k-0613",
        messages: upload,
        temperature: 1,
        max_tokens: 256,
        top_p: 1,
        frequency_penalty: 0,
        presence_penalty: 0,
      });

      const data = {
        user,
        body: response.choices[0].message.content.toString(),
        type: "text",
        fromChat: true,
      };

      await message.create(data);
      return data;
    } catch (error) {
      const data = {
        user,
        body: "Error From Server Please Try Again",
        type: "text",
        fromChat: true,
      };

      await message.create(data);
      return data;
    }
  };

/**
 * @description Send new Prompt
 * @route `/messages`
 * @access Public
 * @type POST
 */
app.post("/messages", protected, async (req, res, next) => {
    const { body, type } = req.body;
    const newMgs = await message.create({
      body,
      type,
      user:req.user._id,
      fromChat:false
    });

    const data =  await resFromChat(body,req.user._id);
    res.status(200).json({
      success: true,
      status: " success",
      prompt: data,
    });
  });


// catch 404 and forward to error handler
app.use(function (req, res, next) {
  res.status(404).json({
    success: false,
    status: "Resource Not Found",
    error: "404 Content Do Not Exist Or Has Been Deleted",
  });
});

// error handler
app.use(function (err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get("env") === "development" ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render("error");
});
var server = http.createServer(app);
/**
 * Listen on provided port, on all network interfaces.
 */
const port = 3000;
server.listen(port);
server.on("listening", onListening);
function onListening() {
  var addr = server.address();
  var bind = typeof addr === "string" ? "pipe " + addr : "port " + addr.port;
  console.log("Listening on " + bind);
}

module.exports = app;

To run the code, execute node index in your terminal. You can then use Postman as an initial client to interact with the server by sending requests to the endpoints

view the full code on github

Adding AI to a Client-side Application

In this final section, we'll augment our LLM Agent with a simple web interface to showcase its functionality in a user-friendly manner. We'll implement both login and registration forms to facilitate user authentication, and we'll design a chat graphical user interface (GUI) for interacting with our LLM Agent.

It's important to note that all endpoints are accessed using native JavaScript fetch requests without relying on any additional frameworks. Furthermore, authentication is cookie-based, making it a lightweight and straightforward solution for our project.

Let's explore the sample code used to bring this web interface to life.

This Handles the Auth

      // Function to check if token exists in cookies
      function checkToken() {
        const token = document.cookie
          .split(";")
          .find((cookie) => cookie.trim().startsWith("token="));
        return token ? true : false;
      }

      // Redirect to login page if token doesn't exist
      if (!checkToken()) {
        window.location.href = "./login.html";
      }

This Fetch And Return The message Arranged


      // Fetch messages from an endpoint
      async function fetchMessages() {
        try {
          const response = await fetch("/messages");
          const data = await response.json();

          return data.prompt; // Assuming the API response contains an array of messages
        } catch (error) {
          console.error("Error fetching messages:", error);
          return []; // Return an empty array if an error occurs
        }
      }

      // Function to display messages in the chat box
      async function displayMessages() {
        const messages = await fetchMessages();
        chatBox.innerHTML = ""; // Clear previous messages
        messages.reverse().forEach((message) => {
          const messageElement = document.createElement("div");
          messageElement.textContent = message.body;
          messageElement.classList.add("message");
          if (!message.fromChat) {
            messageElement.classList.add("sender");
          } else {
            messageElement.classList.add("receiver");
          }
          chatBox.appendChild(messageElement);
        });
        // Scroll to bottom of chat box
        chatBox.scrollTop = chatBox.scrollHeight;
      }

      // Call displayMessages function initially to display existing messages
      displayMessages();

      // Event listener for message form submission
      messageForm.addEventListener("submit", async function (event) {
        event.preventDefault(); // Prevent default form submission behavior

        const newMessage = {
          sender: "user", // Assuming the user is sending the message
          body: messageInput.value,
        };

        // Add new message to messages array
        // Here, you can also send the new message to the backend if neede

        // Call displayMessages to update chat box with new message
        await displayMessages();

        // Clear message input field
        messageInput.value = "";

        const response = await fetch("/messages", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({ type: "text", body: newMessage.body }),
        });
        if (response.ok) {
          await displayMessages();
        }
      });

view the full code on github

Conclusion

Throughout this article, I've provided insights into constructing a comprehensive system to effectively utilize and integrate LLMs into existing workflows. From consuming OpenAI documentation to building an Express backend and integrating AI features into client-side applications, we've outlined practical steps accompanied by code snippets and examples.

As demonstrated, the possibilities are limitless when it comes to leveraging LLMs. Whether it's automating customer support, generating creative content, or powering intelligent assistants, the transformative potential of LLMs is reshaping how businesses operate and engage with their audiences.

Shoutout Veritas 300lvl
Signing out by 4 AM

Using ChatGPT to reply my Whatsapp ?

ogoh cyril — Tue, 28 Feb 2023 01:51:26 +0000

With the advent of artificial intelligence (AI) and natural language processing (NLP), communication has become more seamless than ever before. One such development in this field is the creation of large language models, such as ChatGPT, which can be used to reply to WhatsApp messages. In this article, we will discuss how ChatGPT can be used to reply to WhatsApp messages and the benefits of doing so.

WHAT IS CHATGPT ?
ChatGPT is a state-of-the-art language model developed by OpenAI that has been trained on a large corpus of text data. It is capable of understanding natural language and can generate responses that are coherent and relevant to the conversation.

To use ChatGPT to reply to WhatsApp messages, you will need to integrate it with a messaging app.

There are different ways to integrate ChatGPT with WhatsApp, but one common method is to use a chatbot platform like Twilio or Dialogflow.
These platforms allow you to create a bot that can receive messages from WhatsApp and respond to them using ChatGPT, But neither are free and allow 100% customisation.

BUILDING THE BOT
We are gonna be using Venom to handle the request form Whatsapp, Shout out to the team of maintainer keeping this project alive and free for anyone to use.

To create a bot, you will need to follow these steps:

Sign up to OpenAI.
Install Venom-bot on your pc npm i venom-bot
Integrate ChatGPT with the bot by using its API.
Connect the bot to WhatsApp and reply using incoming messages as it prompt.

Step 1

Get your private key from your private setting here

Step 2

Create a dir and install venom-bot and openai packages

$~ mkdir my-bot && cd my-bot $~ npm init -y $~ npm i venom-bot openai dotenv

Once the installation is completed we open our IDE and
create a file to help get the response from chatGPT



// File name chatGPT.js
const { Configuration, OpenAIApi } = require("openai");
require('dotenv').config()


const configuration = new Configuration({
  apiKey: process.env.CHAT_GPT_KEY,
});
const openai = new OpenAIApi(configuration);




 exports.response = async (prompt) =>{
  return await openai.createCompletion({
        model: "text-davinci-003",
        prompt: prompt,
        temperature: 0.5,
        max_tokens: 60,
        top_p: 1,
        frequency_penalty: 0.5,
        presence_penalty: 0.28,
        stop: ["You:"],
      })
    }

Now any call to response () return a string response from chatgpt

Then Our main file which contain the Whatsapp bot and the integration



//main.js
const venom = require('venom-bot');
const { response } = require("./chatgpt");

venom
  .create({
    session: 'session-name', //name of session
    multidevice: true // for version not multidevice use false.(default: true)
  })
  .then((client) => start(client))
  .catch((erro) => {
    console.log(erro);
  });

function start(client) {
  client.onMessage((message) => {
// This ignore messages from group and story 
    if (message.body && message.isGroupMsg === false && message.from !== 'status@broadcast') {
        response(message.body).then(data => {
            console.log(data.data.choices[0]);
            client
            .sendText(message.from, data.data.choices[0].text)
            .then((result) => {
              console.log('Result: ', result); //return object success
            })
            .catch((erro) => {
              console.error('Error when sending: ', erro); //return object error
            });
          }).catch(err =>{
            console.log(err);
          })
    }
  });
}

Once you have set up the bot run,



$~ node main

it will be able to reply to WhatsApp messages using ChatGPT. The bot can be customized to respond to specific types of messages or questions, depending on your needs.

Screenshot Of the Bot Replies

Not Sure I could rizz someone as chatGPT does

I was laughing when I saw this

Using ChatGPT to reply to WhatsApp messages has several benefits. Firstly, it can save time and effort by automating responses to common questions or inquiries. This can be particularly useful for businesses that receive a large number of messages from customers or clients. Secondly, it can improve the quality of responses by generating coherent and relevant replies that are tailored to the context of the conversation. Finally, it can provide a more seamless and interactive experience for users by allowing them to receive instant responses without the need for human intervention.

In conclusion, ChatGPT can be a powerful tool for replying to WhatsApp messages. By integrating it with a chatbot platform, you can create a bot that can understand natural language and generate responses that are coherent and relevant to the conversation. This can save time, improve the quality of responses, and provide a more seamless and interactive experience for users.

The EndGame - Fakerjs

ogoh cyril — Sat, 08 Jan 2022 20:53:22 +0000

About Four (4) Days Ago, the Author of Fakerjs a popular JavaScript library with more than 2 million weekly Download from NPM Deleted the repository and replaced it with one that only has the modified ReadMe "What really happened with Aaron Swartz?" and no content, and pushed an empty package to npm as the latest version (6.6.6).

The name of the new commit is called ENDGAME

Why I Think He Did It

Marak develops this very useful tool and gives it away for free, receives praise but no money. After realising that there is no money in giving stuff for free with no further plan down the road, gets cranky as others are not giving Marak free services and don't accept applause as a payment method,And says that someone needs to pay for it or take over the development. Declares that will no longer do free work for corporations, but corporations seems to be unimpressed that the free worker will no longer work.

Since no one seems to be interested to pay for work offered for free, Marak launches SaaS of the tool as fakercloud.com (Now offline due to hosting renewal), which is a popular strategy and sometime can actually work.

Unfortunately, according to Marak, engineers from Retool copy the SaaS platform and launch it as a part of Retool. Marak realising what has happened offers the CEO of Retool to sell the fakercloud.com to them. The CEO ghosts Marak, maybe because doesn't want give evidence for a lawsuit or maybe doesn't see the point of purchasing a product that the internal engineers already build.

He Wrote A blog Post About it
you can read it here since his blog is down
https://web.archive.org/web/20210516172305/https://marak.com/blog/2021-04-25-monetizing-open-source-is-problematic

As a result, Marak gets angry and deletes everything and posts conspiracy theory memes and links everywhere. As this tool is a popular one and people depend on it, NPM suspends Marak's account and continues to provide latest working version that Marak gave them for free.

What Impact Does This Have To The Opensource ?

How I Built A Whatsapp Bot For Free (No third-party service)

ogoh cyril — Sun, 13 Jun 2021 00:44:25 +0000

I've always wanted to build or have my own WHATSAPP BOT, to reply my messages as I've never being one to read and reply chats and also send scheduled and automated messages sure as birthday wishes (is kind of a big deal over here)

I hate Chatting

So i start by building a uni-gram Pattern Bot in node and fed it some data, it was super dumb at first but the more data i fed it, the more manageable it was getting

Now What was left was to integrate it with Whatsapp

So I jumped to Twilio WhatsApp Business API 😎😎 and the cost was fair $0.0042 to send a WhatsApp Template message and $0.005 for WhatsApp Session messages; BUT sadly that much 💔💔 for me as a student in a third world country with high exchange rate, I couldn't waste that amount for the Restriction Twilio was giving and I wanted it to come from a regular account(i figured much later).

So I hopped to google and searched for 'Free Whatsapp bot', cause I wasn't gonna build one from scratch; Like I have the skills for that or the time to maintain it😅😅😅💔.

All I could find were third-party Service Provider and not what i anticipated, then something hit me and i went to GitHub to find an open source freeware

And I Met VENOM

VENOM
love at first sight
The documentation was straight forward and it got the right amount of stars and maintainers
so I $~ npm install venom-bot and started coding.

when i started with the demo script from their readme file, I noticed the Application was reading all my incoming messages, down to my friends status caption with a Base64-encoded string to represent the image/gif

So I first made a condition to ignore messages coming from the groups am in and I then imported my bot as a module and passed it the messages coming from my friends as a parameter and replied with the return values from my bot

I did all this in less than 10 min for the first time

I got about a few messages and the bot auto responded for me, I let this process go on for about 15 min unsupervised and 4 out of my friends that interacted with it, only 3 figured it was an auto response system.

I just figured out a new toy

I manage a site that sale and answer assignment for university and since i got access to the server I created an endpoint for it and added cors();

I called my route using a package called node-fetch and got my json data.

So I Sorted Or Used The User Phone Number To Query The Database

My Controller File



const siteName = "https://sitename.com/{secretkey}/"

const fetch = require('node-fetch'); 

/**
 * 
 * @param {number} phone 
 * @param {*} id
 */


// get balance
exports.bal = async (phone) =>{
    const dataStream = await fetch(siteName + 'bal/'+ phone);
    const dataJson = await dataStream.json();
    return await dataJson;
}

My Index File



const venom = require('venom-bot');
const controller = require('./function/fetch');

// Starting Venom 
venom.create()
  .then((client) => start(client))
  .catch((erro) =>{
    console.error(erro);
  });



  // To Read All incoming Messages
  const start = async (client)=>{
    client.onMessage((message) =>{
      // converting all the user message to lowercase for easy computing 
      const data = message.body.toLowerCase();
      const caller = data.split(' ');

      // This is to reformat the users number Base on your location 
      const phone = message.from
      var formatednumber = phone.split("@");
       // removing the 234 and adding 0 to the end 
       var count = "0" + formatednumber[0].slice(3)

      // if startment to check messages string and ignore group messages 
      if(message.isGroupMsg === false && caller[0] == 'KeyWord'){
        switch (caller[1]) {
          // send a help meassage listing params 
          case 'help' :
            // to send a message 
            client.sendText(message.from, controller.help())
            .catch((erro) => {
              console.error('Error when sending: ', erro); 
               //return object error
            });
            break;

          // to get user balance in the application  
          case 'balance' :
            const cyril1 = controller.bal(count).then(res => 
              {
                const reply = `Your Account Balance Is *NGN ${res.wallet}* `

                client.sendText(message.from, reply).catch(erro=>{
                  console.log(erro);
                })
               }).catch(error =>{
                 console.log(error)
               })
            break;
          default: 
           controller.invalidRes
           client.sendText(message.from, controller.invalidRes())
           .catch((erro) => {
             console.error('Error when sending: ', erro); //return object error
           });
           client.sendText(message.from, controller.help())
           .catch((erro) => {
             console.error('Error when sending: ', erro); //return object error
           });
            break;
        }
      }
    }).catch
  }

this gave me the ability to handle almost all the macro tasks in my site on Whatsapp

The Code Running On My Terminal

The chat between a user and a bot

I enjoyed my building process and also didn't roll out that feature 😅

Why ?

The venom library runs in a headless version on chrome using
web.whatsapp.com API

So you must have an activate Whatsapp running on your Mobile Device and that's stressful

and running the process consume much CPU memory

So I could deploy my Whatsapp bot the server but the downside my phone must be online too if I need the bot to work

If you want the full code I could make them available on my Git Repo.

I hope You Enjoyed this
It's my first article
And might not be entirely correct I'm totally open to corrections
Thanks

The Dilemma of a Computer Science Student, Grade or Experience?

ogoh cyril — Fri, 03 Jul 2020 14:42:37 +0000

What do I need?
*A first-class result with low programming skills?
*Or a stack of programming experience and completed project then a low or average grade?

So first off, I don’t mean you can’t have high grade and learn a new technology but in my case I can’t.

*Because if you deep into coding you will realise that learning a new framework means countless practices to get familiar with the syntax and the structure and if you get excited in the process of learning and encounter a bug then it a week of sleepless night and bloodshot eyes if you can’t find a solution on Stack-overflow or Google *

But even though that may not your case

Attending lectures and understanding it, and other extra-curricular activity can be a troll, like it requires a lot dedication to get high grade.

And in my university am mostly taught obsolete technology, nothing really current or in trends or framework which I Like or prefer

Am not saying that what am being taught is a total waste but I get this view that this makes me inexperience to the current Job market and other stuff.

He who hesitates is lost …

that the motto I use

So, I mostly keep to trend trying to learn, test and implement new feature
I once tried coding in school and had series of burn-out my grade fell and then I panic. I dismiss the thought of building actual project in school and just sticking with my routine

But
I been thinking and wondering what is best for me that’s why am seeking advice?

Very good grades?
Or
A ton of completed project to show my employer

Am in my second year At Veritas University, Abuja.