DEV Community: Ravi Agheda

Setting Up Llama 3.2 Locally with Ollama and Open WebUI: A Complete Guide

Ravi Agheda — Wed, 02 Apr 2025 08:56:57 +0000

We'll use Ollama as tool for setting up the llama3.2 model in our local device.

Requirements for Llama3.2

1 Install Ollama

Download the Ollama from here: https://ollama.com/ and install it locally. It should be very easy to install just one click.
It'll automatically setup the CLI path, if not please explore the documentation.

you can explore the models from supported by ollama here
https://ollama.com/search

2 Setup the model, in our case Llama3.2

ollama run llama3.2:latest

It should download the modal and spin it up in your terminal, you can have chat directly from the terminal

Once we're good that part, now it's time to setup the UI ( like chatGPT )

3 Setup Open-WebUI

Open WebUI is an extensible, self-hosted AI interface that adapts to your workflow, all while operating entirely offline.

Checkout their docs from here: https://docs.openwebui.com/

we'll use the docker to setup the interface locally, run this command

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Once docker is up successfully go to port 3000 and you're good to go.

You can run other models and change them directly from the open webui interface.

Enjoy....

Setting Up Llama 3.2 Locally with Ollama and Open WebUI: A Complete Guide

Ravi Agheda — Wed, 02 Apr 2025 08:51:08 +0000

We'll use Ollama as tool for setting up the llama3.2 model in our local device.

Requirements for Llama3.2

1 Install Ollama

you can explore the models from supported by ollama here
https://ollama.com/search

2 Setup the model, in our case Llama3.2

ollama run llama3.2:latest

It should download the modal and spin it up in your terminal, you can have chat directly from the terminal

Once we're good that part, now it's time to setup the UI ( like chatGPT )

3 Setup Open-WebUI

Open WebUI is an extensible, self-hosted AI interface that adapts to your workflow, all while operating entirely offline.

Checkout their docs from here: https://docs.openwebui.com/

we'll use the docker to setup the interface locally, run this command

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Once docker is up successfully go to port 3000 and you're good to go.

You can run other models and change them directly from the open webui interface.

Enjoy....

Creating a GitHub Action for Deploying to Google Cloud Run Using Docker

Ravi Agheda — Sun, 31 Dec 2023 06:40:47 +0000

Setup a new Service Account Create a new service account for our cloud run and deployment process, in order to create a new service account go to IAM & Admin > Service Account > Create New Service Account Add listed roles to the new service account while creation.

Artifact Registry Writer
Cloud Run Admin
Editor
Service Account User
Storage Admin

Create and save the email to GitHub secrets as SERVICE_ACCOUNT_EMAIL and key (JSON) as GCP_SA_KEY we'll need it for the YML file.

Setup Artifact Registry Create a new artifact registry by visiting Artifact Registry > Create Repository Keep the Docker format for the app deployment select your region.

Save registry name and region under github secrets as ARTIFACTION_REGISTRY_NAME and REGION

We're almost there! In order to enable the apis for cloud run, just visit the cloud run via google cloud console and it should auto enable all the required apis for us.

Set / Confirm the Github Secrets

PROJECT_ID - Id of the google cloud project
REGION - Make sure to keep the region that we used while creating the artifact registry or update the yml file as per you need
DEV_APP_NAME - App name that you want to use for the cloud run service name, registry image name and cloud build name ( if build is being used )
ARTIFACT_REGISTRY_NAME - Artifact Registry name
SERVICE_ACCOUNT_EMAIL - Service account email that we created earlier

Follow up this YML File.

Note: Current version of yml file use docker based deployment instead of cloud build If you want to use cloud build instead of docker push, then enable cloud build from google cloud console and uncomment line 81 to 84 to 86, also comment out line 76 to 82

name: Build and Deploy to Google Cloud

on:
  push:
    branches:
      - dev
  workflow_dispatch:


# SERVICE ACCOUNT : cloud-run-and-deploy@semiotic-karma-397201.iam.gserviceaccount.com
env:
  PROJECT_ID: ${{ secrets.PROJECT_ID }}
  REGION: ${{ secrets.REGION }}
  APP_NAME: ${{ secrets.DEV_APP_NAME }}
  REGISTRY_NAME: ${{ secrets.ARTIFACT_REGISTRY_NAME }}
  SERVICE_ACCOUNT_EMAIL: ${{ secrets.SERVICE_ACCOUNT_EMAIL }}

jobs:
  build-and-deploy:
    name: Setup, Build, and Deploy
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      # Authenticate with Google Cloud
      - id: "auth"
        uses: google-github-actions/auth@v1.1.1
        with:
          credentials_json: "${{ secrets.GCP_SA_KEY }}"

      # Setup gcloud CLI/SDK
      - name: Set up Cloud SDK
        uses: google-github-actions/setup-gcloud@v1

      - name: Authorize Docker push
        run: gcloud auth configure-docker $REGION-docker.pkg.dev

      - name: Build and tag the docker image
        run: |-
          docker build --build-arg NODE_ENV=dev . --tag $REGION-docker.pkg.dev/$PROJECT_ID/$REGISTRY_NAME/$APP_NAME:$GITHUB_SHA

      - name: Push the image to the Google Artifact Registry (GAR)
        run: |-
          docker push $REGION-docker.pkg.dev/$PROJECT_ID/$REGISTRY_NAME/$APP_NAME:$GITHUB_SHA

      # - name: Build and push the Docker image
      #   run: |-
      #     gcloud builds submit . --tag $REGION-docker.pkg.dev/$PROJECT_ID/$REGISTRY_NAME/$APP_NAME:$GITHUB_SHA

      - name: Deploy
        run: |-
          gcloud run deploy $APP_NAME \
          --region $REGION \
          --image $REGION-docker.pkg.dev/$PROJECT_ID/$REGISTRY_NAME/$APP_NAME:$GITHUB_SHA \
          --platform "managed" \
          --service-account $SERVICE_ACCOUNT_EMAIL \
          --port 80 \
          --quiet

GitHub Action with EC2 using SSH

Ravi Agheda — Fri, 25 Aug 2023 04:52:36 +0000

It's pretty easy to set up GitHub action with AWS EC2 for deployments using SSH key, follow these 3 breakdowns to implement the pipeline.

1. Generate SSH Key



cd ~/.ssh
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Enter file name: "key_name"
ls and list out files of the .ssh folder, you should be seeing "key_name" and "key_name.pub"

Add public key to authroised keys ```sh

cat github-actions.pub >> ~/.ssh/authorized_keys


For detailed information on SSH Key generation process check this reference: https://zellwk.com/blog/github-actions-deploy/

## 2. Set Github Secrets
SSH_PRIVATE_KEY: private key that we created on ec2
HOST_NAME / IP_ADDRESS: Elastic IP or IP of EC2
USER_NAME: user name of the ec2 user.


## 3. Create a branch_name.yml ( for `dev` branch `dev.yml` ) file under .github/workflows

Update the dev to your branch name

```yml


name: Deploy

on:
  push:
    branches: [ dev ]

jobs:
  Deploy:
    name: Deploy to EC2
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2 
      - name: Build & Deploy
        env:
            PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
            HOSTNAME: ${{secrets.SSH_HOST}}
            USER_NAME: ${{secrets.USER_NAME}}

        run: |
          echo "$PRIVATE_KEY" > private_key && chmod 600 private_key
          ssh -o StrictHostKeyChecking=no -i private_key ${USER_NAME}@${HOSTNAME} '

              # Now we have got the access of EC2 and we will start the deploy .
              cd /home/ubuntu/<PROJECT_DIRECTORY> &&
              git checkout dev &&
              git fetch --all &&
              git reset --hard origin/dev &&
              git pull origin dev &&
              sudo npm i &&
              sudo npm run build &&
              sudo pm2 stop ./dist/index.js &&
              sudo pm2 start ./dist/index.js
              '

Gist Ref: https://gist.github.com/raviagheda/c69ae5e884f4490b1af656dbd80c00dd

Enjoy!

If you are here it means you may have enjoyed reading this blog. Just follow me "Ravi Agheda" which will motivate to write more, and contribute to open source. You can make me a coffee☕️ . Small support comes a long way!

