Forem: Rutam Prita Mishra

Deploying MindsDB on Linode

Rutam Prita Mishra — Tue, 26 Dec 2023 18:56:42 +0000

Introduction

MindsDB is a state-of-the-art AI layer that integrates with traditional databases and enhances their ability to draw meaningful inferences from the existing data.

With MindsDB, one can easily train models that predict results and forecast outcomes based on available data. It has also several integrations with a wide variety of data sources and LLM models that make it robust and accurate for various user applications.

In this tutorial, you will learn to deploy an instance of MindsDB on Linode which is currently a part of Akamai.

Creating a Linode

Linode provides scalable and cost-effective VMs to its users with high availability and reliability. You can follow the steps below to spin up a Linode instance.

Step 1: Sign up for a new Linode account to avail 100$ worth of free credits. Existing users can simply log in using their credentials.

Step 2: Once you're logged in, click on Create Linode to proceed.

Step 3: In the Create page, you need to define the configuration for the VM as per your requirement. For this tutorial, you can use the following configuration.

Choose a Distribution: Ubuntu 22.04 LTS
Region: Mumbai, IN (ap-west) (Choose the region closest to you.)
Linode Plan: Shared CPU - Linode 4GB
Linode Label: mindsdb-demo (You can give any name.)
Add Tags: Leave it as it is.
Root Password: Provide a password of your choice.
SSH Keys: As you provided a password, you don't need an SSH Key.
Assign Firewall: None
Attach a VLAN: Leave it at default.
Add-Ons: You can choose to keep the options checked or unchecked based on your requirements.
- Backups: Keep it unchecked.
- Private IP: Keep it checked.

Now click on Create Linode button to initiate the VM creation process. It should take a while to provision the instance.

Step 4: Once you see a Running status on the instance dashboard, you can interact with the instance by clicking on the Launch LISH Console button.

Use the username as root along with the password you specified in the config to access the VM through the console.

You are now ready to deploy MindsDB on this instance.

Deploying MindsDB on the Linode VM

You can easily deploy an instance of MindsDB on this VM using Docker. To do so, follow the steps below.

Step 1: You need to first update the package lists available on the VM so that all the packages are up-to-date. Use the command given below to do so.

sudo apt update

Step 2: Docker is essential for this deployment. You can install it with the command given below.

sudo apt install docker.io

Type Y and hit Enter when prompted to accept the changes and proceed with the installation.

Step 3: Now you need to pull the latest stable release of MindsDB from Docker. You can use the command given below to do this.

sudo docker pull mindsdb/mindsdb

Wait until the image pull is complete to proceed.

Step 4: Now you can run MindsDB on your instance using Docker. You will also need to expose the respective ports for the MindsDB GUI and the MySQL API. Use the command given below to do so.

sudo docker run -p 47334:47334 -p 47335:47335 mindsdb/mindsdb

Wait until all the processes and APIs are up and running. You should see the confirmation in the console window.

Note: sudo is not necessary to execute commands in the console when you're logged in as the root user.

Testing the MindsDB Instance

You have now successfully started MindsDB on the VM using Docker. To visit the MindsDB interface, simply access the public IP of the VM on port 47334.

http://Linode Public IP:47334

You can find the public IP of the VM on the instance details page.

Once you access the GUI, you can find the Query Editor where you can write SQL-like queries and then view the results in the Result Viewer below it.

To test whether the deployment is well and good, you can simply run a basic query given below and check its results.

SHOW tables;

This should list out all the basic tables available in your MindsDB instance by default.

This confirms that the instance is running properly and you easily access it using the internet.

Conclusion

In this tutorial, you successfully learned how to create a VM on Linode, deploy an instance of MindsDB on it, and then access and query it using the public IP of the VM.

Now that you've deployed the instance, you can go ahead and start working with AI Models or Chatbots and explore MindsDB to its full potential. In case you need any further details, feel free to check out their official documentation here.

Lastly, before you leave, don't forget to drop a like and share it with your peers if you got to learn something new today.

Deploying DocsGPT on Kamatera Performance Cloud

Rutam Prita Mishra — Tue, 26 Dec 2023 10:53:08 +0000

Introduction

DocsGPT is an open-source smart solution powered by AI that helps you retrieve relevant information from any technical documentation. This saves the time and effort of manual searches and makes it easier for users to get acquainted with the technical products or even use them.

In this tutorial, you will learn how to host a DocsGPT instance on the Kamatera Cloud Server.

Creating a Kamatera Cloud Server

Kamatera Cloud is one of the popular cloud providers that provides budget-friendly cloud solutions for enterprises of all levels.

To create a cloud server on Kamatera Cloud, follow the steps below.

Step 1: Sign up for a free account and get a 30-day free trial to test its solutions. If you're an existing user, simply login to your account.

Step 2: Once you're in the dashboard, click on My Cloud and then click on Servers.

Step 3: In the Server Management dashboard, click on the Create New Server button.

Step 4: You need to define the server configuration in the Create New Server page. For this tutorial, feel free to use the configuration specified below.

Choose Zone: Asia (China, Hong Kong) [Choose the closest zone to you.]
Choose An Image: Server OS Images
- Image: Ubuntu
- Choose Version: 22.04 64_bit_optimized_updated
Choose Server Specs: Use the specs given below.
- Type: B General
- CPU: 2
- RAM: 4GB
- SSD DISK#1: 30GB
- Daily Backup: Leave it unchecked.
- Management Services: Leave it unchecked.
Choose Networking: Simple Mode
- Public Internet Network: Keep it checked. (Sets a Public IP)
- Private Local Network: Keep it checked. (Sets a Private IP)
Advanced Configuration: Hide
Finalize Settings: Use the settings given below.
- Password: Provide a password of your choice.
- Validate: Confirm the password once again.
- Server: 1
- Name: Provide a name of your choice for the server.
- Power On Servers: Keep it checked.
Billing Cycle and Pricing: Hourly Billing Cycle

Now hit the Create Server button to start booting up the server.

It will redirect you to the Server Management dashboard where you can check the status of the server creation process by clicking on the Tasks Queue tab at the left bottom section.

Step 5: Once the status is 100%, you can interact with the server by clicking on the ▶ button on the dashboard, then selecting the Connect menu, and finally clicking on the Open Remote Console button.

Deploying DocsGPT on the Server

You can use the DocsGPT source code to deploy it easily. Follow the steps given below to do so.

Step 1: Use the remote console to login to the server. The username will be root and the password will be the one that you set above during server configuration.

Step 2: Now clone the DocsGPT GitHub repository to the server.

git clone https://github.com/arc53/DocsGPT.git

Step 3: You should update all the package information in the system before proceeding further. Use the command to do the update.

sudo apt update

Step 4: To run DocsGPT in the server, you need to install the container tools docker and docker-compose. You can use the command below to install them. Press Y+Enter when prompted to proceed with the installation.

sudo apt install docker docker-compose

Step 5: Now navigate to the DocsGPT folder and add the necessary .env variables.

cd DocsGPT/
nano .env

Set the following values in the .env file.

API_KEY= <Your OpenAI API key>
VITE_API_STREAMING= true

Use Ctrl+X, press Y, and then hit Enter to exit the Nano editor.

Step 6: You now need to set the correct IP address of the DocsGPT backend so that the front end can communicate with it. To do this, you need to change the following in the docker-compose.yaml file of DocsGPT.

nano docker-compose.yaml

You can find the VITE_API_HOST parameter on Line 7. Edit and save it so that it points to the public IP of this cloud server.

VITE_API_HOST=http://<Cloud Server Public IP>:7091

You can find the public IP of the server by going to the Network tab on the Server Management page.

Step 7: You can now use the command below to run your DocsGPT instance on the server.

sudo docker-compose up -d

The initial startup takes up some time, so wait until you get a done status on the remote console terminal.

Testing the DocsGPT Instance

The DocsGPT instance is now available on the port 5173. Use the public IP of the server to access its GUI.

http://<Cloud Server Public IP:5173>

You have to choose a source documentation when you open this URL. For now, select default and click on Save to proceed.

Feel free to ask generic questions to DocsGPT in the chat window and it will reply with the answers.

You: What is DocsGPT?
DocsGPT: DocsGPT is an AI-powered language model developed using OpenAI's GPT (Generative Pre-trained Transformer) architecture. It is designed specifically to assist users in composing and editing documents. DocsGPT can help generate text in various formats, such as essays, code snippets, technical documentation, and more. It understands natural language commands and provides informative responses to user queries. Through its conversational interface, DocsGPT can assist with a wide range of document-related tasks, including content generation, formatting, organization, and more.

Conclusion

In this tutorial, you learned about DocsGPT and Kamatera Cloud. You specifically created a Kamatera Cloud Server, deployed an instance of DocsGPT in it using docker and docker-compose, and finally tested DocsGPT with a sample question.

Now that you've deployed your instance of DocsGPT, feel free to try it out and test its various features. You can check out their official documentation here for further information.

Lastly, before you close this page, don't forget to drop a like and share your feedback in the comments below.

Sentiment Analysis App using Gemini

Rutam Prita Mishra — Sun, 24 Dec 2023 14:01:48 +0000

Introduction

Google has recently launched its state-of-the-art AI model Gemini. Gemini is another Large Language Model that is built robustly for multimodality. This brand-new LLM claims to be better than its contender GPT-4 in many aspects. It is currently offered in 3 variations- Nano, Pro, and Ultra.

The Gemini API was made available for developers on the 13th of December. In this tutorial, we will be using it to build a simple Node Express app that can analyze the sentiments of texts.

Generating the Gemini API Key

The first thing you need to do is to generate an API key which you will use later in your app. Follow the steps below to create one.

Step 1: Visit the Google AI for Developers page and click on the Get API key in Google AI Studio button.

Step 2: In the next screen you will need to sign in with your Google account to proceed. Once you're signed in, you will be redirected to the Google AI Studio dashboard.

If it's your first time logging in, you will need to accept some terms first. Select the appropriate ones and then click on Continue.

Step 3: Now on the Build with Gemini popup, click on the Get API Key button to proceed.

In the API keys dashboard, click on the Create API key in new project button and wait until the key is generated.

Now copy the new API key from the popup and store it safely so that you can use it later in the app.

Setting up the Node Express App

