Forem: Yash Jivani

React-Poem-Finder-App

Yash Jivani — Fri, 06 Jun 2025 01:19:37 +0000

React-Poem-Finder-App

Quick Start

git clone https://github.com/jivaniyash/react-poem-finder-app.git
cd react-poem-finder-app
npm install
npm run dev

Overview
- Features
Getting Started
- Prerequisites
- Installation
Usage
- Deployment

Overview

This Project is built using React + Vite Application. It helps users to find & search poems quickly by typing keywords in the search bar.
Check out Project at CloudFront Link.
Check out the demo at GitHub

Features

Overlays - are used to show/hide the metadata of the poem
Search Bar - to filter the Poems by title/content, sorted by Ascending Order & by title first (Searchable across EN & GU languages)
Pagination - to change the display of poems in a single page & Page Navigation at the bottom of the Screen
Language - toggle to change the default global language and poem-level toggle
Highlighter - to show the query search in the poem

Getting Started

Prerequisites

git
Node.js (18 or later)
npm
Vite (npm install -g vite)
AWS Account (with sufficient permissions to create & add files to an S3 Bucket)

Installation

Clone the Repository

git clone https://github.com/jivaniyash/react-poem-finder-app.git

Navigate to the project directory:
```
cd react-poem-finder-app
```
Install dependencies
```
npm install
```
Test on Local Machine
```
npm run dev
```
This will start the App @ http://localhost:5173. You can remove the configuration - host: true from the server parameter to disable access from other users on the same network
Build the App
```
npm run build
```
This will generate a new dist directory at the root level.
Preview Production Build Locally
```
npm run preview
```
This will start the App @ http://localhost:4173

Usage

There are two options to deploy the React app: either using an S3 website endpoint or CloudFront, with the connection secured.

Deploy App in AWS S3 Bucket and access via S3 public link

Create an S3 Bucket with the uncheck Block all public access option to allow Public Access
Once Bucket is created, navigate to the Properties tab & Enable Static website hosting
Specify the default page of the website -index.html
Upload all the contents from the dist directory to the S3 Bucket
Open the Bucket website endpoint - http://bucket-name.s3-website-region.amazonaws.com/

Deploy App in AWS S3 Bucket and access via AWS CloudFront

Create an S3 Bucket with the Block all public access option
To configure a secure HTTPS connection, create a CloudFront distribution, configuring the domain from the S3 Bucket
Select Origin access control(OAC) settings & create OAC to allow Bucket access for CloudFront
Set Redirect HTTP to HTTPS & optional caching and domain settings
Set the root object as index.html
Copy & Paste the Policy of the OAC to the S3 Bucket
Open the CloudFront Website Endpoint - https://id.cloudfront.net/

Deployment

AWS Deployment using deploy.yml
Create Access keys & Access Token from IAM User Console
Open GitHub Repository Settings -> Under Security -> secrets and variables -> Actions -> Repository secrets
Add AWS_ACCESS_KEY_ID
Add AWS_SECRET_ACCESS_KEY
Add S3_BUCKET_NAME
Add CLOUDFRONT_DISTRIBUTION_ID # if App is deployed to CloudFront for removing cache
Change GitHub Repository's Code and automation Settings -> Branches
Add a Branch protection rule to allow the deploy.yml file to run when new changes are pulled from a feature branch using Pull Requests.

Steps for Fresh Start

Run the following commands for a fresh start of the Project

npm create vite@latest my-project -- --template react
cd my-project                 
npm install
npm run dev

Customize the directory and files to add/alter/remove the files for a particular use case

Check out more at my GitHub Repository

Redirecting YouTube Video: Watch Page to Embed View

Yash Jivani — Sat, 31 May 2025 19:14:22 +0000

Youtube-Embed-Redirector-Extension

This project helps a workaround for YouTube viewers to redirect the YouTube default video view to the Embed view (Full Screen) on Browsers. This helps users avoid any distractions from YouTube suggestions or ads. This extension works as described only with YouTube Videos and Playlists & does not affect YouTube Shorts Videos.

