DEV Community: Prakash Singh

cursor + openai codex: quick wins, quick fails (this week)

Prakash Singh — Tue, 02 Sep 2025 20:48:52 +0000

been juggling cursor + openai codex this week

CURSOR (with gpt-5) = power drill for messy multi-file refactors
CODEX = the robot intern for tests/chores 😅

tricks
-> keep asks tiny (one diff at a time)
-> be super explicit (file paths + “done-when”)
-> ctrl+I opens the agent, ctrl+E shows background agents
-> let codex run in its sandbox while you keep typing
-> add a tiny agents.md so both stop guessing

flops
-> vague prompts
-> “do it all” asks
-> agents touching random files

net: split the work like chef (cursor) + sous-chef (codex) and you’ll ship faster

5-Day Stateful Agent (Open Source) 🚀

Prakash Singh — Wed, 27 Aug 2025 18:21:09 +0000

A tiny, fast agent from ReAct → tools → LangGraph graphs → per-user memory. Easy to run and extend.

Contribute: tracing, vector-DB sample, “Day 6: Agentic RAG.”
Repo: https://github.com/prkskrs/agent-drive-0.1

AgenticAI #LangGraph #LangChain #OpenSource #TypeScript

Context: The repo README shows the Day-1→Day-5 path, memory per user, and a Stripe refund demo; LangGraph docs describe it as a stateful orchestration framework for agentic apps

is RAG dead? nope—it learned to drive

Prakash Singh — Tue, 26 Aug 2025 16:48:20 +0000

mid-2025 takes say the real jump is agentic RAG -> retrieval that adapts mid-flight, switches tools, and asks follow-ups when the data looks weak. aka “RAG with a steering wheel.” 🚗💨

tiny playbook: plan → retrieve (multi-query) → re-rank → answer (with sources) → verify (retry if low confidence).

System Design : Vertical And Horizontal Scaling

Prakash Singh — Mon, 10 Apr 2023 07:28:25 +0000

To expose our code, we cannot simply give our computer to anyone. Therefore, we need to find a way to share our code securely. To run our code, we first need to create a database on our computer and also plan for contingencies in case of power loss. It's crucial to ensure that our service remains uninterrupted since many people depend on it, and we don't want to disappoint them.

To achieve this, we should consider hosting our services on the cloud.

But what distinguishes cloud computing from desktop computing? There's actually no significant difference between the two. With cloud computing, we can access a set of computers that provide computational power, just like a desktop that's located somewhere else. We can upload our code to a cloud computer via remote login, making cloud computing a viable option for running our services.

Let's focus on the business requirements.

If many people will be using your service and your code can't handle that many requests, what will be the solution? There are two approaches:

Vertical Scaling: You can upgrade your existing machine to a larger one to process requests faster.
Horizontal Scaling: You can add more machines and distribute requests among them. Both of these approaches are known as scalability, which is the ability to handle an increasing number of requests. By implementing these mechanisms, you can increase the scalability of your system.

Horizontal Scaling

[1], [2], [3], [4], [5]. (Many Different Machines)
Load Balancing Required
Resilient : Request can be redirected if system is busy.
Communication between servers occurs over the network, which means that it involves network calls. However, network calls are generally slower than other types of calls since they involve input/output (I/O) operations. This is because data needs to be transmitted over the network, which takes time. Such calls are also known as Remote Procedure Calls (RPC).
Data inconsistency can occur when multiple requests are simultaneously using the database.
Scales well as users increase.

Vertical Scaling

[ Huge Machine ]
No Load Balancing Required
Single point of failure. Because of only one machine.
Here we have Inter Process Communication. So faster than Horizontal Scaling.
Data consistent because one system where all data resides.
Hardware Limit.

What do you think is used in the real world?

The answer is that both vertical and horizontal scaling have different benefits, so we use them according to our requirements.
However, a hybrid solution is essentially horizontal scaling, where each machine has a larger processing capacity.
Initially, it's recommended to use vertical scaling, but once users trust your service, you can consider moving to horizontal scaling.

Why Programmers use const while declaring variable in JavaScript ?

Prakash Singh — Sun, 06 Nov 2022 09:36:52 +0000

const

“const” has to be initialised.

const n1 = 20;
console.log(n1)

once you have assigned, you cannot reinitialise.