Now you will need to build a simple app using Node Express that will interact with Gemini through the API and return the sentiments of the user-given sentences/texts.

Creating the Project Structure

Let's start with setting up a Node project directory for the app. Follow the steps below to do it easily.

Step 1: Create a new folder in your desired location and set a name for it.



sentiment-gemini

Step 2: Now open this folder in your desired code editor. For this tutorial, we will use Visual Studio Code.

Now open the terminal by clicking on Terminal on the Title Menu and then selecting the New Terminal option. Use the command given below to initialize a Node project.



npm init

Provide the necessary details in the terminal to set up the package.json file for this Node app or hit enter each time to proceed with the default ones.

Step 3: You are now ready with the Node project directory. You can then install the necessary packages to run this app.

Execute the command below to install all the required/essential packages.



npm i @google/generative-ai body-parser dotenv express

Creating the Client Webpage

You will need a webpage where the users can enter a sentence to fetch its sentiment.

To do so, follow the steps below.

Step 1: Create a public folder inside the app root directory and add a new file named index.html to it.

Step 2: Add the following content to the HTML file to design a simple webpage with an input area, a submit button, and a result display area, all embedded within a <form> element.



<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Sentiment Analysis App</title>
</head>
<body>
  <h1>Sentiment Analysis App</h1>
  <form id="sentimentForm" action="/analyze" method="post">
    <label for="text">Enter a text sentence:</label>
    <input type="text" id="text" name="text" required>
    <button type="submit">Find Sentiment</button>
  </form>
  <b><div id="result"></div></b>

<script src="./script.js"></script>
</body>
</html>

Step 3: Now, add a script.js file in the same folder with the following content.



    // Display sentiment result on the webpage
    document.getElementById('sentimentForm').addEventListener('submit', async function (event) {
        event.preventDefault();

        const text = document.getElementById('text').value;

        // Send a POST request to the server
        const response = await fetch('/analyze', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ text }),
        });

        // Fetch the Result and display it on the webpage
        const result = await response.text();
        document.getElementById('result').innerText = result;
      });

This file handles the submit button action i.e., it sends the user request to the /analyze endpoint, fetches the result, and then sets it to the result div on the webpage.

Creating the Server Application

You can now navigate back to the root folder of the application to proceed further with the following steps.

Step 1: Create an app.js file which serves as the main server file. You can use the following code for this file.



require("dotenv").config();
const express = require("express");
const bodyParser = require("body-parser");
const { GoogleGenerativeAI } = require("@google/generative-ai");

const app = express();
const port = 3000;

const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// Middleware to parse incoming JSON requests
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

// Middleware to serve static files from the 'public' directory
app.use(express.static("public"));

// Serve HTML Webpage to the user on Page Load
app.get("/", (req, res) => {
  res.sendFile("index.html", { root: "public" });
});
// Handle sentiment analysis when the form is submitted
app.post("/analyze", async (req, res) => {
  try {
    const userInput = req.body.text;

    // Call Gemini API for sentiment analysis
    const geminiResponse = await run(userInput);

    const sentimentResult = geminiResponse;

    // Send sentiment result back to the client
    res.send(sentimentResult);
  } catch (error) {
    console.error("Error:", error.message);
    res.status(500).send("Internal Server Error");
  }
});

// Start the server
app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

// Basic Function API to generate content/result using Gemini
async function run(userInput) {
  // For text-only input, use the gemini-pro model
  const model = genAI.getGenerativeModel({ model: "gemini-pro" });

  const prompt = `Analyze the sentiment of the sentence given below.\n${userInput}\nThe output should be in the format- Semtiment: Value`;

  const result = await model.generateContent(prompt);
  const response = await result.response;
  const text = response.text();
  return text;
}

Step 2: Now create a .env file and paste the API Key value that you obtained in the earlier steps.



API_KEY=<YOUR GEMINI API KEY VALUE HERE>

This completes the basic setup for the Node Express App.

Testing the App

You are now ready to run the app and test the functionality. Use the command below in the terminal to start the app.



node app.js

Once it executes successfully, you should see a message that the server is running on port 3000.

Now, open your browser and navigate to localhost:3000 to access your app. You should see a simple webpage as shown below.

Enter a sentence in the input area and click on the Find button. It should return the sentiment of that sentence in a while on the webpage.

This verifies that your app is running as expected.

Conclusion

In this tutorial, you have successfully learned how to generate your own Gemini API key, set up a Node Express App with a webpage, and then run it to find the sentiments of user-given sentences.

While this is a simple example app to showcase how you can use the Gemini Developer API to build your applications seamlessly, feel free to explore the Gemini documentation to explore further advanced topics and usages of the Gemini Model.

You can also check out the source code of this app here.

Lastly, before you leave, don't forget to drop a like and share it with your peers if you found this content valuable and learned something new today.

4th Time Hacktoberfest Contributor

Rutam Prita Mishra — Sat, 09 Dec 2023 13:07:58 +0000

Intro

Well, I have been working as a Software Dev for almost 4 years now. I often participate in various open-source programs and contribute to many open-source projects that pique my interest. This is the 4th time I am participating in Hacktoberfest and I look forward to contributing meaningfully once again to the best of my knowledge.

Rutam21 (Rutam Prita Mishra) · GitHub

Associate Software Developer | Open Source Enthusiast | Blogger @Mattermost Rel v5.39 Contributor MVP | @DigitalOcean Navigator | @Civo Developer Advocate Demo - Rutam21

github.com

Highs and Lows

I always try to contribute both code and documentation in various open issues for different projects. This year also I came across several new projects such as DocsGPT, Trigger.dev, Hyperswitch and Bytebase, etc.

I tried to curate some blogs on some of these tools and also worked on some of their available tickets. Understanding the code base and running the code base locally always was a challenge and that is something I learned and executed properly towards the end.

Another challenge was to make sure that everything worked properly after doing a code change and testing it thoroughly which I did.

There were highs and lows but the overall experience was very rewarding.

Growth

After working on several projects this Hacktoberfest, I have a wider knowledge of different OSS projects out there and have experience in utilizing these tools for different tasks as and when required in my personal and professional endeavors.

Networking and knowing many different people who share the same vision and goal was another plus that I acquired during Hacktoberfest 2023.

Cheers to Hacktoberest 2023!

Deploying DocsGPT on DigitalOcean Droplet

Rutam Prita Mishra — Mon, 06 Nov 2023 13:46:36 +0000

Introduction

DocsGPT is a smart AI assistant to aid all of your technical documentation needs. You can directly communicate with it through a chat interface and it will provide you with the required solution by going through the technical documentation of a given product on its own.

In this tutorial, you will learn how to self-host an instance of DocsGPT on a DigitalOcean cloud instance called Droplet.

Initiating DigitalOcean Droplet

DigitalOcean is a famous cloud provider that provides affordable cloud solutions to its consumers. You will now deploy a cloud VM instance called Droplet on the DigitalOcean platform. Follow the steps below to create a Droplet easily.

Step 1: Log in to your DigitalOcean account to open your user dashboard. If you don't have an account yet, simply create one here. You can claim free credits worth $200 valid for 60 days to try the platform seamlessly.

Step 2: Once you are in the user dashboard, click on Droplets in the left navigation panel and then click on the Create Droplet button. This should take you to the new Droplet configuration wizard.

Step 3: On this page, you need to define the configuration for your cloud instance. You can define the configuration as per your needs but feel free to use the configuration given below to complete this tutorial.

Choose Region: Choose the region closest to you to minimize latency.
Datacenter: Leave it at default. If there are multiple options available for your region, then select the data center that falls closer to your geographic location.
VPC Network: This is set to default.
Choose an image: Click on the OS tab and then select Ubuntu.
Version: 22.04 (LTS) x64 (You can also go for the latest 23.10 x64 version)
Choose Size: Select the sub-options as follows.
- Droplet Type: Basic (Plan Selected)
- CPU Options: Regular [Disk Type: SSD]
- Plans: $24/mo (4GB / 2 CPUs, 80GB SSD Disk, 4 TB Transfer)
- Additional Storage: Leave it as it is.
Choose Authentication Method: Select Password
- Create root password: Provide a password for your root user.
Recommended Options: Leave it as it is as we don't have any extra configuration required for this tutorial.
Finalize Details: Use the sub-options as follows.
- Quantity: 1 Droplet
- Hostname: docsgpt-demo (You can provide any name.)
- Tags: Leave it blank.
- Project: Select Demo or your email from the dropdown.

Now click on the Create Droplet button to start provisioning the VM.

Step 4: It will take some time for the instance to be up and running. Wait until the loading bar completes in the following screen and you see a green dot beside the Droplet name that confirms its running status.

Step 5: Now click on the droplet name i.e., docsgpt-demo and then click on Console on the next screen to log in to your Droplet. This will open a new terminal window.

You are now ready to proceed with the installation of DocsGPT on your Droplet.

Deploying DocsGPT

Now you need to follow the steps given below to successfully deploy DocsGPT on your cloud instance.

Step 1: Clone the DocsGPT repository to your instance. Use the command given below to do so.

git clone https://github.com/arc53/DocsGPT.git

Step 2: Update the package indexes of your Ubuntu system with the command given below.

sudo apt update

Step 3: DocsGPT needs containerization tools like docker and docker-compose to run. You can install them with the commands given below. Press Y when prompted to proceed with the installation.

sudo apt install docker docker-compose

Step 4: The .env variables for DocsGPT need to be set. You can do so by going to the DocsGPT folder and adding a .env file.

cd DocsGPT/

nano .env

Save the following values in the .env file.

LLM_NAME=DocsGPT-7b (You can choose any available LLM under DocsGPT)
API_KEY= <Your OpenAI API key>
VITE_API_STREAMING= true

You can exit the Nano editor by using Ctrl + X and then hitting Y followed by Enter.

Step 5: DocsGPT's front end needs to connect and communicate with its backend properly for its work. To do this, you need to edit the docker-compose.yaml file so that it points to the correct IP address of the backend. Use the command below to edit the file.

nano docker-compose.yaml

Find Line 7 in the editor and edit the VITE_API_HOST parameter. It should use the public IPv4 of your Droplet.

VITE_API_HOST=http://<Droplet Public IPv4>:7091