Demo

Steps to activate the Extension

Pull this repository or Download files as a Zip file & unzip it.
Open the Browser's Extension Page. For Google Chrome - Please type in the URL bar - chrome://extensions.
Turn on the Developer Mode toggle button if turned off.
Click on the Load Unpacked Button.
Choose the directory where this git repository is downloaded or cloned.
Ignore any errors in the extension page.

Usage

Open the https://www.youtube.com/ and choose the video you want to play
The browser tab will redirect the YouTube watch page to the embed video format in full-screen view.

Additional Configuration

Currently, there is an additional URL parameter - rel=0 added to the background.js script, which shows the video suggestions only from the current YouTube Channel during Play/Pause Mode & End of Video. Check out Youtube API documentation for additional configuration.

Check out my GitHub Repository - YouTube-Embed-Redirector-Extension

Serverless Data Ingestion Pipeline using AWS Lambda, S3 & RDS

Yash Jivani — Wed, 28 May 2025 22:31:57 +0000

CMS API Data Processing using AWS Lambda, S3 & RDS

CMS (Centers for Medicare & Medicaid Services) API provides information on prescription drugs provided to Medicare beneficiaries enrolled in Part D (Prescription Drug Coverage), by physicians and other health care providers, aggregated by provider and drug in the US.

Project Scope

For this project, 2023 Year records are used from the cms database. This project showcases how different AWS Services are configured & provisioned to follow AWS best security practices to allow for least privilege by assigning IAM Roles & Policies

Data Flow Steps

Following are the steps AWS Services follow -

LambdaA runs the Python scripts to fetch the CMS Data using the CMS API and stores it in an S3 bucket (cms-2023-project)
S3 Bucket has an Event Notification triggered, which is configured to run LambdaB once a new object is uploaded successfully in the S3 bucket with the predefined prefix & suffix set for the key name
LambdaB, which is under the Private subnet, follows the steps -
- Connects to S3 using a VPC Endpoint
- Retrieves the raw data from the triggered Event Notification
- Connect to RDS MySQL Database Instance
- Create the Table if it doesn't exist & store the data

Additional Notes -

LambdaB & RDS Spans to MultiAZ for High Availability (us-east-1a & us-east-1b) (Not shown in Diagram)
LambdaB & RDS are associated with different security groups to talk to AWS Services securely
Since RDS is placed inside a private subnet, LambdaB needs to be placed inside a VPC
IAM Policies are created to allow Lambda A & B to connect with S3 & RDS and are attached to IAM Roles
VPC Endpoint is configured to allow target S3 requests
Route Tables are associated with Private Subnets
Inbound & Outbound rules are set to receive incoming & outgoing traffic to services inside the Security groups

Project Steps:

Create a VPC with 2 Private Subnets & 2 Security Groups and configure firewall rules (Inbound & Outbound)
Create a VPC Endpoint using the S3 Gateway service
Create a S3 Bucket to store data & allow permissions & configure Event Notification
Create LambdaA & LambdaB & follow instructions @ lambdaA & lambdaB
Create RDS Instance, configuring MySQLDB Engine, Credentials, Storage & Instance & Connectivity

Find More information in my GitHub Repository - cms-data-aws

Smart Waste Solutions: Integrating AI in Next-Gen Waste Sorting

Yash Jivani — Fri, 30 Aug 2024 03:08:55 +0000

Have you ever thought of using AI to sort your customer's waste? There are many companies & waste management contractors in the market globally who want to maximize recycling and save the environment. But, the main problem is people tend to throw the waste in the bin they want or nearest to them, regardless of waste signs & symbols located on bins. Some of the key reasons are people:

are unaware of the categories (usually there is a variation of categories)
don't know which waste is classified under what category
don't have time to think/wait
and many more...