// Will throw error
const n2;
console.log(n2)

“const” can be scoped into blocks

const n1 = 20;
if(n1<=20){
   const n3 = 9;
   console.log(`n3 : ${n3}`)
}
console.log(`n1 : ${n1}`)
// Will throw error if you uncomment this line
// console.log(`n3 : ${n3}`)

“const” content can be modified
-> If I assign it as an object, JavaScript does not care if you change the object. All it cares about is whether it is an object or not. Do not change it to a number or string. You can now update or change the inside of an object.

const movie = { "title" : "Avengers" }

// will throw error
// const movie = 10; 

// But changing inside object is fine
movie.title="test"
movie.year=100
movie.genre="Action"
console.log(movie)

you cannot do initialization in any of the ways

const n=1
n++ or n=n+1 or n=19

you cannot do loop with “const”

for(const i=0 ; i<10 ; i++)
{
   console.log(i)
}
// will throw error at i++ at first time

let

let follow the same rule as const except it can be assigned and left uninitialised.

let n;
n=10;
n=[]
n={}
n="StringHere"
console.log(n)

you can always do loop with let

// will run perfectly
for(let i=0 ; i<10 ; i++)
{
    console.log(i)
}

the value of undefined let variable is undefined

let x;
console.log(x)                // check console => x --> undefined

var

A classical way to initialise Javascript variables. The awful thing about var is It is expensive to manage in the browser.

Look at that! Right there, so the window will become this

Global object which already exist in the browser and any var variable will attach itself to this thing. You can imagine with a thousand variables later, you can attach yourself to this or stop, so it’s a security problem and it is taking an unnecessary memory.

Answer of the above question :
→ Always use const use let when you need to reassign variables.
→ And avoid using var.
→ We need to clear things up, like that we should always use const. If you need to reassign the value to the reserved variable, use let Otherwise, never use var, and in my programming experience with JavaScript till now, I’ve noticed that I barely use let, like only in loops. Otherwise, it’s constantly happening const.
Yes, if you require anything really, just use const all the time because of the optimisation.
Check GitHub for code : Click Here

Backend Boilerplate for NodeJs-ExpressJs-MongoDB

Prakash Singh — Sun, 09 Oct 2022 21:29:42 +0000

When i was learning backend web developement. I had not found any proper resource for Backend Web Development. But, i have tried my best to learn. Started googling, learnt using youtube and documentation websites.

Then after, i used to work in same file app.js or index.js
Later on, It was very hard for me to work on Big Projects.

Before Start why file structure is important?
1) Helps you to find your files quickly in future.
2) Other developers can understand your files and don't face much difficulty
3) Easy for debugging
4) More importantly clean code, because it allows you to clearly communicate with the next person who works with what you've written.

File Structure

configuration

→ In this directory, we usually connect our database i.e. MongoDB using mongoose.

→ And also to manage passport, it is Express-compatible authentication middleware for Node.js . Passport's sole purpose is to authenticate requests, which it does through an extensible set of plugins known as strategies and this directory is mainly used to take care of configuration part.

→ Structure for db.js

import mongoose from "mongoose";
import dotenv from "dotenv";
dotenv.config();
const MONGO_URL = process.env.MONGO_URL || "mongodb://localhost:27017/test"

// console.log(MONGO_URL)

// Connect Database
export const connectDB = mongoose.connect(MONGO_URL,{
useNewUrlParser:true,
useUnifiedTopology:true
})
.then(console.log("DB Connected Succesfully...."))
.catch((err)=>{
console.log("DB Connection Failed!")
console.log(err)
process.exit(1)
});

export default connectDB;

models

Here we implement our schemas in order to create collections in each document.

→ Structure of user.js

// Import Dependencies
import mongoose  from "mongoose";
import validator from "validator";
import bcrypt from "bcryptjs";
import jwt from "jsonwebtoken";

const userSchema=new mongoose.Schema({

username:{type:String,required:true,maxlength:[40,'Name should be under 40 characters.']},

email:{type:String,required:[true,'Please provide an email'],validate:[validator.isEmail,'Please enter email in correct format'],unique:true},

password:{type:String,required:true,minlength:[6,"Password should be of atleast 6 characters."],
},

role:{type: [{type: String,enum: ['admin', 'user']}],default:['user']},
forgotPasswordToken:String,
forgotPasswordExpiry:Date
},
{timestamps:true})