DS_Store in git, why ?

Ravi Agheda — Thu, 15 Jun 2023 08:16:12 +0000

Mac user generally face this issue where .DS_Store file gets generated automatically and pops up in the git changes ( unless you've added it in ignore 😅 )

What is DS_Store?

It known as Desktop Services Store and it holds meta information about your folder’s thumbnails, settings, etc.

Why?

These files are created any time you navigate to a file or folder from the Finder on a Mac.

How to get rid of it?

Probably you already know the solution, .gitignore

Thank you for reading the short blog.

Love Mongodb ? Try Tigris db once.

Ravi Agheda — Tue, 18 Apr 2023 05:12:54 +0000

Tigris db is one the best no sql database I came across after the mongodb.

We love mongodb for it's ease of use and features, powered queries easy model setup, complex operations.
But still there are many things we have to handle on our own, i.e. Environment based setup etc.

Whereas Tigris provide native integration for branching enviroments, we can setup the main, staging, dev branch for different database using env config.

In order to get one more step further we have a tigris db to explore. Let's discuss some key points difference of tigris db and mongodb to get more idea around it.

How Tigris differ from MongoDB from the tigris doc

Unlike MongoDB, Tigris follows a modern composable architecture with loosely coupled components. Furthermore, compute is separated from storage, allowing for independent scaling and a more resilient system.

The storage layer in Tigris is built on FoundationDB, and Tigris inherits the strong consistency guarantees, and the scalability of FoundationDB.

Tigris provides automatic database sharding, and shard keys are unnecessary as the data distribution is automatically handled. This ensures true serverless behavior with no painful transition from a non-sharded to a sharded MongoDB cluster.

Tigris' open source Kubernetes-native design allows it to be deployed anywhere in the cloud in the user's account, ensuring that the user is always in control of their data.

Some other differentiating features include global interactive ACID transactions, consistent secondary indexes, and an integrated search platform.

To try the Tigirs database with express app, visit: https://www.tigrisdata.com/
Signup, and create a test app. It'll provide a command set of npm. Create an express app using it and you'll be able to explore the codebase and queries.

Here's a reference of express tigris app: https://github.com/raviagheda/express-tigrisdb

Fun Fact: If we move to tigress db then our stacks will be as follow MEAN will be NEAT, and MERN will be TERN.

If you are here it means you may have enjoyed reading this blog. Just follow me "Ravi Agheda"
which will motivate to write more, and contribute to open source. You can make me a coffee☕️ . Small support comes a long way!

The Art of Debugging: Techniques for Effective Problem-Solving

Ravi Agheda — Sat, 15 Apr 2023 19:33:21 +0000

Debugging is an essential part of the software development process. It's the process of identifying and resolving errors, bugs, or issues that prevent the code from running correctly. However, debugging is often seen as a tedious and frustrating task, and many developers struggle with finding effective techniques to solve problems efficiently. In this blog post, we'll explore some creative and unique techniques that can help developers improve their debugging skills and become more effective problem-solvers.

Divide and Conquer

The divide and conquer approach involves breaking down a problem into smaller, more manageable pieces. This technique is particularly useful when dealing with complex issues that involve multiple components or dependencies. By isolating the problem, developers can focus their efforts on specific areas, reducing the scope of the issue and making it easier to solve. This technique is also useful for identifying the root cause of a problem, which can help prevent similar issues from arising in the future.

Rubber Duck Debugging

Rubber Duck Debugging is a technique that involves explaining the problem to an inanimate object, such as a rubber duck. This technique may sound silly, but it's a useful way to approach problems from a different perspective. By explaining the problem out loud, developers can often identify issues they might have overlooked. This technique is also useful for clarifying the problem to other team members, which can help improve collaboration and communication.

Debugging with Print Statements

Debugging with print statements involves inserting log statements into the code to track the execution flow and identify issues. This technique is particularly useful for tracking down issues that are difficult to reproduce or that occur intermittently. By logging key variables or function calls, developers can gain insights into the behavior of the code and identify areas where issues are occurring. This technique is also useful for gaining a better understanding of how the code is executing, which can help improve overall code quality.

Pair Programming

Pair programming involves two developers working together on the same codebase, sharing ideas and solving problems collaboratively. This technique is particularly useful when dealing with complex issues that require a fresh perspective or expertise in a specific area. By working together, developers can share knowledge, identify issues more quickly, and come up with more creative solutions. Pair programming is also an excellent way to improve team collaboration and communication, which can lead to more effective problem-solving in the long run.

Conclusion

Debugging is a critical skill for developers, but it can also be a frustrating and time-consuming process. By using the creative and unique techniques discussed in this blog post, developers can approach problems from a fresh perspective, improve collaboration and communication, and become more effective problem-solvers. To implement these techniques successfully, it's essential to prioritize clear and concise communication with your team, maintain a detailed record of the debugging process, and be willing to experiment with different methods until you find what works best for you. Remember, the art of debugging is not just about finding and fixing issues; it's also about developing a problem-solving mindset that focuses on continuous improvement and finding creative solutions to complex problems.

How to integrate swagger ui in your node project with auto generation ?

Ravi Agheda — Sat, 04 Mar 2023 11:59:43 +0000

In this blog post, we will look at how to integrate Swagger into a Node.js project using the Swagger UI and Swagger Autogen libraries and output JSON.

Installing Swagger UI and Swagger Autogen
The first step is to install the Swagger UI and Swagger Autogen libraries. We can do this using npm. Open a terminal window and navigate to the root directory of your Node.js project. Then, run the following command:

Swagger is a tool for documenting and testing APIs. It provides an interface for exploring endpoints, testing input and output data, and generating client libraries for different programming languages. In this blog post, we will look at how to integrate Swagger into a Node.js project using the Swagger UI and Swagger Autogen libraries and output JSON.

Installing Swagger UI and Swagger Autogen
The first step is to install the Swagger UI and Swagger Autogen libraries. We can do this using npm. Open a terminal window and navigate to the root directory of your Node.js project. Then, run the following command:

npm install swagger-ui-express swagger-autogen

This will install the Swagger UI and Swagger Autogen libraries in your project.

Setting up Swagger UI
Once the libraries are installed, we need to set up Swagger UI in our Node.js project. Create a new file in your project root directory called swagger.js. This file will contain the Swagger UI setup code.

const swaggerUi = require('swagger-ui-express');
const swaggerDocument = require('./swagger.json');

module.exports = (app) => {
  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
};

This code sets up the Swagger UI middleware for our Express app. The swaggerUi.serve middleware serves the Swagger UI files, and the swaggerUi.setup middleware creates a new route at /api-docs where we can access the Swagger UI.

The swaggerDocument variable is a JSON file that describes the API endpoints, input and output data, and other details about our API. We will create this file later in this blog.

Setting up Swagger Autogen
Now that we have set up Swagger UI, we need to set up Swagger Autogen. This library automatically generates Swagger documentation based on our Express app's route handlers.

Create a new file in your project root directory called swagger-autogen.js. This file will contain the Swagger Autogen setup code.

const swaggerAutogen = require('swagger-autogen')();

const outputFile = './swagger.json';
const endpointsFiles = ['./routes/*.js'];

const config = {
    info: {
        title: 'Blog API Documentation',
        description: '',
    },
    tags: [ ],
    host: 'localhost:3000/api',
    schemes: ['http', 'https'],
};

swaggerAutogen(outputFile, endpointsFiles, config);

This code sets up Swagger Autogen to generate Swagger documentation for our API endpoints. The outputFile variable is the name of the JSON file where the documentation will be saved. The endpointsFiles variable is an array of paths to our Express app's route handler files.

Let me know in the comment, if your swagger requirement is resolved by this blog.

And, You can make me a coffee☕️

Thank you for reading through, Follow me for more content :)