You can find the Publiv IPv4 of the Droplet on the Droplet details page.

Now save the changes and exit the editor.

Step 6: You are now ready to run DocsGPT on your Droplet with the command given below. Remember that the initial startup time will be a bit longer as it requires downloading all the necessary dependencies and then building the app.

sudo docker-compose up -d

Once you see the done status of a list of DocsGPT jobs in the terminal, you're good to work with it on your Droplet.

Working with DocsGPT

You can now access DocsGPT by visiting the following URL.

http://<Public Droplet IPv4:5173>

When you open this URL for the first time, you will need to choose a source documentation. Select default and click on Save to test the deployment.

You can now ask generic questions about DocsGPT and it will provide you with the relevant answers.

You: What is DocsGPT?

DocsGPT: DocsGPT is an AI-powered language model developed using OpenAI's GPT (Generative Pre-trained Transformer) architecture. It is designed specifically to assist users in composing and editing documents. DocsGPT can help generate text in various formats, such as essays, code snippets, technical documentation, and more. It understands natural language commands and provides informative responses to user queries. Through its conversational interface, DocsGPT can assist with a wide range of document-related tasks, including content generation, formatting, organization, and more.

Your DocsGPT deployment is now ready to help you with any technical documentation needs.

Conclusion

DocsGPT can be a great asset to save time by eliminating the need to manually search across docs to seek answers. The team behind this is working continuously to bring more features and upgrade the user experience. You also have the option to try their cloud version directly if you don't wish to host it by yourself.

The community is always welcome to try it out and provide their valuable feedback or suggest additional features by joining their Discord.

Lastly, before you leave, feel free to drop a Like if you loved reading this article, and don't forget to share it with your peers.

Database GitOps with Bytebase for MySQL

Rutam Prita Mishra — Tue, 31 Oct 2023 12:55:20 +0000

Introduction

GitOps is a powerful methodology for managing infrastructure and application configurations using Git repositories. Bytebase is a database management tool that simplifies collaboration on database schemas, automates migrations, and enables GitOps workflows. This tutorial guides you through setting up Database GitOps with Bytebase for a MySQL database. By the end of this tutorial, you will have a MySQL database with its schema version controlled in a Git repository using Bytebase.

Prerequisites

Before you start, ensure you have the following prerequisites:

A running MySQL database server.
Git installed on your local machine.
Docker and Docker Compose (for running Bytebase).

Step 1: Install and Set Up Bytebase

Bytebase is available as a Docker container, making it easy to set up. Follow these steps to get it up and running:

Create a directory for your Bytebase configuration and navigate to it in your terminal.
Create a docker-compose.yaml file with the following content:

   version: '3'
   services:
     bytebase:
       image: bytebase/bytebase
       ports:
         - 8080:8080
       environment:
         - DATABASE_URL=mysql://<username>:<password>@<db_host>:<db_port>/<db_name>
       volumes:
         - ./bytebase-data:/data

Replace <username>, <password>, <db_host>, <db_port>, and <db_name> with your MySQL database details.

Run the following command to start the Bytebase container:

   docker-compose up -d

Bytebase should now be accessible at http://localhost:8080. Open your web browser and access this URL to complete the initial setup of Bytebase.

Step 2: Create a Bytebase Project

After setting up Bytebase, create a new project. A project acts as a container for all the database schemas and changes related to a specific application or service.
Click on the newly created project to access its dashboard.

Step 3: Set Up a Git Repository

Now, set up a Git repository to store your database schema and migrations. You can use a Git hosting service such as GitHub, GitLab, or Bitbucket.

Create a new Git repository for your project and initialize it with a README or an empty commit.
Clone the repository to your local machine.
In the Bytebase project dashboard, navigate to the "Settings" tab and select "Git Repository."
Fill in the Git repository details, including the URL, branch name, username, and password or token if required.
Save the Git repository configuration.

Step 4: Configure Database Connections

To manage your MySQL database using Bytebase, you need to configure a database connection.

In the Bytebase project dashboard, go to the "Settings" tab and select "Database Connections."
Click "Create Database Connection" and provide the necessary information, including the database type, connection name, host, port, database name, username, and password.
Save the database connection.

Step 5: Create and Track Schema

With Bytebase and your Git repository set up, it's time to create and track your database schema:

In the Bytebase project dashboard, navigate to the "Database" section and select your configured database connection.
Click on "Schema" to create a new schema. You can create tables, indexes, and other database objects here.
After creating your schema, navigate to the "Migrations" tab and create a migration for the schema changes.
Once your migration is created, you can review and validate it.
Commit and push your migration to the Git repository you set up earlier.
Bytebase will automatically track your schema changes in the Git repository.

Step 6: Collaborate and Deploy Changes

Bytebase allows multiple team members to collaborate on database schema changes, review migrations, and deploy them.

Invite team members to your Bytebase project by sharing the project's URL with them.
Team members can access the project, review migrations, and approve them.
Deploy approved migrations to your MySQL database using Bytebase.

Conclusion

In this tutorial, you've set up Database GitOps with Bytebase for a MySQL database. You've learned how to:

Install and configure Bytebase using Docker.
Create a Bytebase project and configure Git repository and database connections.
Track and version-control your MySQL database schema and migrations using Git.
Collaborate with team members and deploy changes to the database.

This approach streamlines your database management processes, making it easier to manage schema changes and collaborate with team members while keeping everything under version control.

Lastly, before you leave, don't forget to drop a Like and share it with your peers.

Database GitOps with Bytebase for PostgreSQL

Rutam Prita Mishra — Tue, 31 Oct 2023 12:49:17 +0000

Introduction

GitOps is a methodology that allows you to manage your infrastructure and application configurations using Git repositories. Bytebase is a database management tool that helps you collaborate on database schemas, manage migrations, and automate database operations. This tutorial will guide you through setting up Database GitOps with Bytebase for a PostgreSQL database. By the end of this tutorial, you'll have a PostgreSQL database and its schema version-controlled in a Git repository using Bytebase.

Prerequisites

Before you begin, make sure you have the following prerequisites:

A PostgreSQL database server is installed and running.
Git installed on your local machine.
Docker and Docker Compose (for running Bytebase).

Step 1: Install and Set Up Bytebase

Bytebase is available as a Docker container, which makes it easy to set up. Follow these steps to get it up and running:

Create a directory for your Bytebase configuration and navigate to it in your terminal.
Create a docker-compose.yaml file with the following content:

   version: '3'
   services:
     bytebase:
       image: bytebase/bytebase
       ports:
         - 8080:8080
       environment:
         - DATABASE_URL=postgresql://<username>:<password>@<db_host>:<db_port>/<db_name>
       volumes:
         - ./bytebase-data:/data

Replace <username>, <password>, <db_host>, <db_port>, and <db_name> with your PostgreSQL database details.

Run the following command to start the Bytebase container:

   docker-compose up -d

Bytebase should now be accessible at http://localhost:8080. Open your web browser and access this URL to complete the initial setup of Bytebase.

Step 2: Create a Bytebase Project

After setting up Bytebase, create a new project. You can think of a project as a container for all the database schemas and changes related to a particular application or service.
Once the project is created, click on it to access its dashboard.

Step 3: Set Up a Git Repository

Now, you need to set up a Git repository to store your database schema and migrations. You can use a Git hosting service like GitHub, GitLab, or Bitbucket.

Create a new Git repository for your project and initialize it with a README or an empty commit.
Clone the repository to your local machine.
In the Bytebase project dashboard, navigate to the "Settings" tab and select "Git Repository."
Fill in the Git repository details, including the URL, branch name, username, and password or token if required.
Save the Git repository configuration.

Step 4: Configure Database Connections

To manage your PostgreSQL database using Bytebase, you need to configure a database connection.

In the Bytebase project dashboard, navigate to the "Settings" tab and select "Database Connections."
Click on "Create Database Connection" and provide the necessary information, including the database type, connection name, host, port, database name, username, and password.
Save the database connection.

Step 5: Create and Track Schema

Now that you have Bytebase and your Git repository set up, it's time to create and track your database schema:

In the Bytebase project dashboard, navigate to the "Database" section and select your configured database connection.
Click on "Schema" to create a new schema. You can create tables, indexes, and other database objects here.
After creating your schema, navigate to the "Migrations" tab and create a migration for the schema changes.
Once your migration is created, you can review and validate it.
Commit and push your migration to the Git repository you set up earlier.
Bytebase will automatically track your schema changes in the Git repository.

Step 6: Collaborate and Deploy Changes

Bytebase allows multiple team members to collaborate on database schema changes, review migrations, and deploy them.

Invite team members to your Bytebase project by sharing the project's URL with them.
Team members can access the project, review migrations, and approve them.
Deploy approved migrations to your PostgreSQL database using Bytebase.

Conclusion

In this tutorial, you've set up Database GitOps with Bytebase for a PostgreSQL database. You've learned how to:

Install and set up Bytebase using Docker.
Create a Bytebase project and configure Git repository and database connections.
Track and version-control your database schema and migrations using Git.
Collaborate with team members and deploy changes to the database.

This approach allows you to manage your database schema and changes in a more controlled and collaborative manner, improving your database management workflow.

Before you leave, don't forget to drop a Like and share the article with your peers.

Building an Instill AI Pipeline in 5 minutes

Rutam Prita Mishra — Sun, 22 Oct 2023 21:07:31 +0000

Introduction

InstillAI is a no-code or low-code platform that enables users to build AI workflows for unstructured data at lightning-fast speed.

The Instill core can be broadly categorized into 3 segments, namely:

Instill VDP: VDP stands for Versatile Data Processing and it represents a comprehensive unstructured data infrastructure. Instill VDP aims to simplify the processing of such unstructured data from A-Z easily.
Instill Model: This part of the core enables you for MLOps. The Instill Model makes way for you to import and serve ML models hassle-free for gaining insights in the form of inferences.
Instill Base: This is the base in the true sense for all the Instill Projects as it manages the underlying services such as user management servers, databases, and third-party observability tools. It also upgrades the accessibility and usability across VDP and Model.

Now after that long introduction, let's do something interesting with it. In this article, we will build an AI pipeline for Text Sentiment Analysis in just 5 minutes.

So, set your timer, and let's get going.

Setting up the Pipeline