const User = mongoose.model("User",userSchema);
export default User;

controllers

Controller functions to get the requested data from the models, create an HTML page displaying the data, and return it to the user to view in the browser.

→ Structure of userController.js

// Import Model
import User from "../models/User.js"

// Making Promise
import bigPromise from "../middlewares/bigPromise.js"

export const createUser = bigPromise(async(req,res,next)=>{
const {username,email,password}=req.body;

if((!username) || (!email) || (!password)){
return res.status(400).json({
success:false,
message:"All fields are required!"
})}

const existingUser = await User.findOne({email:email})

if(existingUser){
return res.status(501).json({
success:true,
message:"User Already Exists !",
})}

else{
const user=await User.create({
username,
email,
password
})

return res.status(201).json({
success:true,
message:"User Created Successfully !",
data:user
})
}
})

middlewares

The main purpose of the middleware is to modify the req and res objects, and then compile and execute any code that is required. It also helps to terminate the request-response session and call for the next middleware in the stack.

myCustomMiddleware (req,res,next)
{
// My Customized Middleware is here.
}

routes

"Routes" to forward the supported requests (and any information encoded in request URLs) to the appropriate controller functions.

→ Structure of userRoutes.js

import express from "express"
const router = express.Router()

// import controllers
import {createUser} from "../controllers/userController.js"

router.route("/createUser").post(createUser)
export default router;

utils

In "Utils" we put functions to handle error based on api and etc. Also "utils" module provides some functions to print formatted strings as well as some 'utility' functions that are helpful for debugging purposes. Use require('utils') to access these functions.

.env

The .env file contains the individual user environment variables that override the variables set in the /etc/environment file. You can customize your environment variables as desired by modifying your . env file.

Example :

#JWT
APP_PORT=9000

#PREFIX app path
APP_PRIFIX_PATH=/APP_PRIFIX_PATH

#JWT
JWT_SECRET=APLHABETAGAMA
JWT_EXPIRE=1y

# Database config

# If you want to use database URI with DB_URI
DB_URI=
DB_USERNAME=admin
DB_PASSWORD=admin

→ Structure of app.js

Here, we import main dependencies like regular middlewares, cookie-parser, routes management and router middleware.

import express  from "express"
import  dotenv  from "dotenv"
import connectDB from "./config/db.js"
dotenv.config();
const app=express()
import cookieParser from "cookie-parser"

//cookies and filemiddleware
app.use(cookieParser())

// morgan middlewares
import morgan from "morgan"
app.use(morgan("tiny"))

// regular middlewares
app.use(express.json())
app.use(express.urlencoded({extended:true}))

// import all routes here
import userRoutes from "./routes/userRoutes.js"

// router middleware
app.use("/api/v1",userRoutes);
export default app;

→ Structure of index.js

Here, we listen or run our server at localhost.

import app from "./app.js"
const PORT=process.env.PORT||1999

// import {connectDB} from "./config/db.js"

app.listen(PORT,()=>{
console.log(`listening at port http://localhost:${PORT}`)
})

Workflow

Basic npm packages to be installed while setting-up new project :

npm i express mongoose doting body-parser morgan cors jsonwebtoken bcryptjs validator cookie-parser

Before it ends, if you want my node-js-backend-boilerplate it is already created and it is been open sourced under Catalysts Organisation's.

Check Out this GitHub Link for Boilerplate, you can clone this boilerplate for projects : Click Here

Follow if you find this article helpful. Thank You !

Diabetes Prediction Using SVM - Interesting Machine Learning Projects

Prakash Singh — Mon, 19 Sep 2022 20:45:19 +0000

Domain Knowledge

In this case, we train our model with several medical informations such as the blood glucose level, insulin level of patients along with whether the person has diabetes or not so this act as labels whether that person is diabetic or non-diabetic so this will be label for this case.

So once, we feed this data to our support vector machine model. What happens is our model tries to plot the data in a graph.
Once it plots the data, it tries to find a hyperplane so in this image you can see a hyper plane. So, what happens is that this hyperplane separates these two datas.

Then once, we feed new data to this model, it tries to put that particular data in either of these two groups. With that, it can predict whether the person will be diabetic or non-diabetic.