Due to the unsorted waste collection at the source, it becomes difficult for the recycling facility to sort 100% accurately. This blog shows the procedure of setting up the system (hardware & software) at/near waste collection bins.

Hardware Requirements

Raspberry Pi
Camera
Arduino Uno
Breadboard
Wires & LED Lights

Software Requirements

Python
Arduino IDE

Steps.

Configure Raspberry Pi Setup - Getting started - Raspberry Pi Documentation
Install Python if not installed.
SSH your Raspberry Pi into your local system or connect with HDMI display, keyboard & mouse to set up the system. This is only required once
Create a Project Directory. Create Python Virtual Env.
Install packages required for running the inference. You can run the trained model Inference. This document is not meant to explain Ultralytics YOLO model training & various ways of optimizing inferences for your custom use-cases & requirements using Roboflow or Ultralytics HUB Inference . The Waste Category Predictor (AI Model) predicts the waste type and sends the signal to Arduino.
Install Arduino IDE in Raspberry Pi.
Connect your Arduino with Baseboard & Setup the led lights. Based on the custom blinking you want for each port, Send the Code to the Arduino system. Remember the custom serial constant you set for each LED light.
Install pyserial package and connect your app with LED using serial commands.
Now, you are all set, once you connect the camera with the Raspberry Pie, Run the Python App.

Some of the steps to configure in VS code are elaborated on at the end of this blog.

Workflow

The user approaches the bin to dispose of the waste item.
When the user points the waste item to the camera, then live video frames are sent to the Raspberry where the Python Code is running.
AI model predicts the waste type & categorizes it.
Based on the classified waste, the response is sent back to the LED light (installed on top of the bin) so the user can get guided where s/he has to throw the waste based on the Light color.

Generally, Raspberry Pi has less computing power affecting the prediction. To tackle this problem, Connect Coral Edge TPU with Raspberry Pi if you want to run locally. Otherwise, you can connect your camera live streams to the remote server (running either in GCP/AWS/Azure or any other cloud computing platform) using a WiFi connection (Make sure you set up proper authentication, making your system secure).
This blog doesn't provide Python code & Arduino js code. But if you want to learn more, feel free to connect with me. I would help you set up the configuration & happy to work on building projects like these.

# Steps to Install Packages in Raspberry Pi
## 1. Create & Activate Virtualenv, Install Dependencies

python3 -m venv .venv
.\.venv\Scripts\activate
pip install -r .\requirements.txt

yolo predict model=yolov8s.pt source=0 show=True

# Steps YOLO

## With using Docker
### Install Docker
sudo apt update
sudo apt upgrade -y

sudo reboot

### Install Docker on Raspberry Pi

curl -sSL https://get.docker.com | sh

cd ./
Pull & Run docker image

t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t

## Without using docker

### 1.Create a directory

mkdir waste_sorter

### 2. Create & Activate Virtualenv, Install Dependencies
sudo apt update
sudo apt install python3-pip -y
pip install -U pip

python3 -m venv .venv
.\.venv\Scripts\activate
pip install -r .\requirements.txt

https://docs.ultralytics.com/guides/raspberry-pi/#start-without-docker


pip install ultralytics[export]

# test.py to test Led light configuration
# You need to adjust the code as per your requirements
import random

ser = serial.Serial(port='/dev/ttyACM0', baudrate=9600)

time.sleep(2)

def start_led(n):
    '''Lit Led light for 1 sec & Dim it for n times'''
    for _ in range(n):
        print('start_led function - Command D')
        ser.write(b'D')
        time.sleep(1)

start_led(5)


while True:
    print(f'''It's A, class 0''')
    ser.write(b'A')
    print(f'''It's B, class 1''')
    ser.write(b'B')
    print(f'''It's C, class 2''')
    ser.write(b'C')
    time.sleep(20)
    break


while True:
    try:
        command_input = input('Please Enter Command - 0 for blue, 1 for yellow, 2 for green :')
        command = int(command_input)
    except Exception as e:
        print(f'Error Occured :{e}')
        print('Please enter a valid command')

    if command == 0:
        ser.write(b'A')
    elif command == 1:
        ser.write(b'B')
    elif command == 2:
        ser.write(b'C')