You will now learn how you can set up an AI pipeline on InstillAI Follow the steps below to complete it easily.

Step 1: Log in to your InstillAI Cloud account. If you don't have an account yet, you can create one here for free using your Email or Google or GitHub ID.

Step 2: Once you're logged in, it takes you to your console dashboard.

Here you can find some pre-defined pipeline templates to get started with. But for now, you will do everything from scratch.

Click on the Add Pipeline button to create a new pipeline.

Step 3: It takes you to the pipeline creator dashboard. Here you can notice that there's something like a flowchart at the middle of the screen. It mainly consists of three things.

Start: Here you will define your input elements.
Connector: Here you will define your AI Agent (OpenAI, Llama, etc)
End: Here you will see the output.

Step 4: You will perform a text sentiment analysis here. So, you have to create a Text field in the Start section.

Click on Add Field in the Start section and then select Text. In the next screen, provide a Name for the field and the Key through which you will access it.

Step 5: Now move on to set up the connector for this pipeline. To complete this particular task, you can use OpenAI GPT as a connector.

Simply click on Add Connector and on the next screen, select OpenAI from the New Resource section.

Step 6: Once you select the new resource, your connector section will now show the option to create a resource. Click on Create Resource to proceed.

In the Add Resource modal, provide an ID, Description, OpenAI API Key, and an Organization name, and finally click on Save. This creates an OpenAI resource for you.

Note: You need to sign up on OpenAI to obtain your own API key. The key shown in the image above is a dummy.

Step 7: Now you can create an AI Task for Sentiment Analysis using the above OpenAI resource. Click on the ⚙️ icon on the Connector section to configure the AI Task. You can use the options below or can customize it as per your needs.

Task: Text Generation
prompt: Analyze the sentiment of {{start.text}} and return back the sentiment. The output should be in the format- Sentiment: Sentiment Value
model: gpt-3.5-turbo
system_message: You are an assistant who is in charge of sentiment analysis of texts.
temperature: 0.5 (We want to have a more focussed response)
n: 1 (Defines the number of chat completion choices)
max_tokens: 2500

Now click on Save to save the AI Task.

Note: We are using the value of the Text field defined in the Start section for sentiment analysis. You can access that value by using {{start.keyName}}.

Step 8: You will now notice that the Start and Connector sections are connected. This is because you used the text value from the Start section in the AI Task.