"Okay so in this case, we use several medical information such as bmi, blood glucose level, insulin level of patient and etc."

Requirements for this project
→ Python
→ Support Vector Machine

First of all, we will talk about Support Vector Machine.
SVM is one of the most popular Supervised Learning algorithms, which is used for Classification as well as Regression problems.
However, primarily, it is used for Classification problems in Machine Learning.

The goal of the SVM algorithm is to create the best line or decision boundary that can segregate n-dimensional space into classes so that we can easily put the new data point in the correct category in the future. This best decision boundary is called a hyperplane.

Workflow

Diabetes Data→ Take data from hospitals or patients.

Data Preprocessing → We need to preprocess data where we will try to analyze the data and this data won't be very suitable to feed to the machine learning model and we need to standardize this data at first because there is a lot of medical information and we want all these data to be on the same bridge. So, what we do is to standardize all of this data so that all this data will lie in the same range.
And all these things will be done in the data pre-processing.

Train-test-split → We will train our machine learning model with training data and then we will try to find the accuracy score of our model with the help of test data. So simply, it will tell us how well our model is performing.
So once, we had done with splitting of data into training and testing data.

Support Vector Machine Classifier → Now, we will feed data to our SVM classifier model. We will be using a classifier model where this model will classify whether the patient is diabetic or non-diabetic.
Once, we have trained it. We'll have a trained SVM classifier. So, when we give a new data. So, it can now predict whether the patient is diabetic or non-diabetic.

Code Summary :

# Importing Dependencies

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler #(standardize data to common range)
from sklearn.model_selection import train_test_split
from sklearn import svm
from sklearn.metrics import accuracy_score

# Loading the diabetes dataset to pandas dataframe
df=pd.read_csv("diabetes.csv")

# all data except labels
X= df.drop(columns="Outcome",axis=1)
y=df["Outcome"]

# train test split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,stratify=y, random_state=2)

# Model Training
classifier=svm.SVC(kernel='linear')
classifier.fit(X_train,y_train)

Github Link for Jupyter File and Dataset : Click Here

Tools Required For Backend Development

Prakash Singh — Wed, 14 Sep 2022 21:03:11 +0000

As a Backend Developer, eventually you will be going to collect whole bunch of tools that will be important for your workflow.

We are going to start with absolutely basic tools. These are the must having tools for every backend developer. In backend, majority of time we spend to build REST API. For this, we need some specialised tools to actually test them, because our browser can majorily send the GET Request.
For a POST Request, it requires a lot of involvement. And we don't need that. So, most popularly we use these tool. And we will have a little bit of debate around all of these tool.

VS Code :

→ Nowadays, VS code is my first choice to write my every code. It is used by almost everyone. This is the editor for which i am falling in love. Or already fallen in. You can also use Sublime Text, Atom and etc whichever is your favourite. But, this is the one that i am using. And i will highly recommend to give it a try.

Must install these extensions in your VS Code :
→ JavaScript (ES6) Code Snippets
→ Auto Close Tag
→ Prettier - Code formatter
→ Better Comments
→ Live Server

Postman :

→ Sometimes debate comes out that we can use ThunderClient in VS Code. OfCourse that is a great thing and you can also use this ThunderClient. It will give you almost every option that you are looking up for. But, the thing is i am not that much familiar with ThunderClient. But, many of the developers are on Postman. I will give you all the reason why it is all there. No doubt ThunderClient is light-weight and amazing but not for the pro usage.

But why we are going for Postman ?
→ The first thing you will love about it is the ability to create the environment.
→ Also you can create your own APIs. This is very fantastic in it.
→ We can create our own mock servers.
→ You can check the flow of API Endpoints. And you can share this flow with any developer and it will be easy for them to understand.

If you will be working in a corporate, you will be using it day-in day-out.

So, make sure that you will get more friendly with postman.
Apart from postman, people also use the app Insomnia also kind of "brother of postman". But these days postman providing you more feature than this. But this is also being loved whole lot of people.

Nodejs :

→ Nodejs is an open source, cross-platform runtime environment for developing server-side and networking applications. It is one of the most popular technologies nowadays to build scalable and efficient REST API's. Node.js applications are written in JavaScript, and can be run within the Node.js runtime on z/OS, Linux, macOS, Microsoft Windows, SmartOS, FreeBSD, OpenBSD, IBM AIX.
It allows the Node.js developers to create web servers & networking tools using JavaScript and collection of modules that handle various core functionalities.
Popular Nodejs Frameworks :
→ Express.js
→ Next.js
→ Koa
→ Nest.js and so on.