Langchain Chat Assistant using Chainlit App

Yash Jivani — Wed, 21 Aug 2024 17:13:41 +0000

Hey there! If you're excited about building your own AI assistant using Langchain and Chainlit, you're in the right place. In this post, I'll walk you through the steps to set up a simple yet powerful AI assistant. Let’s dive in!

Demo

Steps to Configure

Follow these steps to configure the app on your machine!

1. Clone Git Repo

git clone https://github.com/jivaniyash/langchain-chat-assistant.git
cd ./langchain-chat-assistant

2. Create & Activate Virtual Env

sudo apt install python3.11-venv
python3 -m venv .venv
source ./.venv/bin/activate
python3 -m pip install --upgrade pip

3. Install Packages

pip install chainlit langchain_openai langchain

4. Run the script

chainlit run ./app/main_openai.py -w

-w flag to enable auto-reloading

This will open a web browser automatically. If not, please copy this link - localhost:8000 into the web browser.

Customize

Now, you can customize your app to specific use cases by changing System Prompt from ./utils/systemPrompt.md.
Add New Functions to tailor your use-cases from ./utils/functions.py. Also, if you need to connect using local database, csv, or Excel or any other data files; add those files under ./assests/ directory. fetchFromLocalDB function explains how to configure adding new data sources.

Run Local LLM using OLLAMA APIs

If you want to run your assistant using local LLM running in OLLAMA, please follow these steps.

And there you have it! You can now build and run your own AI assistant using OpenAI or OLLAMA. Enjoy exploring the possibilities!

Please look at my GitHub Repo to get a glance over the files.

From Stamped to Clean: Transforming Watermarked Images into Clear Visuals

Yash Jivani — Fri, 16 Aug 2024 14:31:01 +0000

Have you wondered how you can remove watermarks from images using Python? It's very simple! You should know Python and have a basic knowledge of computer vision models like CNN & TensorFlow DL framework to follow architectures if you are interested!! Please make sure that you read the copyright laws of the images you want to remove watermarks before you run the code.

Steps to follow -

Create a new Google Colab notebook. Change the runtime to T4 GPU to enhance computing power to run the inference pipeline.
Install Conda packages, create and activate the Conda environment
Since Google Colab uses the latest Tensorflow & Python versions and this project uses tensorflow=1.15.0 which is supported by Python 3.6, install miniconda inside the Colab environment

# set pythonpath
%env PYTHONPATH = # /env/python

# Set up miniconda and set the path '/usr/local'
!wget https://repo.anaconda.com/miniconda/Miniconda3-py38_4.12.0-Linux-x86_64.sh
!chmod +x Miniconda3-py38_4.12.0-Linux-x86_64.sh
!./Miniconda3-py38_4.12.0-Linux-x86_64.sh -b -f -p /usr/local

import sys
sys.path.append('/usr/local/lib/python3.8/site-packages')

# create a new conda environment using Python 3.3
!conda create -n myenv python=3.6

3.Install Packages inside Env.

%%shell
eval "$(conda shell.bash hook)"
conda activate myenv
conda install -y tensorflow==1.15 pillow opencv matplotlib pyyaml
conda install -y tensorflow-gpu

pip install --upgrade pip
pip install git+https://github.com/JiahuiYu/neuralgym

4.Clone Repo

!git clone https://github.com/zuruoke/watermark-removal

5.Download Model Files from drive and paste them into the /watermark-removal/model directory.

6.Execute Python code to remove the watermark from your istock image. If you have Alamy, Shutterstock, or your custom watermarked images, please add mask.png inside utils/<watermark-type>/<image-type>.

%%shell
eval "$(conda shell.bash hook)"
conda activate myenv

cd watermark-removal
python main.py --image path-to-input-image --output path-to-output-image --checkpoint_dir model/ --watermark_type istock