Step 9: Now you have to configure the End section so that you can see the results there. Click on Add Field, provide a Title, aKey, and theValue` for this field.

The simple logic to determine the Value for the End field is as follows.

The connector provides the output which has the Key name as texts. So, the value here can be accessed by {{connector_name.output.texts}}.

Now once you hit the Save, you will find that the Connector and the End sections are connected as well.

You are now ready to run this pipeline and test it. Before that, click on Save in the top right section of the screen to save this pipeline.

Testing the Pipeline

You can now click on the Run button which is beside the Save button to start testing this pipeline with an actual run.

On the next screen, type a text in the Start section which would act as an input to the AI task, and then click on Run on top of it.

Wait for a while and then you can see the sentiment of the above sentence in the output field of the Connector as well as the End section.

This confirms that your pipeline is properly set and is working as expected. You can stop the pipeline by clicking on the Stop button at the top right section of the screen.

Conclusion

In this tutorial, you finally learned how to create an AI pipeline easily using InstillAI. You also successfully completed the sentiment analysis of texts using the OpenAI resource in the pipeline.

InstillAI is currently in its Alpha stage and all of its features are free to use. Feel free to explore it and provide feedback to their team through their Discord server.

Lastly, if you liked reading this article, please don't forget to drop a Like and share it with your peers. Feel free to provide your feedback or suggestions in the comments below.

Deploying DocsGPT on Civo Compute

Rutam Prita Mishra — Tue, 17 Oct 2023 22:27:30 +0000

Introduction

DocsGPT is an AI assistant for your technical documentation needs. It serves you with any specific information you may seek from a piece of documentation and eliminates the need for manual searches.

In this tutorial, you will learn to self-host DocsGPT on one of the major cloud providers i.e., Civo. The only objective will be to deploy an instance of DocsGPT on a Civo Compute VM.

Initiating Civo Compute

We will start this tutorial by creating a Civo compute instance first. The steps given below will simply help you create one easily.

Step 1: Login to your Civo Dashboard. If you don't have an account, then simply Sign Up and claim your free credits worth 250$ valid for 1 month.

Step 2: Once you're in the Civo Dashboard, click on Compute from the left panel and then click on the Launch my first instance button.

Step 3: Here you need to define the configuration for the compute machine that you want to create. Feel free to customize it as per your demands but for the sake of this tutorial, we will use the configuration given below.

Hostname: Name the machine as you wish.
How many instances: Keep it at default 1.
Select Size: Select Small Standard as the size.
Select image: Choose Ubuntu 22.04 LTS.
Initial User: Choose root to have all privileges or ubuntu to have the standard privileges.
Network: Keep it at default.
Public IP address: You will need a Public IP to be able to use DocsGPT instance from the internet. Select Create.
Firewall: Use default-default from the dropdown or if you don't have that option, then select Create new firewall. It will add a default firewall policy.
SSH Key: Choose Random Password.
Initialisation Script: Leave it empty.
Tags: Leave it empty as well.

Now click on the Create button. This is going to take a while to boot up your new instance.

Step 4: Wait until you can see the The instance is running. message at the top of the screen. You can now click on the View SSH information to find your username and random password that you can use to log in to your instance through SSH.

You're now ready to move to the next part where you will install DocsGPT in your instance and use it through your Public IP.

Deploying DocsGPT

You can now simply follow the steps below to successfully deploy DocsGPT on your compute instance.

Step 1: Open your terminal and SSH into your compute instance using the command below.

ssh username@<Public IP of the instance>

Type yes when prompted and then enter the random password that you can find in the SSH Information panel on your compute dashboard to log in.

Step 2: Now you can clone the DocsGPT clone repository to your instance with the command given below.

git clone https://github.com/arc53/DocsGPT.git

Now, try running the following to update the package lists.

sudo apt update

Step 3: You will need the docker and docker-compose containerization tools to run DocsGPT easily. You can install these using the following commands.

sudo apt install docker.io

Now install docker-compose. Type Y and hit Enter when prompted.

sudo apt install docker-compose

Step 3: Navigate to the DocsGPT folder now and define the environment variables in a .env file.

cd DocsGPT/

nano .env

Enter the following details in your .env and save it.

API_KEY= <Your OpenAI API key>
VITE_API_STREAMING= true

Use Ctrl + X and then type Y and hit Enter to exit the editor.

Step 4: You will now need to set the correct IP for the backend so that it can communicate with the frontend properly. Modify the docker-compose.yaml file to do this.

nano docker-compose.yaml

Navigate to Line 7 where the VITE_API_HOST is defined. Modify the host URL as such.

VITE_API_HOST=http://<Compute Instance Public IP>:7091

Step 5: You can now run the DocsGPT app on your instance with the command below. The initial start-up time can be a bit longer as it downloads all the necessary dependencies and builds the app.

sudo docker-compose up -d

Now you should be able to access your own self-hosted DocsGPT on Civo Compute using the following URL.

http://<Public Compute Instance IP:5173>

Working with DocsGPT

When you open the DocsGPT page for the first time, it is going to ask you to select Source Document. You can choose any one source from the list and then start querying about it using DocsGPT.

You can now query anything about the Docs.

For e.g., if you selected the source document as default, then you can ask generic queries about it.

You: What is DocsGPT?

DocsGPT: DocsGPT is an AI-powered language model developed using OpenAI's GPT (Generative Pre-trained Transformer) architecture. It is designed specifically to assist users in composing and editing documents. DocsGPT can help generate text in various formats, such as essays, code snippets, technical documentation, and more. It understands natural language commands and provides informative responses to user queries. Through its conversational interface, DocsGPT can assist with a wide range of document-related tasks, including content generation, formatting, organization, and more.

So, now your self-hosted DocsGPT instance is ready to serve all of your documentation needs.

Conclusion

DocsGPT is ever-evolving, and they are striving to add more features and are continuously supporting the community and consumers as much as they can.

Feel free to use it yourself and share your feedback with the team.

We hope you had a great time reading this deployment guide. Don't forget to drop a Like and share it with your peers.

Predict Sales of Manufacturing with MindsDB using Java

Rutam Prita Mishra — Tue, 06 Jun 2023 18:54:50 +0000

Introduction

MindsDB is a powerful AutoML framework. Developers and data scientists highly rely on it to build predictive models that are highly accurate, without requiring extensive knowledge of machine learning algorithms. With MindsDB, you can extend the power of AI to predict or forecast certain target outcomes and gain valuable insights from your data.

Java, on the other hand, is a versatile and popular programming language that provides robustness and scalability for developing various applications. By integrating MindsDB with Java, you can harness the capabilities of both technologies to create a comprehensive solution.

In this tutorial, we will explore the seamless integration of MindsDB and Java to predict sales in the manufacturing sector. Let's dive in and discover the exciting possibilities that arise when combining the cutting-edge technology of MindsDB with the robustness and flexibility of Java!

Setting up a Java Project

You are free to choose the editor as per your convenience. However, we will use Eclipse as the editor for this tutorial. You can follow the steps below to successfully set up a Java project and deal with all the required dependencies.

Open your Eclipse Editor. You can download the Eclipse editor from here.
Click on the File menu, select New and then click on Project....

In the New Project wizard, select Java Project and click on Next. Finally provide a name for the project, leave everything else at default and click on Next.

In the next page, you can configure the build settings for the project. To successfully complete this tutorial, we will need the MySQL Java connector jar. You can download it from here.

Now simply click on Libraries, select Classpath and then hit the Add External JARs... button. Finally click on Finish button.

If a popup appears to display the default perspective for the project, click on Open Perspective to proceed.

It is not really advised to create Java class files in the /src root i.e., default package. So, we will create a package first.

Right click on /src, select New and then click on Package. Provide a name for the package and then click on Finish.

Now the Java project is ready, and we can continue with further steps below.

Creating a Connection to MindsDB Cloud

The first step we want to take is to successfully create a connection to MindsDB Cloud.

Let's create a new Class file inside mindsdb package and name it as connections.java.

You can use the code snippet below to establish the connection.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;

public class Connections {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection conn = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Connection Failed. Please check your credentials.");
        }
    }
}

Here is what the code does.

It imports the necessary packages, including java.sql.Connection and java.sql.DriverManager.
The connection details, such as the host, username, and password, are specified in the code and is specific to each user.
The getConnection() method is used to establish a connection to the database, and if successful, a message indicating a successful connection is printed. If there is an exception or the connection fails, an error message is displayed.

Fetching Table data from MindsDB Cloud

If we are able to successfully connect to MindsDB Cloud, we can now try to fetch some table data.

Simply create another new Class file and name it as Tables.java.

For this tutorial, we are using this dataset from Kaggle. Download this dataset and upload it on MindsDB Cloud as a table so that we can use it now.

You can use the code snippet below to fetch the data from the Sales table.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Tables {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection connection = null;
        Statement statement = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");

            String query = "SELECT * FROM files.Sales LIMIT 3";
            statement = connection.createStatement();
            ResultSet rs = statement.executeQuery(query);

            while (rs.next()) {
                String date = rs.getString("Date of Order");
                String storeCode = rs.getString("Store Code");
                String itemCode = rs.getString("Item Code");
                String sales = rs.getString("sales");
                String district = rs.getString("District");
                String state = rs.getString("State");

                System.out.println("\n\n Date: " + date + "\n Store Code: " + storeCode + "\n Item Code: " + itemCode
                        + "\n Sales: " + sales + "\n District: " + district + "\n State: " + state);
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("An error occurred while fetching table data.");
        }
    }
}

Let's understand what this code does below.

The code establishes a connection to a MySQL database hosted on the MindsDB Cloud.
It imports the necessary packages, including java.sql.Connection, java.sql.DriverManager, java.sql.ResultSet, and java.sql.Statement.
The connection details, such as the host, username, and password, are specified in the code.
A SQL query is executed to retrieve data from the Sales table in the files database. The retrieved data is then displayed in the console, including columns like "Date of Order," "Store Code," "Item Code," "Sales," "District," and "State."

Creating a Predictor Model

Now we can similarly establish a connection and create a Predictor model using a Java Class file. Create another new class named Predictor.java and use the code snippet given below.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class Predictor {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection connection = null;
        Statement statement = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");

            String query = "CREATE PREDICTOR mindsdb.sales_predictor FROM files (SELECT `Store Code`,`Item Code`,sales,District,State FROM Sales LIMIT 10000) PREDICT sales";
            statement = connection.createStatement();
            boolean isSuccess = statement.execute(query);

            System.out.println("Is the predictor model created successfully: " + isSuccess);

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("An error occurred while creating the predictor. " + e);
        }
    }
}

Find a summary of what the code does below.

The code establishes a connection to a MySQL database hosted on the MindsDB Cloud.
It imports the necessary packages, including java.sql.Connection, java.sql.DriverManager, and java.sql.Statement.
The connection details, such as the host, username, and password, are specified in the code.
A SQL query is executed to create a predictor model named sales_predictor using the data from the Sales table in the "files" database. The predictor model is trained to predict the sales column. The query also limits the data to 10,000 rows.
The result of the model creation operation is printed to the console, indicating whether the predictor model was created successfully or not.

Note: The model name needs to be unique. So, if the model is created once successfully and you try to execute this code multiple times, you will get an error stating the following.
Error: model 'sales_predictor' already exists in project mindsdb!

Checking Status of the Model

Once you create a model, it takes some time to complete it's training. You can create a new class named Status.java and use the code snippet below to fetch the creation status of the current model.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Status {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection connection = null;
        Statement statement = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");

            String statusQuery = "SELECT status FROM mindsdb.predictors WHERE name='sales_predictor'";
            statement = connection.createStatement();
            ResultSet rs = statement.executeQuery(statusQuery);

            while (rs.next()) {
                String status = rs.getString("status");
                System.out.println("\n\n Status: " + status);
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("An error occurred while fetching table data.");
        }
    }
}

Here is a summary of what the code does.

The code establishes a connection to a MySQL database hosted on the MindsDB Cloud.
It imports the necessary packages, including java.sql.Connection, java.sql.DriverManager, and java.sql.ResultSet.
The connection details, such as the host, username, and password, are specified in the code.
A SQL query is executed to fetch the status of the specific predictor model named sales_predictor from the mindsdb.predictors table.
The status of the predictor model is retrieved from the result set and printed to the console.

Making Predictions

We have now successfully created a model to predict the sales of medium scale units located in Maharashtra, India.

We can predict the sales in two ways i.e., Single or Batch. Let us see how we can do this one by one below.

Single Predictions

In this type of prediction, we predict a single target value based on a set of given feature set values.

You can create another new Class file named SinglePrediction.java and use the code snippet below.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Prediction {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection connection = null;
        Statement prediction = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");

            String query = "SELECT * FROM mindsdb.sales_predictor WHERE `Item Code`=1 AND District='Kolhapur'";
            prediction = connection.createStatement();
            ResultSet rs = prediction.executeQuery(query);

            while (rs.next()) {
                int sales = rs.getInt("sales");
                float confidence = rs.getFloat("sales_confidence");
                float sales_min = rs.getFloat("sales_min");
                float sales_max = rs.getFloat("sales_max");

                System.out.println("\n\n Sales: " + sales + "\n Confidence: " + confidence + "\n Max Sales: " + sales_max + "\n Min Sales: " + sales_min);
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("An error occurred. Please try again!" + e);
        }
    }
}

You can understand what the code exactly does below.

The code imports necessary packages for establishing a connection to a MySQL database and performing SQL operations.
It establishes a connection to the MindsDB Cloud MySQL database using the provided host, username, and password.
A SQL query is executed to fetch prediction results from the sales_predictor model based on specified conditions (Item Code=1 and District='Kolhapur').
The fetched prediction results, including sales, confidence, maximum sales, and minimum sales, are printed to the console.

Batch Predictions

We can also choose to predict the target value for a set of data records i.e., a Batch. To achieve this, we can JOIN the sales_predictor model with the Sales table.

Now create a new file again named BatchPredictions.Java and use the code snippet given below.

// Import the necessary packages
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Batch {
    public static void main(String[] args) {
        final String host = "jdbc:mysql://cloud.mindsdb.com:3306/files";
        final String username = "YOUR_MINDSDB_ACC_EMAIL";
        final String password = "YOUR_MINDSDB_ACC_PASSWORD";

        Connection connection = null;
        Statement prediction = null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(host, username, password);
            System.out.println("Connection to the database created successfully");

            String query = "SELECT t.`Date of Order`, t.`Item Code`, t.`Store Code`, t.District, s.sales, s.sales_confidence, s.sales_min, s.sales_max, t.State FROM files.Sales as t JOIN mindsdb.sales_predictor AS s ORDER BY t.`Date of Order` LIMIT 5;";
            prediction = connection.createStatement();
            ResultSet rs = prediction.executeQuery(query);

            while (rs.next()) {
                int sales = rs.getInt("sales");
                float confidence = rs.getFloat("sales_confidence");
                float sales_min = rs.getFloat("sales_min");
                float sales_max = rs.getFloat("sales_max");
                String date = rs.getString("Date of Order");
                String storeCode = rs.getString("Store Code");
                String itemCode = rs.getString("Item Code");
                String district = rs.getString("District");
                String state = rs.getString("State");

                System.out.println("\n\n Date: " + date + "\n Store Code: " + storeCode + "\n Item Code: " + itemCode
                        + "\n District: " + district + "\n State: " + state + "\n Sales: " + sales + "\n Confidence: "
                        + confidence + "\n Max Sales: " + sales_max + "\n Min Sales: " + sales_min);
            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("An error occurred. Please try again!" + e);
        }
    }
}

We can understand what the code does with the summary given below.

The code imports necessary packages for establishing a connection to a MySQL database and performing SQL operations.
It establishes a connection to the MindsDB Cloud MySQL database using the provided host, username, and password.
A SQL query is executed to fetch batch prediction results from the Sales table and sales_predictor model joined based on a condition, with results ordered by the Date of Order column and limited to 5 records.
The fetched batch prediction results, including various attributes such as sales, confidence, minimum sales, maximum sales, date, store code, item code, district, and state, are printed to the console.

Note: Don't forget to replace the username and password strings in all of the code snippets above with your own MindsDB Cloud account credentials. If you don't have a MindsDB Cloud account, then you can create one here.

Conclusion

In this tutorial, you learnt how to predict sales for medium manufacturing units using MindsDB with Java. You explored how to set up a Java project in Eclipse, create a connection to MindsDB Cloud, fetch table data, create a predictor model, check the status of the model, and make single and batch predictions.

The next thing you can try to do on top of it is to modify the code and enable user input values from the console to be passed onto the query which will used to predict the sales value accordingly.

Another thing to note here is that MindsDB has already launched several SDKs for different platforms like JavaScript, Python, etc. Feel free to explore them as well.

Lastly, before you leave this page, please leave your suggestions, if any, in the comment box and don't forget to drop a Like.

Introducing MindsDB Playground: Your all-in-one MindsDB Companion App

Rutam Prita Mishra — Tue, 06 Jun 2023 07:47:20 +0000

Introduction

Machine Learning has become the need of the hour as the technologies widely depend on leveraging data to gain insights and make precise decisions. But developing and utilizing machine learning models is a tough task that is quite time-consuming and requires expertise in programming, algorithms and data analysis. So, it has become necessary now to reduce these underlying efforts and utilize the power of AutoML in abundance.

In such a case, MindsDB serves as a revolutionizing tool in the world of AutoML. MindsDB is an open-source, automated machine learning (AutoML) framework that works as an AI layer on top of your existing databases and allows you to build, train, and deploy predictive models without writing any code. It uses its underlying candidate models that are robust and precise and can easily identify the most relevant features in a dataset to accurately predict the target values.

MindsDB Playground is a web application with a simple and user-friendly interface that can be used by users to interact with different applications powered by MindsDB. The application is built using the Node Express platform and the UI is powered by HTML, CSS and JavaScript. This website lists tons of apps under NLP (Natural Language Processing) and Prediction Model (Classification, Regression and Timeseries) categories for the users to try out the effectiveness of MindsDB in real-world scenarios.

This blog post will provide a comprehensive guide to the MindsDB Playground, discussing its features, applications, and how to use it.

Application Flow

The flow of the application begins when a user browses the application in a web browser. The user can then submit a request to the server, which is then processed by the server-side code to generate the appropriate response. The response or the error, if any, is then sent back to the client side and is displayed to the user in the web browser.

Now let us briefly understand how the client-side and server-side functions interact with each other to retrieve the desired result.

Client-Side

The client-side code collects the user input, sends a request to the server, and finally displays the result to the user.

When the webpage loads, the user can choose to interact with the application they want. They have to simply pass the input in textarea and then submit the form on the webpage. This invokes the handleFunction method. This function first prevents the default form submission behaviour, which would cause the page to refresh. It then retrieves the user input from the input textarea and clears it out on the webpage for the next run.

You can find a snippet of the HTML form that is used on the webpage below.

<form class="home-form" onsubmit="handleFunction(event)">
              <textarea
                id="functionInput"
                required="true"
                placeholder="Paragraph Here"
                class="home-textarea textarea"
              ></textarea>
              <div class="home-radio-buttons">
                <h1 class="home-text17">Select Engine:</h1>
                <input
                  type="radio"
                  id="functionOpenAI"
                  name="functionEngine"
                  value="OpenAI"
                  required=""
                  title="OpenAI"
                  class="home-open-a-radio"
                />
                <label class="home-open-a-label">OpenAI</label>
                <input
                  type="radio"
                  id="functionHuggingFace"
                  name="functionEngine"
                  value="HuggingFace"
                  required=""
                  title="HuggingFace"
                  class="home-hugging-face-radio"
                />
                <label class="home-hugging-face-label">Hugging Face</label>
              </div>
           <button id="findFucntion" type="submit" class="home-view02 button">
                Execute Function
              </button>
            </form>

                         <!-- Result Div Below -->

            <div class="home-result morph" id="functionDiv">
              <button class="home-button02 button" title="Close">
                <svg viewBox="0 0 1024 1024" class="home-icon22">
                  <path
                    d="M810 274l-238 238 238 238-60 60-238-238-238 238-60-60 238-238-238-238 60-60 238 238 238-238z"
                  ></path>
                </svg>
              </button>
              <p class="home-text18" id="functionResult"></p>
            </div>

The client-side code also displays a loading screen while processing this request to keep the user informed. This is simply achieved by setting the display style property of the loading-screen element to block.

The client-side code makes a POST request to the server's /findFunctionResult endpoint with a JSON payload that contains the user input and any other required details such as the selectedEngine. The fetch API is used to make this request with the appropriate headers and body.

Find the snippet for the handleFunction() method below as an example.

function handleFunction(event) {
  event.preventDefault();
  const query= document.getElementById("fucntionInput").value;
  const resultDiv = document.getElementById("functionResult");

  // Clear the input field
  document.getElementById("fucntionInput").value = "";

  // Loading Screen
  document.getElementById("loading-screen").style.display = "block";

  const engines = document.getElementsByName("functionEngine");

  const selectedEngine = Array.from(engines).find(
    (engine) => engine.checked
  )?.value;

  const functionCloseButton = document.querySelector(".home-button02");
  const functionDiv = document.querySelector("#fucntionDiv");

  functionCloseButton.addEventListener("click", () => {
    functionDiv.style.display = "none";
  });

  // Send a POST request to /findFunctionResult endpoint
  try {
    fetch("/findFunctionResult", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ query, selectedEngine }),
    })
      ...continued

The server then responds with a JSON payload containing either the desired result or any error that occurred. The client-side code analyzes the response and checks for errors, if any. In case there is no error, it displays the result to the user by setting the innerHTML property of the functionResult element with a formatted string of the result. The loading-screen is not visible anymore as its display property is set to none now and instead, the functionDiv is displayed containing the result.

Here is the ...continued code from the above snippet that sets the result back to the user.

.then((response) => response.json())
      .then((data) => {
        // Display the prediction
        if (!data.error) {
          resultDiv.innerHTML =
            "The result is: <br/><br/>" +
            data.result +
            "<br/><br/> Powered by " +
            data.selectedEngine;
          document.getElementById("loading-screen").style.display = "none";
          document.getElementById("functionDiv").style.display = "block";
        } else {
          resultDiv.innerHTML =
            "We are caught in the middle of an error. Please try Again!";
          document.getElementById("loading-screen").style.display = "none";
          document.getElementById("functionDiv").style.display = "block";
        }
      })
      .catch((error) => {
        document.getElementById("loading-screen").style.display = "none";
        alert("An error occurred while summarizing the text");
        throw error; // Throwing the error
      });
  } catch (error) {
    document.getElementById("loading-screen").style.display = "none";
    alert("An error occurred while summarizing the text");
  }
}

In case of an error during the process, the error message is set in the functionResult element and is shown to the user instead of the result after hiding the loading-screen .

There is also a Close button in the functionDiv element. The client-side code attaches an event listener to it so that the users can close this element after viewing the result.

Server-Side

The server side handles the analysis or prediction/forecasts based on engines like OpenAI or HuggingFace or the historical data. The server provides an HTTP endpoint /findFunctionResult that accepts a POST request containing a JSON payload with the user input. It then uses this input to query the respective underlying model and returns a JSON response. In case of an error, it returns an error message instead of the result.

Here is a snippet of the /findFunctionResult endpoint from the server-side app.js file.

app.post("/findFunctionResult", async (req, res) => {
  const inputText = req.body.inputText;
  const selectedEngine = req.body.selectedEngine;

  try {
    // Call the function from mindsdb.js
    const result = await mindsdb.executeMindsDBQuery(query, selectedEngine);
    res.send({ result, selectedEngine });
  } catch (error) {
    logger.error("Error extracting result: ", error);
    res
      .status(500)
      .send({ error: "An error occurred while extracting result." });
  }
});

Applications

The MindsDB Playground includes several applications that use OpenAI or HuggingFace or LightWood engine to perform automated data analysis or predictions. We will be discussing each of these applications below in detail.

NLP Models

The MindsDB Playground App features eight NLP applications that are powered by either the OpenAI engine or the HuggingFace Engine. Let's discuss each of them one by one below.

Behind the scenes, there's a handler function on the server side that interacts with the MindsDB Cloud, executes the required query and then returns the result. Find the snippet of the code below.

async function executeMindsDBQuery(query, selectedEngine) {
  let retries = 3;
  const retryDelay = 1000;
  let modelName;
  if (selectedEngine === "OpenAI") {
    modelName = process.env.MINDSDB_OA_MODEL_NAME;
  } else if (selectedEngine === "HuggingFace") {
    modelName = process.env.MINDSDB_HF_MODEL_NAME;
  }

  while (retries > 0) { //Retries upto 3 times in case of an error
    try {
      const escapedQuery = query.replace(/"/g, ""); // Escape double quotes
      const text = `SELECT responseColumn FROM ${modelName} WHERE label="${escapedQuery}"`; // SQL query statement to be executed
      const response = await MindsDB.SQL.runQuery(text);
      if (!response.rows) {
        throw new Error("Invalid response from MindsDB");
      }
      return response.rows; //Returns the response
    } catch (error) {
      logger.error(`Error executing query: ${query}`, error);
      retries--;
      if (retries === 0) {
        throw new Error("Maximum number of retries reached");
      }
      await new Promise((resolve) => setTimeout(resolve, retryDelay)); // Waits for 1 second before retrying
    }
  }
}

Some important parameters to note here are as follows:

query: It contains the user input text.

escapedQuery: We escape any double quotes present in the input text so that SQL can parse it easily without any errors.

modelName: It is selected based on the user selection retrieved from the selectedEngine parameter.

text: It contains the SELECT statement that needs to be executed.

retries: The function is designed to retry 3 times in case of an error to make the functionality somewhat fail-safe.

retryDelay: The duration between each retry in case of a failure, which is set to 1 second by default.

The first 4 parameters will change as per the user input and the specific application that they are trying to run.

Text Summarization

The Text Summarization application allows users to summarize long texts into shorter versions. Users can input a long text into the app, select the NLP engine of their choice (OpenAI or HuggingFace), and get a summarized version of the text.

The 4 parameters for the Summarize Text App will be as follows.

if (selectedEngine === "OpenAI") {
  summaryModelName = process.env.MINDSDB_OA_SUMMARY_MODEL_NAME;
} else if (selectedEngine === "HuggingFace") {
  summaryModelName = process.env.MINDSDB_HF_SUMMARY_MODEL_NAME;
}

const escapedMessage = summary.replace(/"/g, "");
const text = `SELECT summary FROM ${summaryModelName} WHERE text="${escapedMessage}"`;
const summaryResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can provide a summary of the input texts.

For the OpenAI engine, we can create a model with the statement below.

Create Model openai_article_summarizer
PREDICT summary
USING
engine = 'openai',
model_name = 'gpt-4',
min_tokens = 45,
max_tokens = 200,
prompt_template = 'Provide a short and informative
summary of the following text. text:{{text}}';

For the HuggingFace engine, we can create a model with the statement below.

CREATE MODEL hf_article_summarizer                           
PREDICT summary                           
USING
    engine = 'huggingface',
    task = 'summarization',
    model_name = 'sshleifer/distilbart-cnn-12-6',
    input_column = 'text',
    min_output_length = 10,
    max_output_length = 200;

Sentiment Analysis

The Sentiment Analysis application allows users to analyze the sentiment of a text. Users can input text into the textarea in the app, select the NLP engine of their choice (OpenAI or HuggingFace), and get the sentiment of the text i.e., Positive, Negative, or Neutral.

The 4 parameters for the Sentiment App will be as follows.

if (selectedEngine === "OpenAI") {
  sentimentModelName = process.env.MINDSDB_OA_SENTIMENT_MODEL_NAME;
} else if (selectedEngine === "HuggingFace") {
  sentimentModelName = process.env.MINDSDB_HF_SENTIMENT_MODEL_NAME;
}

const text = `SELECT sentiment FROM ${sentimentModelName} WHERE text="${inputText}"`;
const sentimentResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can provide the sentiment of the input texts.

For the OpenAI engine, we can create a model with the statement below.

CREATE MODEL openai_sentiment_analyzer
PREDICT sentiment
USING
engine = 'openai',
model_name = 'gpt-4',
prompt_template = 'Describe the sentiment of the text
strictly as "positive", "neutral", or "negative".
"I love the product":positive
"It is a scam":negative
"{{text}}.":';

For the HuggingFace engine, we can create a model with the statement below.

CREATE MODEL hf_sentiment_analyzer                           
PREDICT sentiment                           
USING
    engine = 'huggingface',
    task = 'text-classification',
    model_name = 'cardiffnlp/twitter-roberta-base-sentiment',
    input_column = 'text',
    labels = ['negative','neutral','positive'];

Translations

The Translations application allows users to translate text from one language to another. The app supports three translations, including English to French, French to English and Spanish to English. Users can input text in any of the supported languages, select the translation choice and the NLP engine of their choice (OpenAI or HuggingFace), and get back the translated text.

The 4 parameters will change as follows for the Translation App.

if (selectedEngine === "OpenAI") {
  if (choice === "Fr-EN") {
    translationModelName = process.env.MINDSDB_OA_FREN_MODEL_NAME;
  } else if (choice === "Es-EN") {
    translationModelName = process.env.MINDSDB_OA_ESEN_MODEL_NAME;
  } else {
    translationModelName = process.env.MINDSDB_OA_ENFR_MODEL_NAME;
  }
} else if (selectedEngine === "HuggingFace") {
  if (choice === "Fr-EN") {
    translationModelName = process.env.MINDSDB_HF_FREN_MODEL_NAME;
  } else if (choice === "Es-EN") {
    translationModelName = process.env.MINDSDB_HF_ESEN_MODEL_NAME;
  } else {
    translationModelName = process.env.MINDSDB_HF_ENFR_MODEL_NAME;
  }
}

const text = `SELECT translation FROM ${translationModelName} WHERE text="${inputText}"`;
const translationResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train 3 models using MindsDB Cloud that can translate the input texts.

For the OpenAI engine, we can create the models with the statements below.

CREATE MODEL openai_engfr_translator  //English-French Model
PREDICT translation
USING
    engine = 'openai',
    model_name = 'gpt-4',
    prompt_template = 'Translate the following text in English to French. text:{{text}}';

-------------

CREATE MODEL openai_freng_translator   //French-English Model
PREDICT translation
USING
    engine = 'openai',
    model_name = 'gpt-4',
    prompt_template = 'Translate the following text in French to English. text:{{text}}';

-------------

CREATE MODEL openai_speng_translator   //Spanish-English Model
PREDICT translation
USING
    engine = 'openai',
    model_name = 'gpt-4',
    prompt_template = 'Translate the following text in Spanish to English. text:{{text}}';

For the HuggingFace engine, we can create the models with the statements below.

CREATE MODEL hf_enfr_translator        //English-French Model
PREDICT translation
USING
engine = 'huggingface',
task = 'translation',
model_name = 't5-base',
input_column = 'text',
lang_input = 'en',
lang_output = 'fr';

-------------------

CREATE MODEL hf_fren_translator        //French-English Model
PREDICT translation
USING
engine = 'huggingface',
task = 'translation',
model_name = 'Helsinki-NLP/opus-mt-fr-en',
input_column = 'text',
lang_input = 'fr',
lang_output = 'en';

--------------------

CREATE MODEL hf_spen_translator        //Spanish-English Model
PREDICT translation
USING
engine = 'huggingface',
task = 'translation',
model_name = 'Helsinki-NLP/opus-mt-es-en',
input_column = 'text',
lang_input = 'es',
lang_output = 'en';

Spam Detection

The spam detection app detects whether a given input text is spam. This app can help determine if an email or message is a scam. The app uses either the HuggingFace or the OpenAI engine based on the user's choice for spam detection.

The 4 parameters for the Spam Detection App will be as follows.

if (selectedEngine === "OpenAI") {
  spamModelName = process.env.MINDSDB_OA_SPAM_MODEL_NAME;
} else if (selectedEngine === "HuggingFace") {
  spamModelName = process.env.MINDSDB_HF_SPAM_MODEL_NAME;
}

const text = `SELECT type FROM ${spamModelName} WHERE text="${message}"`;
const spamResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can detect spam from the input texts.

For the OpenAI engine, we can create a model with the statement below.

CREATE MODEL openai_spam_detector
PREDICT type
USING
    engine = 'openai',
    model_name = 'gpt-4',
    prompt_template = 'Determine and Label the given text as "SPAM" or "HAM". 
                       "You have won 12 crore lottery. Click here to claim" : SPAM
                       "The team scrum call has been shifted to 8PM today. Kindly join on time." : HAM
                       "{{text}}" : ';

For the HuggingFace engine, we can create a model with the statement below.

CREATE MODEL mindsdb.hf_spam_detector
PREDICT type
USING
engine = 'huggingface',
task = 'text-classification',
model_name = 'mariagrandury/roberta-base-finetuned-sms-spam-detection',
input_column = 'text',
labels = ['HAM', 'SPAM'];

JSON Extraction

The JSON extraction app extracts JSON data in the defined format from a given input text. JSON (JavaScript Object Notation) is a lightweight data-interchange format. The app can be helpful for developers to extract meaningful data in the form of a JSON from a given string. The app uses the OpenAI engine for JSON extraction.

The 4 parameters for the JSON Extraction App are mentioned below.

if (selectedEngine === "OpenAI") {
  jsonModelName = process.env.MINDSDB_OA_JSON_MODEL_NAME;
}

const text = `SELECT json FROM ${jsonModelName} WHERE synopsis="${message}"`;
const jsonResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can extract data in a JSON format from the input texts.

For the OpenAI engine, we can create a model with the statement below.

CREATE MODEL openai_movie_json_extractor
PREDICT json
USING
    engine = 'openai',
    model_name = 'gpt-4',
    json_struct = {
        'Movie': 'Movie Name',
        'Director': 'Director',
        'Starcast': 'Name of the stars or actors.',
        'Plot': 'Short plot description about the movie in about 30 words.'
    },
    input_text = 'synopsis';

Question Answering

The question-answering app attempts to answer any question the user has based on the input text. The app uses the OpenAI engine for this. The model is trained such that it can answer questions without context.

The 4 parameters for the Question Answering App will be as follows.

if (selectedEngine === "OpenAI") {
  qnaModelName = process.env.MINDSDB_OA_QNA_MODEL_NAME;
}

const text = `SELECT answer FROM ${qnaModelName} WHERE question="${message}"`;
const qnaResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can answer the question in the input text.

For the OpenAI engine, we can create a model with the statement below.

CREATE MODEL openai_question_answerer
PREDICT answer
USING
    engine = 'openai',
    model_name = 'gpt-4',
    prompt_template = 'Answer the following question. text:{{question}}.';

ESG Labelling

The ESG labelling app determines whether a given input text is environmentally, socially, or governance focused. ESG stands for Environmental, Social, and Governance, and it is a set of standards used to measure the sustainability and ethical impact of an investment. This app can help determine if a company or an investment is ESG focused. The app uses the HuggingFace engine for ESG labelling.

The 4 parameters for the ESG Labelling App will be as follows.

if (selectedEngine === "HuggingFace") {
  esgModelName = process.env.MINDSDB_HF_ESG_MODEL_NAME;
}

const text = `SELECT label FROM ${esgModelName} WHERE text="${message}"`;
const esgResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can label ESG types properly based on the input texts.

For the HuggingFace engine, we can create a model with the statement below.

CREATE MODEL mindsdb.hf_esg26_labeller
PREDICT label
USING
engine = 'huggingface',
task = 'text-classification',
model_name = 'yiyanghkust/finbert-esg',
input_column = 'text';

Industry Identification

The industry identification app attempts to identify the industry a company belongs to based on the input text. This app can be helpful for investors to know which industry a company belongs to. The app uses the HuggingFace engine for industry identification.

The 4 parameters for the Industry Identification App are as follows.

if (selectedEngine === "HuggingFace") {
  industryModelName = process.env.MINDSDB_HF_INDUSTRY_MODEL_NAME;
}

const text = `SELECT label FROM ${industryModelName} WHERE text="${message}"`;
const industryResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can identify the respective industry from the input texts.

For the HuggingFace engine, we can create a model with the statement below.

CREATE MODEL mindsdb.hf_industry_labeller
PREDICT label
USING
engine = 'huggingface',
task = 'text-classification',
model_name = 'sampathkethineedi/industry-classification',
input_column = 'text';

Prediction Models

MindsDB also offers to train robust predictor models that can be used to predict an outcome. These models can be prepared using existing data in the database and don't necessarily need any coding skills or expertise in programming. The models here work in a similar way as the above NLP models but with a slight change. They don't require any modelName or selectedEngine parameters.

Mobile Price Prediction

The mobile price prediction app predicts the price of a mobile device based on its input features such as RAM, battery, etc. The app uses MindsDB's regression predictor model to predict accurate pricing.

The 2 parameters for the Mobile Prediction app are as follows.

const text = `Select Price from ${priceModelName} where Brand="${request.body.brand}" AND Model="${request.body.model}" AND Storage=${request.body.storage} AND RAM=${request.body.ram} AND ScreenSize=${request.body.screen} AND BatteryCapacity=${request.body.battery} AND Camera=${request.body.camera};`;

const priceResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can predict the price of a phone based on user-provided input specs.

We can create a regression predictor model for this with the statement below.

Create Predictor mindsdb.mobile_price_predictor
FROM files
(Select * from Mobiles)
Predict Price;

Ethereum Price Forecast

The Ethereum Price Forecast app predicts the future price of Ethereum, a cryptocurrency. The app uses MindsDB's time-series predictor model to forecast the price of Ethereum on the next day of the user-provided date.

The 2 parameters for the Ethereum Price Prediction App will be as follows.

const text = `Select EP.Close from ${ethModelName} as EP JOIN files.Ethereum as E WHERE E.Date > '${request.body.date}' LIMIT 1;`;

const ethPriceResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can forecast the Ethereum price for the next day of the date given by the user.

We can create a time-series model for this with the statement below.

CREATE PREDICTOR mindsdb.ethereum_price_predictor
FROM files
(Select * from Ethereum)
PREDICT Close
ORDER BY Date
WINDOW 150
HORIZON 65;

Water Potability Prediction

The water potability prediction app predicts whether a given water sample is safe for human consumption or not. The app uses MindsDB's classification predictor model to determine water portability based on the user's water composition parameters.

The 2 parameters for the Water Potability App will be as follows.

const text = `Select Potability from ${waterModelName} where ph=${request.body.ph} AND Hardness=${request.body.hardness} AND Solids=${request.body.solids} AND Chloramines=${request.body.chloramines} AND Sulfate=${request.body.sulfate} AND Conductivity=${request.body.conductivity} AND Organic_carbon=${request.body.carbon} AND Trihalomethanes=${request.body.trihalomethanes} AND Turbidity=${request.body.turbidity};`;

const waterResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can classify the water potability based on the water composition from the input texts.

We can create a classification model for this with the statement below.

CREATE PREDICTOR mindsdb.water_potability_predictor
FROM files 
(SELECT * FROM Water)
PREDICT Potability;

Tesla Stock Price Prediction

The Tesla stock price prediction app predicts the future price of Tesla's stock. The app again uses MindsDB's time-series predictor model to forecast the stock price of Tesla on the next day of the user-given date.

The 2 parameters for the Tesla Stock Prediction App will be as follows.

const text = `Select TP.Close from ${teslaModelName} as TP JOIN files.Tesla as T WHERE T.Date > '${req.body.date}' LIMIT 1;`;

const priceResponse = await MindsDB.SQL.runQuery(text);

Now, we need to train a model using MindsDB Cloud that can forecast the Tesla Stock price for the next day of the date given by the user.

We can create a time-series model for this with the statement below.

CREATE PREDICTOR mindsdb.tesla_stocks_predictor
FROM files
(Select * from Tesla)
PREDICT Close
ORDER BY Date
WINDOW 150
HORIZON 65;

App Features

The MindsDB Playground App has several features that make it a useful tool for users of all levels to get started with MindsDB. Some of these salient features include:

Easy-to-use Interface: The app comes with a user-friendly interface that makes it easy for users to interact with a variety of apps powered by MindsDB.

Free-to-use: The app is free to use and will always stay that way.

Various NLP Models: The app has eight NLP applications powered by the OpenAI engine or the HuggingFace engine. These applications include Text Summarization, Sentiment Analysis, Translations (Eng-Fr, Fr-Eng, Es-Eng), Spam Detection, JSON Extraction, Question Answering, ESG Labelling, and Industry Identification.

Various Prediction Models: The app also offers four prediction applications, including Mobile Price Prediction, Ethereum Price Prediction, Water Potability Prediction, and Tesla Stock Price Prediction. These 4 apps cover all the different types of prediction models i.e., Regression Type, Classification Type and Timeseries Type.

Mobile Responsive: The Playground application is designed to be easily usable on various types of devices including, mobile phones (both in portrait and landscape modes), tablets, laptops and desktops.

SQL Cheat Sheets: In case any new user wonders how to train the models that are present on the Playground application themselves on MindsDB Cloud, they can simply use the Download Cheat Sheet option present at the top left corner of each of the application panels.

Cloud Hosting: The Playground App has been deployed live using the DigitalOcean App Platform which is very reliable and fail-safe.

Custom Domain: The Playground App uses a custom domain to add a sense of branding and credibility among its users and is also secured with SSL i.e. you can access it over HTTPS.

Demo

The app has been deployed and is live on MindsDB Playground.

The GitHub repository for the project can be found here.

Future Scopes

The Playground App is currently under early development and the recent release can be considered as a version 1 release. So, like any other app, it has many scopes of improvement. However, some of the major ones are listed out below.

More Sample Apps
Faster Response Times
Session Cache
Sample Dataset Downloads
Modern UI Framework Implementation

Conclusion

Overall, the MindsDB Playground App provides an excellent opportunity to explore the capabilities of natural language processing and predictive analytics that are powered by MindsDB. The app's user interface is user-friendly, and the app is easy to use. Users can choose between different NLP and predictive analytics models and select the one that they want to use. The app can be useful for new users, potential customers, developers and anyone interested in exploring the robust and accurate solutions provided by MindsDB.

Lastly, feel free to drop any suggestion or feedback about the App in the comments below and don't forget to show some appreciation to this article if you had a great time reading it.

References

MindsDB Docs
MindsDB JS SDK
Figma
DigitalOcean App Platform
GoDaddy Domain Registry

This App was originally made for the @MindsDB x Hashnode Hackathon.

Forecast Tesla Stock Prices using MindsDB

Rutam Prita Mishra — Fri, 21 Oct 2022 20:25:17 +0000

Introduction

If we talk about AutoML, then one of the most amazing open-source products that comes to my mind is MindsDB. MindsDB enhances the existing databases and modifies the tables in them to act as AI Tables that are able to train robust Predictior models using the data that exists.

All this without the hassle of learning how to code such models in Python or dealing with the dependencies or maintaining them at a later stage. With MindsDB, you can use simple SQL-like statements and get accurate predictions in a click.

In this tutorial, we will learn how we can forecast the stock prices of Tesla using MindsDB. You can download the required dataset from here which we will use in this tutorial.

Importing Data into MindsDB Cloud

We will use MindsDB Cloud to complete this tutorial. Make sure you follow all the steps below to complete training a Predictor Model.

Step 1: Log in to the MindsDB account with your credentials. You can also sign up for a new account and it's absolutely free.

Step 2: Once you're signed in, the MindsDB Cloud console opens up. Now click on the Add data button from the top right corner. This should open up the Select your datasource page.

Step 3: Now select Files from the top tab instead of Databases and then hit the Import File section.

Step 4: Now browse and open the .CSV file that we just downloaded above, provide a name for the table in the Table Name field and then hit the Save and Continue button to create it.

Step 5: After the Table is created, the control takes us back to the MindsDB Cloud console. You will find two simple queries in the Query Editor now. Let's execute them one by one to confirm whether the data import was successful or not.

SHOW TABLES FROM files;

Find the name of the table we created in the list of returned table names.

SELECT * FROM files.Tesla LIMIT 10;

This should return 10 data records from the table Tesla.

This confirms that we have the correct data records with us and now we can move on to the next part of this tutorial.

Creating a Predictor Model

Creating a Predictor model using MindsDB is as easy as just firing up a simple SQL query. So, let's see how easily we can create this model.

Step 1: MindsDB provides a CREATE PREDICTOR that will come in handy now as we want to create and train a new model using the dataset, we have with us. You can find the query below.

CREATE PREDICTOR mindsdb.tesla_predictor     (Name of the Predictor)
FROM files
(SELECT * FROM Tesla)              (Name of the Table)
PREDICT Close                      (Target Value)
ORDER BY value_date                (Ordering data based on Date)
WINDOW 120                         (Model picks up last 120 records)
HORIZON 60;                        (To Forecast the future 60 outcomes)

The query should return a successful status.

Step 2: The model can take some time to be ready. Meanwhile, we can check its status using the command below.

SELECT status
FROM mindsdb.predictors
WHERE name = 'tesla_predictor';

If the status is complete, then the model is ready. However, if the status is generating or training, then wait for a while until you get the status as complete.

Note: This kind of Predictor is an advanced one as we will be using it to predict a future outcome value based on the historical data that we have in the dataset. Such kind of predictions fall under the Timeseries category.

Understanding the Predictor Model

As the Predictor model is now ready, let us first understand what lies under the hood. So, MindsDB provides us with three ways to describe our model to retrieve further insights.

By Features
By Model
By Model Ensemble

By Features

If you're interested to find out the roles that each of the columns serve for the model or the encoders used on them, then you can try to describe the predictor based on it feature.

DESCRIBE mindsdb.tesla_predictor.features;

By Model

You can choose to describe it by model if you want to figure out the underlying candidate models that were used during the training along with the one that was finally selected for the Predictor. The selected candidate will have the value 1 in its selected column.

DESCRIBE mindsdb.tesla_predictor.model;

By Model Ensemble

If you're interested to further deep dive and find out how the candidate model was selected, then you can try describing the predictor with ensemble. This returns a JSON result with all the parameters that helped to determine the best candidate model out of the available ones.

DESCRIBE mindsdb.tesla_predictor.ensemble;

We have now completed understanding the model we just trained. Time to start forecasting things now!

Forecasting Target Values

As usual, MindsDB also provides simple SQL statements to predict/forecast values from the model. So, let's figure out how we can forecast values.

Before we proceed, we need to understand the basic scenario here. So, we have a dataset that lists out the closing stock values of Tesla over a period of time. Now, with this predictor model, we will try to forecast the closing value after the last record available in the dataset. We can do that by using another keyword LATEST for the dates now.

The query will be simple SELECT type where we will join the predictor model along with the data table and fetch the Forecasts.

SELECT T.value_date as date,
       T.Closing as Forecast,
       Closing_explain
FROM mindsdb.tesla_predictor as T
JOIN files.Tesla as P
WHERE P.value_date > LATEST
LIMIT 60;

This query should return us with the forecasts of up to 2 months (60 Days) after the last date that was available in the dataset. The last available date in this dataset was 16-09-2022 and 60 days from that day ends at 14-11-2022 which is the last forecast date in the result table.

Note: You can forecast the values of further future dates by simply increasing the value of HORIZON to more than 60 days. To increase the accuracy, you can also opt to increase the value of WINDOW to more than 120 days.

Conclusion

We have now reached the end of this tutorial. Let us summarize all the tasks we did above as a list below.

We created a MindsDB Cloud Account.
We imported a dataset into MindsDB Cloud.
We created and trained a Predictor Model for Timeseries Forecast.
We gained insights about the model using DESCRIBE.
We forecasted the Tesla Stock Prices for a future date.

Now, it's time for all of you to create your own models and try forecasting some interesting values. If you need some suggestions, then I would love to drop some ideas like Bitcoin Value Forecast, Ethereum Value Forecast, Gold Price Forecast, etc. Be creative, train something funky and share it with the community.

Lastly, before you close this page, don't forget to drop a LIKE if you liked this tutorial and also let me know if you have any feedback. You can also suggest something specific you wish to learn about MindsDB and I will try to cover that up as well.