Chrome :

→ Google Chrome provides plenty of tools, extensions, and features for everyday users, but it also includes plenty of features for developers and designers who are interested in building or editing websites and applications of their own. And it provides a feature of inspect element and networks.

GIT :

→ Git is an open source version control system. It is being used widely by web developers to track changes made to both open source and commercial projects. The developers can further use Git with major operating systems and integrated development environments (IDEs). But the developers must understand the key features of Git to use the version control system more efficiently.

How to Use Git More Efficiently for Backend Development?
→ Open Source
→ Distributed Architecture
→ Focus on File Content
→ Supports Nonlinear Workflow
→ Maintaining Security and Integrity of Source Code
→ Facilitate Collaboration and Coordination

MongoDB :

MongoDB have both online and offline version. I will recommend to use offline version install it locally which is absolutely good for you.Because, it is one of the most famous database program in the world , which is highly used on nowadays for most of the data requirements.
The mongoDB is open source relational database which helps to store unstructured data in JSON format. The open sourceness is one of the main reason for it's popularility.

Is mongoDB secured ?
→ MongoDB is a secured database program. All the data which are stored in the mongoDB will be encrypted and which can't be decrypted by neither the other users nor the mongoDB it self. The users who own the database will only be able to see and manage the data.

So, it is finished. I hope you find this post useful.
Although learning Backend development may initially seem difficult, bur but anyone can accomplish it.
But, i will recommend you all to work on MERN Stack. It is getting very popular.
Thanking You !!

Forecast Your Weather With Python Script

Prakash Singh — Fri, 09 Sep 2022 20:22:47 +0000

What we are going to build ?
→ In order to check your place's weather. With the help of inbuilt libraries of python like requests, json and IPython. From "IPython" library , we use modules like "Image" and "display".

Step 1 : Importing Dependencies

import requests
import json
from IPython.display import Image, display

Step 2 : Enter your api-key
→ You can use https://api.openweathermap.org/ and get your API key. So that, you will get access of data.

# api-key
appId="94*********************"

Step 3 : Enter your place name

# place input
query=input("Enter Your Place to Check Weather : ")

Step 4 : Make queries for URL
→ Here you can write more specific queries for URL.

# queries
unit="metric"

Step 5 : Create Dynamic URL
→ Design your URL. With query variables and make sure that you are using api key or id.

# API url
url="https://api.openweathermap.org/data/2.5/weather?q="+f"{query}"+"&appid="+f"{appId}"+"&units="+f"{unit}"

Step 6 : Send GET request and store response of URL hit

# get response from api-hit
response=requests.get(url,stream=True)

Step 7 : Store data from response

# get data (in bytes form)
data=response.content

Step 8 : Convert "bytes" format to json

# get json file from "bytes" type
jsn=json.loads(data.decode("utf-8"))

Step 9 : Store important data from converted json file

# get temperature
temp=jsn["main"]["temp"]

# get weather icon
icon=jsn["weather"][0]["icon"]

# get weather description
weatherDesc=jsn['weather'][0]["description"]

Step 10 : Send GET request and store response of URL to fetch Image

# get request with imageUrl to fetch png image
imageUrl="https://openweathermap.org/img/wn/"+f"{icon}"+"@2x.png"
response2=requests.get(imageUrl,stream=True)

Step 11 : Display Outputs

# display png
display(Image(response2.content))

# display temperature
print(f"Temperature : {temp}°C (Degree Celcius)")

# display place name
print(f"Place : {query}")

# display weather description
print(f"Weather Description : {weatherDesc}")

Sample Output :

Github Link For Full Code : Click Here

Interesting Machine Learning Projects : Rock Vs Mine Prediction

Prakash Singh — Thu, 08 Sep 2022 04:45:04 +0000

Suppose there is a war between countries and we have assigned submarines to check whether there is rock or a mine inside water.

Mines are explosives that explode when some object come in contact with it.

And there can be rocks as well in the ocean.

What to build ?
→ Submarines have to predict whether it is crossing a mine or a rock. So, we have to build a system to predict whether the object beneath the submarine is mine or rock.