Setup AWS S3 bucket for NodeJS

Ravi Agheda — Sat, 07 Jan 2023 18:11:29 +0000

Amazon Simple Storage Service (S3) is one of the best tool to store the file/media. Let's set it up with nodejs framework.

Setup S3 bucket with public access.
Integrate S3 with NodeJS.

1. Setup S3 bucket with public access.

First thing first, let's create a bucket

Enter the name and Change the region if required, here I'm keeping it Oregon as default.

As I need a public bucket so I'm enabling a ACL and keeping Radio options as it is.

Same as above, uncheck the checkbox in order to make it public.

Keep rest of the options as it is unless required, and hit create bucket button.
Now once bucket is created we would have to update the bucket policy in order to access it as public bucket.

Open a Bucket
Go to permission and scroll down to Bucket Policy, and Edit

{
    "Version": "2008-10-17",
    "Statement": [
        {
            "Sid": "AllowPublicRead",
            "Effect": "Allow",
            "Principal": {
                "AWS": "*"
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::ravis-blog-bucket/*"
        }
    ]
}

Scroll down to CORS policy and Edit

[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "GET",
            "PUT",
            "POST"
        ],
        "AllowedOrigins": [
            "*"
        ],
        "ExposeHeaders": []
    }
]

Make sure that you update the bucket name inside the policy code "Resource".

In order to test the setup, upload a single file and try to access it from outside, i.e. Incognito.

2. Integrate S3 with NodeJS

Assuming you already have express app setup and we are ready to proceed with aws sdk setup. In order to acccess S3 apis from nodejs we would need to install aws-sdk npm package.

Lets also install the uuid and mime as helper packages.

const { S3 } = require('aws-sdk');
const uuid = require('uuid').v4;
const mime = require("mime");

const s3 = new S3();
const uploader = (file, filepath) => {
    console.log("uploading file -> ", file);
    const params = {
        Bucket: process.env.AWS_S3_BUCKET, // ravis-blog-bucket
        Key: `${filepath}${uuid()}_${Date.now()}_.${mime.getExtension(file.mimetype)}`,
        Body: file.buffer
    };

    console.log(params);
    return s3.upload(params);
}

Now it's ready for user, we can call the uploader function and pas multipart file and filePath ( location path at S3, i.e. images/logos/ ).

How to redirect the domain to the port number using Nginx and set up SSL?

Ravi Agheda — Wed, 25 May 2022 11:06:33 +0000

Nginx Configuration Setup

Install Nginx

sudo apt update
sudo apt install nginx

Link port with domain

Open this file in nano or vim /etc/nginx/nginx.conf

http{
  server{
    listen 80;
    server_name DOAMIN.com www.DOMAIN.com;
    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header Host $http_host;
      proxy_pass http://<IP_ADDRESS>;
    }
  }
}

After updating nginx.conf apply this commands
Test nginx.conf sudo nginx -t
Restart nginx service sudo systemctl restart nginx or sudo service nginx restart
Check nginx status sudo systemctl status nginx or sudo service nginx status

Issue ssl certificate from certbot

Ref: https://www.nginx.com/blog/using-free-ssltls-certificates-from-lets-encrypt-with-nginx/

Install certbot

sudo apt-get update
sudo apt-get install certbot
sudo apt-get install python-certbot-nginx

Obtain the SSL/TLS Certificate

sudo certbot --nginx -d example.com -d www.example.com

It'll handle the required modification for https in nginx.conf

Automatically Renew Let’s Encrypt Certificates

crontab -e
0 12 * * * /usr/bin/certbot renew --quiet

Manually setup SSL and https configuration on nginx

http{
  server{
    listen 80;
    server_name spotcodes.in www.spotcodes.in;
    return 301 https://$server_name$request_uri;
  }

  server {
    listen 443 ssl;
    server_name spotcodes.in www.spotcodes.in;

    ssl_certificate /etc/letsencrypt/live/spotcodes.in/cert.pem;
    ssl_certificate_key /etc/letsencrypt/live/spotcodes.in/privkey.pem;

    location / {
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $http_host;
    proxy_pass http://3.83.202.107:2001;
    }
  }
}

Test SSL certificate installation

https://www.experte.com/ssl-check

Usefull links and credits

Mongoose auto timestamp

Ravi Agheda — Tue, 02 Feb 2021 06:21:55 +0000

Let mongoose schema handle timestamps for you

It's a little difficult to manage createdAt and updatedAt on each Create and Update operation.

We can have it handled by mongoose built-in features.There are three ways to add timestamps in mongoose schema

1. createdAt and updatedAt in timestamp format.

const mySchema = new mongoose.Schema(
    {
        name: String,
    }, 
    {
        timestamps: true,
    }
);

output:

createdAt: 2021-02-02T06:12:26.668Z,
updatedAt: 2021-02-02T06:12:48.930Z

2. Timestamp with a custom field name

By default, the names of the fields are createdAt and updatedAt. Customize the field names by setting timestamps.createdAt and timestamps.updatedAt.

const mySchema = new mongoose.Schema(
    {
        name: String,
    }, 
    {
        timestamps: { createdAt: 'addedAt', updatedAt: 'modifiedAt' },
    }
);

output:

addedAt: 2021-02-02T06:12:26.668Z,
modifiedAt: 2021-02-02T06:12:48.930Z

3. Timestamp with number format (double)

By default, Mongoose uses new Date() to get the current time. If you want to overwrite the function Mongoose uses to get the current time, you can set the timestamps.currentTime option. Mongoose will call the timestamps.currentTime function whenever it needs to get the current time.

const mySchema = new mongoose.Schema(
    {
        name: String,
        createdAt: Number,
        updatedAt: Number,
    }, 
    {
        timestamps: { currentTime: ()=> Date.now() },
    }
);

output:

createdAt: 1612246845043,
updatedAt: 1612246853068

How to host Angular app on Heroku

Ravi Agheda — Sun, 31 Jan 2021 17:04:33 +0000

We need an express server to make the Angular app live.

Install express and path.

npm install express path

Create server.js

const express = require('express');
const path = require('path');

const app = express();

app.use(express.static(__dirname + '/dist/<FOLDER_NAME>'));

// Link index.html of build folder with router.
app.get('/*', (req,res,next) => {
    res.sendFile(path.join(__dirname + '/dist/<FOLDER_NAME>/index.html'));
});


app.listen(process.env.PORT || 8000);

Add these lines in `package.json`

inside scripts

"start": "node server.js",
"heroku-postbuild": "ng build --prod"

Add engines inside package.json

"engines": {
    "node": "14.15.3",
    "npm": "6.14.9"
  },

Add this project to GitHub and connect this repository with your Heroku app.

Click on deploy.

Thanks for reading :)

DEV Community: Ravi Agheda

Setting Up Llama 3.2 Locally with Ollama and Open WebUI: A Complete Guide

1 Install Ollama

2 Setup the model, in our case Llama3.2

3 Setup Open-WebUI

Setting Up Llama 3.2 Locally with Ollama and Open WebUI: A Complete Guide

1 Install Ollama

2 Setup the model, in our case Llama3.2

3 Setup Open-WebUI

Creating a GitHub Action for Deploying to Google Cloud Run Using Docker

GitHub Action with EC2 using SSH

1. Generate SSH Key

DS_Store in git, why ?

Love Mongodb ? Try Tigris db once.

The Art of Debugging: Techniques for Effective Problem-Solving

Divide and Conquer

Rubber Duck Debugging

Debugging with Print Statements

Pair Programming

Conclusion

How to integrate swagger ui in your node project with auto generation ?

Setup AWS S3 bucket for NodeJS

1. Setup S3 bucket with public access.

2. Integrate S3 with NodeJS

How to redirect the domain to the port number using Nginx and set up SSL?

Nginx Configuration Setup

Install Nginx

Link port with domain

Issue ssl certificate from certbot

Install certbot

Obtain the SSL/TLS Certificate

Automatically Renew Let’s Encrypt Certificates

Manually setup SSL and https configuration on nginx

Test SSL certificate installation

Usefull links and credits

Mongoose auto timestamp

Let mongoose schema handle timestamps for you

1. createdAt and updatedAt in timestamp format.

output:

2. Timestamp with a custom field name

output:

3. Timestamp with number format (double)

output:

How to host Angular app on Heroku

Install express and path.

Add these lines in package.json

Add this project to GitHub and connect this repository with your Heroku app.

Add these lines in `package.json`