Reference

Please give a star to Github Repository which is forked from zuruoke/watermark-removal
To configure TensorFlow=1.15, setup conda env inside colab

Interpreting Benchmarks and Evaluations in LLMs

Yash Jivani — Tue, 25 Jun 2024 19:38:54 +0000

Welcome to the era of Large Language Models (LLMs). If you've heard terms like "benchmarks" or "evaluations" and wondered what they mean & how to interpret them in the context of LLMs, you're in the right place. Let's break down these concepts to understand them.

Benchmarks

Benchmarks refer to standardized tests or tasks in the form of datasets used to evaluate and compare the performance of different models. These benchmarks often include various language understanding and generation tasks, such as text completion, question answering, and summarization. Benchmarks provide a measure of how well an LLM performs compared to others. Some of the benchmarks used to evaluate LLMs are -

General Language Understanding Evaluation (GLUE) benchmark is a collection of 9 natural language understanding tasks
MMLU (Massive Multitask Language Understanding) is a benchmark to measure knowledge acquired during pretraining. It covers 57 subjects across STEM
HumanEval focuses on whether the LLM's generated code works as intended Detailed information can be found in [2] & [3].

Evaluations

Evaluation refers to measuring and assessing a model's performance and effectiveness in how accurately the model can predict or generate the next word in a sentence, understand context, summarize data, and respond to queries. Evaluation is crucial because it helps determine the model's strengths and weaknesses, and provides insights into areas of improvement. There are 2 different ways to compute metrics scores

Statistical Scorer
These are purely number-based scorers - i.e. they don't consider semantics into account. Some of these are -
a. BLEU (BiLingual Evaluation Understudy) evaluates the output of LLM application against annotated ground truths by calculation precision for each matching n-gram between actual & predicted outputs.
b. ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is primarily used for evaluating text summaries from NLP models and calculates recall by comparing the overlap of n-grams between LLM outputs and expected outputs.
Model-Based Scorer
These are NLP-based scorer that takes semantics into account. Some of these are -
a. BLEURT(Bilingual evaluation understudy with Representations from Transformers), often used for machine translation, uses pre-trained models like BERT to score LLM outputs on some expected outputs
b. NLI(Natural Language Inference) uses the NLP classification model to classify whether an LLM output is logically consistent (entailment), contradictory, or unrelated (neutral) with respect to a given reference text.

Detailed information can be found in [4].

After undergoing the benchmark’s evaluation, models are usually awarded a score from 0 to 100. These are the numbers you usually see when companies publish along with their LLM model to compare other models evaluated on the benchmark.

Forem: Yash Jivani

React-Poem-Finder-App

React-Poem-Finder-App

Quick Start

Table of Contents

Overview

Features

Getting Started

Prerequisites

Installation

Usage

Deploy App in AWS S3 Bucket and access via S3 public link

Deploy App in AWS S3 Bucket and access via AWS CloudFront

Deployment

Steps for Fresh Start

Redirecting YouTube Video: Watch Page to Embed View

Youtube-Embed-Redirector-Extension

Demo

Steps to activate the Extension

Usage

Additional Configuration

Serverless Data Ingestion Pipeline using AWS Lambda, S3 & RDS

CMS API Data Processing using AWS Lambda, S3 & RDS

Project Scope

Data Flow Steps

Additional Notes -

Project Steps:

Smart Waste Solutions: Integrating AI in Next-Gen Waste Sorting

Hardware Requirements

Software Requirements

Steps.

Workflow

Langchain Chat Assistant using Chainlit App

Demo

Steps to Configure

1. Clone Git Repo

2. Create & Activate Virtual Env

3. Install Packages

4. Run the script

Customize

Run Local LLM using OLLAMA APIs

From Stamped to Clean: Transforming Watermarked Images into Clear Visuals

Steps to follow -

Reference

Interpreting Benchmarks and Evaluations in LLMs

Benchmarks

Evaluations

References