How it can be done ?
→ Submarine uses a sonar that sends sound signal and reviews switch back of the signal. So, this signal is then processed to detect whether the object is mine or just a rock in the ocean.
These sound waves can travel for hundreds of miles under water, and can retain an intensity of 140 decibels as far as 300 miles from their source.

WorkFlow :

Collect Sonar Data : Laboratory setup experiment can be done where sonar is used to send and receive signals. There is far difference between signals received from mines and rocks. Because mines will be made up of metal.
So, we collect this data which is nothing but the sonar data obtained from a rock and a metal cylinder.
And later, we use this sonar data and feed it to our machine learning model.
and our model will predict whether the object is made up of metal or it is just a rock.
This is the principle we are going to use in our prediction.

Data Preprocessing : We must process data for better results. In preprocessing, we do cleaning, filling missing values etc.

Train Test Split : After that, we will train our model with 80-90% of training-data and 10–20% will be used to test-data. And evaluate our model with the help of test-data.

Logistic Regression Model : Why Logistic Regression Model ? Because, this model works very well for Binary Classification Problem. It is a Binary Classification Problem (Rock or a Mine).
This is a Supervised Learning Algorithm.

# Importing Dependencies
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Dataset Reading
sonar_data=pd.read_csv("sonardata.csv",header=None)

# Check relation between classes
sonar_data.groupby(60).mean()

# Separating input-output columns
X=sonar_data.drop(columns=60,axis=1)
y=sonar_data[60]

# train_test_split
X_train,X_test,Y_train,Y_test=train_test_split(X,y,test_size=0.1,stratify=y,random_state=1)

# Model Building
model=LogisticRegression()

# Model Fitting
model.fit(X_train,Y_train)

# accuracy on training data
X_train_pred=model.predict(X_train)
training_data_accuracy=accuracy_score(X_train_pred,Y_train)

# accuracy on test data
X_test_pred=model.predict(X_test)
test_data_accuracy=accuracy_score(X_test_pred,Y_test)

# Check Github Link For Full Code And Dataset

Github Link : Click Here

Track Anyone's IP Address using Python

Prakash Singh — Sun, 04 Sep 2022 06:53:45 +0000

Using this technique, you can make your own IP Tracker.

At first, download python in your system.

Step 1 : Add Dependencies

import os
import urllib2
import json

OS Module : It will be used to interact with Operating System.

urllib2 Module : It will be used to handle "urls".

json(JavaScript Object Notation) Module : It will be used to store and exchange data.

Step 2 : Take Raw Input From User (Tageted IP)

ip = input("What is your target IP: ")

Step 3 : Enter URL, whose api we are using

url = "http://ip-api.com/json/"

Step 4 : Get HttpResponse in a variable

response=urllib2.urlopen(url+ip)

Step 5 : Get Data from response in a variable

data=response.read()

Step 6 : Get Data in JSON form in a variable

values=json.loads(data)

Step 7 : Showcase the Informations

print("IP: "+values["query"])
print("City: "+values["city"])
print("ISP: "+values["isp"])
print("Country: "+values["country"])
print("Region: "+values["region"])
print("Timezone: "+values["timezone"])

Full Code : Link

How to get phone number information using Python ?

Prakash Singh — Thu, 01 Sep 2022 17:00:16 +0000

In order to get details of any mobile number. We can use an inbuilt library of python i.e "phonenumbers". And modules present inside this library are "geocoder", "carrier" and "timezone".

Step 1: install the library "phonenumbers"

!pip install phonenumbers

Step 2: import library

import phonenumbers

Step 3: take user's phone number and parse it

a = input("Enter Phone Number: ")
# Parsing
ph_no = phonenumbers.parse(a)

Step 4:
geocoder : this module is used to get the location of your number.

from phonenumbers import geocoder
# Location Of Number
print(geocoder.description_for_number(ph_no,"en"))

Step 5:
carrier : this module is used to get the service_provider's name of your number.

from phonenumbers import carrier
# Service_Provider's Name
print(carrier.name_for_number(ph_no,"en"))

Step 6:
timezone : this module tells the timezone of the phone number.

from phonenumbers import timezone
# Timezone
print(timezone.time_zones_for_number(ph_no))

Full Code : Click Here