You asked ChatGPT to help plan a trip. It gave you a list of hotels. An AI Agent would have booked the flight, reserved the room, blocked your calendar, and emailed your team — while you were still reading its first message.

That’s not ChatGPT being smarter. That’s a completely different category of AI. And it’s already being used.

The AI you know has one big limitation

For any task you throw at it, a basic AI can generate a well-organized trip itinerary — complete with flight options, hotel recommendations, car rentals, and even activity suggestions. It’ll tell you which flight is cheapest, which hotel has the best reviews, and what time you should leave for the airport.
But there’s a catch: it stops at suggestions. You still have to open multiple tabs, compare prices, enter your credit card details, and actually book everything yourself.

This is where AI agents change the game

Unlike traditional AI models that only predict, search, or retrieve information (often using techniques like RAG — Retrieval-Augmented Generation), AI agents take action. Instead of just showing you the cheapest hotel, an AI agent can book it for you. Instead of merely listing flight options, it can reserve your seat, add your passport details, and send you a confirmation email — all autonomously.

What is an AI Agent?

An AI agent is an autonomous system that perceives its environment, makes decisions, and takes actions to achieve specific goals — without requiring step-by-step human intervention.

Unlike traditional AI models that primarily predict or retrieve information, AI agents act. They can:

• Plan multi-step workflows (like organizing a full vacation itinerary)
• Use tools (search the web, call APIs, interact with software)
• Execute tasks (book flights, reserve hotels, send emails, make purchases)
• Adapt based on feedback or changing conditions

Think of an AI agent as a digital assistant that doesn’t just tell you what to do — it actually does it for you.

How it works?

• Perceive & Plan: Agent receives the goal, breaks it into subtasks
• Act & Use Tools: Agent calls tools — web search, calendar, email, databases — to execute each step
• Check & Loop: Agent evaluates if the goal is met, re-plans if not, stops when done

An LLM generates text. An Agent takes action. That one difference is the entire future of AI

Real world Examples:

• Coding Agents (Claude Code): Writes code, runs tests, debugs errors, and even deploys applications autonomously
• Medical scheduling agents: Books appointments, sends reminders, coordinates with insurance, and prepares patient records
• AI research assistants: Searches academic papers, extracts key findings, summarizes literature, and drafts research reports

Limitations of an AI Agent

• Accuracy and Reliability: AI agents can make mistakes — and when they do, the consequences can be costly. Unlike traditional software that follows deterministic rules, agents use probabilistic models that can hallucinate, misinterpret instructions, or execute incorrect actions.
• Security: Giving an AI agent autonomy means giving it access—to your accounts, APIs, payment methods, and sensitive data. This creates several security vulnerabilities.
• Cost and Complexity: Running AI agents is expensive and technically demanding. It requires computing resources which will run 24/7 so as to power on the agents. Then, there will be API costs, Infrastructure, Maintenance costs etc.
• Control: As agents become more autonomous, maintaining human control becomes harder. The Control over agents is one of the limitations that may let one think twice before using it, because an Agent with a Control might misalign from the goals, perform in an unpredicted way and some may include irreversible actions.

There are many more limitations that also affect usage of AI Agents like: Integration Challenges, Skill gap etc. So, an AI Agent might sound some fancy robot doing all the things that you are capable of but it must be used with caution.

Endnote: The Future Is Action

They’re not just smarter chatbots; they’re autonomous collaborators that can plan, use tools, and execute real-world actions on your behalf.

AI agents represent a fundamental shift in how we interact with technology — from asking for information to delegating tasks.

Yes, they have limitations. Accuracy issues, security risks, high costs, and control challenges mean we’re not quite at the point of fully hands-off automation. But the trajectory is clear: as models become more reliable, tools become better integrated, and safety frameworks mature, AI agents will move from novelty to necessity.

Missed the earlier parts of this series?

• Part 1 — It’s not thinking. It’s not searching. So what is it doing?
• Part 2 — LLMs Hallucinate. Here’s the Fix Companies Are Quietly Using.
• Part 3 — What is Fine-tuning? The plain English guide to giving AI a personality.

Stop Hallucinations: How RAG Gives AI the Right Answer

In my previous blog, we covered RAG — the technique that gives AI access to real, current information before it answers. It’s powerful.

Every customer support chatbot you’ve ever used that felt weirdly on-brand — that knew the company’s tone, used the right terminology, never went off-script — was almost certainly fine-tuned. Here’s what that means.

The Problem with a Generalist

A base LLM like GPT-4 is trained to be good at everything — which means it’s optimised for nothing specific. We can make it write as a Lawyer, Doctor, Engineer etc. but it won’t be consistent, it won’t use your specific terminology and it won’t understand the nuances of your industry the way as specialist would.

Hiring a brilliant generalist and hoping they pick up your company culture on their own works — eventually, slowly, inconsistently. Fine-tuning is the structured onboarding that makes it stick from day one.

Fine-tuning doesn’t build a new AI. It takes one that already exists — and teaches it to be specifically good at your thing.

So what is Fine-Tuning?

Fine-tuning is the process of taking a pre-trained LLM and training it further on a smaller, specific dataset — so it becomes an expert in that domain, that tone, or that task.

A classically trained musician can play almost anything. Fine-tuning is like spending two years playing nothing but jazz. You don’t lose your classical training — you add a new fluency on top of it.

Process of Fine-Tuning a Model

• Starting off with a Base Model: You don’t start from scratch, you have a pre-trained model — GPT, Claude, LLaMA — one that already understand language, grammar, reasoning and general knowledge. This is your starting point so called as Base Model.
• Prepare the Dataset: You gather examples of exactly what you want the model to do. If you want it to answer customer support questions in your brand’s tone — you collect hundreds or thousands of example question-and-answer pairs that represent the ideal response. This dataset is small compared to what the base model trained on — but it’s highly specific.
• Train on the Specific data: The model runs through your examples and adjusts its internal settings — called weights — to get better at producing exactly this type of output. It’s not memorising your examples. It’s shifting its behaviour toward your use case. After training, the model has permanently changed — it now defaults to your style, terminology, and approach.

Fine-tuning doesn’t add information. It changes behaviour. That’s the entire distinction.

Where is Fine-Tuning is already being used?

• Customer Support: This is an prime example of Fine-Tuning. When a company’s chatbot consistently uses their brand voice — their specific words, their specific tone, their specific policies — that’s fine-tuning. A base LLM would give a generic helpful answer. A fine-tuned one gives the answer that sounds like it came from that company specifically
• Code Assistants: GitHub Copilot isn’t just a base LLM answering coding questions. It’s been fine-tuned on billions of lines of code — which is why it predicts code completions far better than a general-purpose AI would. It’s not smarter. It’s more specifically trained.

So which one is better RAG or Fine-Tuning?

Neither. They solve different problems.

RAG is for when you want to have current, specific, or private information it wasn’t trained on. Fine-tuning is for when you need the AI to behave differently — to adopt a style, a tone, or a specialisation.

The most capable AI products use both. Fine-tune for behaviour. Use RAG for knowledge. Together they create something that sounds right and knows the right things.

RAG — gives AI new knowledge · dynamic · cheaper
Fine-tuning — changes AI behaviour · permanent · more powerful
Both — the gold standard for serious AI products

And as always, you’ll have to read my opinions

What excites me about fine-tuning isn’t the technology — it’s the implication. A small team with the right data can now build an AI that’s more specialised than anything a large company could have bought five years ago. That’s a genuine shift in who gets to build what.

Until we meet again!

Missed Part 2? Read it here — What is RAG? The plain English guide to giving AI a memory

Part 4 dropping soon — AI Agents. Follow so you don’t miss it.

Quick heads up: this is Part 2 of a series. Part 1 covers LLMs — the thing that makes ChatGPT work. If you skipped it, this will still make sense. It’ll just make more sense if you didn’t.

Large language models, explained simply — no engineering degree required

In Part 1, we established something uncomfortable — LLMs don’t know facts. They know patterns. And sometimes those patterns produce very confident, very wrong answers. So here’s the question nobody answered: if that’s true, how are hospitals, law firms, and banks trusting these things with real decisions?

LLMs are pre-trained on massive, diverse datasets. When given an input, they tokenize the text, convert tokens into vectors (embeddings), and use transformer attention to relate those embeddings and produce the most statistically likely output. However, if relevant information didn’t exist in the model’s training data, the response can be misaligned, misleading, or even a hallucination. This is where RAG comes in. Would you like a shorter or more technical version?

Every LLM has a training cutoff — a date after which it knows nothing. GPT-4’s cutoff is early 2024. Ask it about something that happened last month and it either says it doesn’t know, or fills the gap with a plausible-sounding fiction. For a chatbot recommending movies, that’s fine. For a financial advisor or a doctor, that’s dangerous.

So the problem isn’t the LLM. The problem is that the LLM is working blind. RAG gives it eyes

RAG — Retrieval Augmented Generation — is a technique that gives an LLM access to specific, up-to-date information before it generates a response. Instead of relying only on what it learned during training, it first goes and fetches the relevant information, then answers.

For better understanding — Think of the LLM as a brilliant writer who has read everything — but was locked in a room since last year. RAG is the librarian who, before the writer answers your question, runs out, grabs the most relevant documents, and slides them under the door

So what actually happens when you ask a RAG-powered AI a question?

R — Retrieve

The moment you type your question, the system doesn’t go straight to the LLM. First it searches a knowledge base — a curated collection of documents, PDFs, databases, or web pages that a company has pre-loaded. It finds the most relevant pieces of information for your question. Think of it as a very fast, very specific library search.

A — Augment

Those retrieved pieces of information are then attached to your original question — like a reference pack handed to the LLM alongside your query. The LLM now has your question AND the relevant context it needs to answer it accurately. It’s no longer working blind.

G — Generate

Now the LLM does what it does best — generates a response. But this time it’s grounding its answer in the retrieved documents, not just its training patterns. The result is an answer that’s accurate, current, and traceable back to a real source.

RAG doesn’t make the LLM smarter. It gives the LLM better information to work with. The distinction matters.

Where RAG is being used?

Prime Example — When Perplexity AI answers a question and shows you the exact sources it used — that’s RAG in full view. It retrieved, it used the context, it generated, and it showed its work. This is what makes it more trustworthy than a standard ChatGPT response.

So, RAGs enable responses grounded in up-to-date sources: instead of relying solely on the model’s learned predictions (which can be outdated or incorrect), they retrieve relevant documents and synthesize answers based on that fresh evidence.

But here comes the harsh truth

RAG is not a cure. It’s a significant improvement.

Here’s what it still can’t fix:

• If the knowledge base it retrieves from has outdated or incorrect documents, the LLM will confidently use that bad information. RAG is only as good as the documents it has access to.
• RAG reduces hallucination — it doesn’t eliminate it. The LLM still generates text token by token. If the retrieved context doesn’t fully answer the question, it may still fill the gap with a pattern rather than admitting it doesn’t know.
• If the search component retrieves the wrong documents — or misses the relevant one — the LLM answers confidently based on irrelevant context. The quality of the retrieval step is just as important as the LLM itself.

But as always I’ll share my opinion

RAG is the most practical AI development of the last two years — not because it’s glamorous, but because it’s the first thing that made LLMs actually trustworthy enough for real decisions. Nobody talks about it enough.

A Question for you:

Which would you trust more — a standard ChatGPT answer, or one powered by RAG? And does knowing the difference change anything?

See you soon!!!!!!

Missed Part 1? Start here — Large Language Models, explained simply

Next up — Part 3: What is Fine-tuning? The plain English guide to giving AI a personality

First of all, You don’t need to be an engineer to understand this. In fact, most engineers can’t explain it simply either. But here’s why you should care: the people who understand how this works are already making better decisions with it than everyone else.

LLMs appear in your daily life whenever you use Gmail’s Smart Compose, Grammarly’s suggestions, or Google Search’s AI‑generated answers. You also meet them in chatbots on websites, voice assistants, and tools like Microsoft Copilot that help write emails, documents, or code inside familiar apps.

Large Language Model (LLM) is a type of AI Model that has ability to process natural‑language inputs and generate human‑like responses.

In simpler words: an LLM can read, understand, and generate human language.

• It “reads” text (like a sentence or a question) and converts it into a form the computer can work with.
• It “understands” the meaning and context enough to answer questions, explain ideas, or continue a conversation.
• Then it “writes” back in natural language, choosing the most likely next words to form a coherent reply.

What actually happens when you hit send?

The first thing the model does is tear your sentence apart….

The first thing the model does is break your sentence down into smaller pieces called tokens — a step known as tokenization. This process takes the input text and, depending on the underlying algorithm, splits it into words, subwords, or punctuation units that the model can process numerically.

Let’s say you ask any Generative AI : Hi, How are you?

This input will be torn apart (Tokenized) as:

“Hi” — “,” — “ How” — “ are” — “ you” — “?”

You see how a simple message turned into 6 tokens, and this is just an example how tokens are created out of your inputs.

So now the model has your sentence split into pieces. But here’s the problem — computers don’t understand pieces of text. They only understand numbers. So how does your ‘Hi’ or ‘How’ become something a machine can actually work with?

That’s where embeddings play their part . . .

Now the tokens are converted into a list of numbers (vectors) that captures its meaning and relationships to other words. These are called Embeddings. Instead of dealing with raw text such as “king” or “apple” , the model converts each piece into a list of numbers (a vector) that captures its meaning and relationships to other words.

Now if we just revisit the Tokens we had, their Embeddings will be as follows:

“Hi” — “,” — “ How” — “ are” — “ you” — “?”
12194, 11, 3253, 553, 481, 30

The numbers mapped to tokens (the embeddings) are not completely random, but they are initially chosen in a structured, learnable way and then adjusted during training. These values depend entirely on the specific model and its training process, so different models will assign different numerical vectors to the same token.

So now the model has a long list of numbers. But numbers alone mean nothing without context. ‘Hi’ and ‘Hello’ are two separate numbers — but the model needs to know they belong together, and that together they mean something specific. How does it figure that out?

Here comes the role of Transformers

Think of it like a room full of people where everyone is talking to everyone else simultaneously. Each word in your sentence is "asking" every other word — how relevant are you to me? The word "bank" asks "river" and "money" and "account" — and based on your full sentence, decides which one matters. This mechanism is called self-attention, and it's what makes modern LLMs dramatically better than everything that came before them.

By the time your sentence has passed through the Transformer, every single token is no longer just a number. It's a number that understands its relationship to every other number in the sentence. Now all the embeddings are very well aware of their relation with others.

This context-aware output is what gets handed to the next stage — where the model finally generates a response.

So now the model has your sentence — fully broken down, converted to numbers, and loaded with context. You’d expect it to now “think” of an answer and write it out. But that’s not what happens.

It predicts one word at a time.

The model looks at everything you’ve written, asks “what word most likely comes next?” — picks one, adds it to the sequence, then repeats the exact same process. Over and over, word by word, until the response is complete. There’s no plan. No outline. No destination in mind. Just one prediction at a time, each one informed by everything that came before it.

There’s actually a setting behind this called temperature. Low temperature means the model plays it safe — picking the most statistically likely word every time. High temperature means it takes risks — picking less obvious words, which makes responses feel more creative, but also less reliable. When ChatGPT sounds poetic, someone turned that dial up.

But here’s the part that changes how you should think about these tools forever:

This is exactly why LLMs make things up. They’re not lying. They’re not guessing randomly. They’re doing precisely what they were built to do — predicting the most statistically likely next word. Sometimes that prediction is a fact. Sometimes it’s a very confident-sounding fiction. The model cannot tell the difference between the two.

Here’s what’s wild — the model that writes your cover letter and the one that passed the bar exam are doing the exact same thing. Predicting the next token. Nothing more, nothing less.

So Now, We can bust some Myths about LLM

• It is not searching the internet. Unless explicitly connected to a search tool, an LLM has no idea what happened yesterday.
• It is not thinking. There’s no reasoning happening in the way your brain reasons
• It is not remembering you. Every new conversation starts completely blank.

Last but not the least

My Opinion

I find it more exciting — not less — knowing that there’s no magic here. Just math, scale, and a lot of clever engineering. That’s somehow more impressive than magic

And A Question for you guys,

Now that you know it’s predicting words, not thinking — will you use it differently?

This is Part 1 of the “AI in Plain English” series. Next up — Part 2: What is RAG? The plain English guide to giving AI a memory

In today’s digital era, securing our data and confidential information is nothing less than a paramount. Ensuring that only authorized bodies can access our secured resources is a top most priority.

Today we’ll be generating and verifying JWT Token using NodeJS and JWT. So Let’s Dive in 🔥

Tools We’ll be using are as follows

• VSCode — Code Editor 🟦
  https://code.visualstudio.com/
• Insomnia- For testing our APIs (You can use postman too) 🟪
  https://insomnia.rest/

Languages and Frameworks

• NodeJS- For creating our server and handling requests and responses using Typescript/Javascript
  https://nodejs.org/en

Starting up with Dependencies

• Making project directory and initializing our project

mkdir tokenapi
npm init

• Installing dependencies

npm install express body-parser jsonwebtoken

Let’s Create our server

• Open the project directory inside VSCode
• Create a file named index.js
• Let’s start with importing the required dependencies in index.js file

const express = require('express')
const bodyparser = require('body-parser')
const jwt = require('jsonwebtoken')

• Initializing Express server using express dependency

const app = express() // Application object over which our server will be working on
const port = 1973//Server port

app.use(bodyparser.urlencoded({extended: false}));
app.listen(port,()=>{
    console.log('Listening to port',port) 
})

Defining Routes for Generating and Verifying our Tokens

• For Generating Token

app.post("/generateToken", (req, res) => {
    let data = {
        time: Date(),
        tokenId : 1
    }
    const token = jwt.sign(data, 'secret-key');
    res.json({'secret-key' : token})
});

• For Validating Token

app.get("/validateToken", (req, res) => {
    try {
        const token = req.header("token");
        const verified = jwt.verify(token, 'secret-key');
        if(verified){
            return res.json({'result' : 'Token verified successfully'})
        }else{
            return res.json({'result' : 'Token verification failed'})
        }
    } catch (error) {
        console.log(error)
        return res.json({'result' : 'Something went wrong'})
    }
});

Testing our APIs

• Get Token using generateToken Request

• Verifying Token using validateToken Request

Conclusion

JWT token validation is a crucial aspect of securing your Node.js applications. By following these steps, you can implement JWT-based authentication and authorization to protect your resources and ensure that only authorized users can access them. Remember to keep your secret keys secure and consider using libraries and best practices for enhanced security.

Hey Folks! Today, we’re going to dive into the world of backend development and explore how we can create a CRUD (Create, Read, Update, Delete) API using Node.js, Express, and PostgreSQL. CRUD operations are like the backbone of many web applications out there as they enable you to create, read, update, and delete data from database. So without wasting time, Let’s dive in! 💚🚀

Tools We’ll be using are as follows

• VSCode — Code Editor 🟦
  https://code.visualstudio.com/
• Insomnia- For testing our APIs (You can use postman too) 🟪
  https://insomnia.rest/
• pgAdmin- For easily accessing our database using graphical inteface provided by PostgreSQL (Optional)
  https://www.postgresql.org/

Languages and Frameworks

• NodeJS- For creating our server and handling requests and responses using Typescript
  https://nodejs.org/en
• SQL- For creating our database

Before continuing further, make sure you have all these tools installed on your system

Starting up with Dependencies

• Making project directory and initializing our project

mkdir shoppingapi
npm init

• Installing dependencies

npm install express body-parser pg

Setting up our database

• Creating and Connecting to our database

psql
CREATE database shoppingapi
\c shoppingapi

• Creating table inside our database

CREATE TABLE product(
  id serial PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  price VARCHAR(255) NOT NULL
);

• id: A unique serial integer acting as our primary key to uniquely identify items.
• name: A text column for the product's name, which cannot be null.
• price: A text column for the product's price, which cannot be null.

Let’s Create our server

• Open the project directory inside VSCode
• Create a file named index.ts
• Importing the required dependencies

import Express, { Application, Request, Response  } from "express";
import bodyparser from 'body-parser';

• Initializing Express server using express dependency

const app: Application = Express() // Application object over which our server will be working on
const port = 8000 //Server port

app.use(bodyparser.json()) //Using body-parser for JSON parsing and other stuffs
app.use(
    bodyparser.urlencoded({
    extended: true,
  })
)

• Running our server

app.listen(port,()=>{
    console.log('Listening to port',port)
    initDB();
})

• We are all set with our server so now let’s connect our database for implementing CRUD operations

Connecting PostgreSQL database to our server

• Create a file named dbservice.ts where we will be inserting all database related functions
• Import Client from PG dependency and initializing our database client request

import {Client} from 'ts-postgres'
const pool = new Client(
    {
        user: 'YOUR USERNAME',
        password: 'YOUR PASSWORD',
        database: 'YOUR DATABASE NAME',
        host: 'localhost',
        port: 'YOUR PORT' (5432 is default port)
    }
);
//initDB function to connect to our Database once before making requests
export const initDB =async function(){
  await pool.connect();
}

• Implementing CRUD Operations

//GET ALL PRODUCTS FROM PRODUCTS TABLE
export const getAllProductQuery = async function () {
    return new Promise(async function (resolve, reject) {
       try{
        const result = await pool.query('SELECT * FROM products');
        resolve(result.rows);
       }
       catch(e){
        console.log('Error -- $e',[e])
        reject(e);
       }        
 })}

//GET SINGLE PRODUCT FROM PRODUCT TABLE BY USING PRODUCT'S ID
export const getProductViaId = async function (id:number) {
    console.log(id);
    return new Promise(async function (resolve, reject) {
       try{
        const result = await pool.query('SELECT * FROM products WHERE id = $1', [id])
        resolve(result.rows);
       }
        catch(e){
            console.log('Error -- $e',[e])
            reject(e);
        }
}

//INSERTING A PRODUCT TO PRODUCT TABLE
export const insertProduct = function (productName:string,productPrice:string) {
    return new Promise(async function (resolve, reject) {
        try{
            const result = await pool.query('INSERT INTO products (name,price) VALUES($1,$2) RETURNING *', [productName,productPrice])
            resolve(result.rows);
        }
        catch(e){
            console.log(e);
        }
    });
    
}

//UPDATING A PRODUCT INSIDE PRODUCT TABLE
export const updateProduct = async function (productName:string,productPrice:string,id:number) {
    return new Promise(async function (resolve, reject) {
        try{
            const result = await pool.query('UPDATE products SET name = $1, price = $2 WHERE id = $3', [productName,productPrice,id])
            resolve(result.rows);
        }
        catch(e){
            console.log(e);
            reject(e);
        }    
    });
}

//DELETING A PRODUCT FROM PRODUCT TABLE
export const deleteProduct = async function (id:number) {
    return new Promise(async function (resolve, reject) {
        try{
            const result = await pool.query('DELETE FROM products WHERE id = $1', [id])
            resolve(result.rows);
        }
        catch(e){
            console.log(e);
            reject(e);
        }
    });
}

Defining our Routes

• Create a file named routes.ts where we will be defining our routes

import {deleteProduct, getAllProductQuery, getProductViaId, insertProduct, updateProduct} from './dbservice';
import { Response,Request } from 'express';

//[GET] -- ALL PRODUCTS ROUTE
export const allProductsRoute = (req:Request,res: Response)=>{
   getAllProductQuery().then((value)=>{
    res.status(200).json(value);
    console.log(value);
   });       
}


//[GET] -- GET PRODUCT BY ID ROUTE
export const getProductById = (req:Request,res: Response)=>{
    const id = parseInt(req.params.id)
    getProductViaId(id).then((value)=>{
        res.status(200).json(value);
    });
}

//[POST] -- INSERT PRODUCT ROUTE
export const insertProductRoute = (req:Request,res: Response)=>{
    const {name,price} = req.body;

    console.log('--- $1 $2 ---',[name,price]);
    if(name && price){
        insertProduct(name,price).then((value)=>{
            res.status(200).json(value);
        });
    }
    else{
        res.status(400).json({
            "error": "Invalid inputs"
        });
    }
}

//[GET] -- UPDATE PRODUCT ROUTE
export const updateProductRoute = (req:Request,res: Response)=>{
    const {name,price} = req.body;
    const id = parseInt(req.params.id);

    console.log('--- $1 $2 ---',[name,price]);
    if(name && price){
        updateProduct(name,price,id).then((value)=>{
            res.status(200).json(value);
        });
    }
    else{
        res.status(400).json({
            "error": "Invalid inputs"
        });
    }
}

//[GET] -- DELETE PRODUCT ROUTE
export const deleteProductRoute = (req:Request,res: Response)=>{
    const id = parseInt(req.params.id);
    if(id){
        deleteProduct(id).then((value)=>{
            res.status(200).json(value);
        });
    }
    else{
        res.status(400).json({
            "error": "Invalid inputs"
        });
    }
}

• Now in our index.ts file we will attach our routes to our express application

app.get('/products', (req: Request,res:Response)=>{
  allProductsRoute(req,res)
})
app.get('/products/:id',(req: Request,res:Response)=>{
  getProductById(req,res)
})
app.post('/insertProduct',(req: Request,res:Response)=>{
  insertProductRoute(req,res)
})

app.put('/updateProduct/:id',(req:Request,res:Response)=>{
  updateProductRoute(req,res)
})

app.delete('/deleteProduct/:id',(req:Request,res:Response)=>{
  deleteProductRoute(req,res);
})

Testing our CRUD API

• Start the server by running following command

npm start

• Open Postman/Insomnia

Conclusion

Congratulations! You’ve just built a CRUD API using Node.js, Express, and PostgreSQL. This is a fundamental skill for backend development and will serve as the backbone for more complex applications.

Remember, this is just the beginning. You can expand on this project by adding authentication, validation, error handling, and more. The possibilities are endless, so keep exploring and building.

Happy coding, and may your CRUD operations always return the data you expect!💚🚀

Today I will show you how we can modify the standard counter application using the Riverpod State Management package and make it a little modern.

Let’s Look at what Riverpod is…

As stated above, Riverpod is a state management package used to manage the state of an application. In Flutter we have seen packages like provider, getx, bloc, etc.. and just like them, Riverpod is also a package that is used to read or listen to state changes inside an application.

Why Riverpod?[RIVERPOD VS PROVIDER]

The provider is a great package and is preferred everywhere when it comes to state management strategies but the Provider has some disadvantages in it like when we create nested providers we can only access the value of the provider which is nearest or closest. For example :

class Home extends StatelessWidget{

Widget build(BuildContext context){

return Provider(

create : (context)=> ‘FAR’

child Provider(

create : (context)=> ‘CLOSE’

builder(context,child){

return Text(Provider.of<String>(context);

}

)

);

}

Wait! if you don't know how to use providers I have already made a blog on that in which I made this application using provider so you can have a look at that :

The Evolution of Counter App Using Provider in Flutters

So in the above code, we have 2 providers which are providing different strings and we want to print those strings but in this case, we can only print ‘CLOSE’ because it's the nearest or the closest and that’s where we observe a small but noticeable disadvantage of the provider and also provider always shows error in runtime. Hence, to get rid of this we can use riverpod because it provides us with global providers hence we don’t have to attach providers to widgets or UI, rather than this, we will declare a provider globally and use it where we need but How?

First thing first let’s make a flutter project which will provide us the Standard Counter Application. So run the command written below

flutter create riverpodtutorial

So first of all let’s just remove all the boilerplate code(comments) which come whenever we make a project with flutter and then convert the MyHomePage class from stateful to stateless. Now let’s apply riverpod to the application but before that add the latest version available of the flutter_riverpod package to our pubspec.yaml file.

flutter_riverpod : ^latest_version

So as I described above we will declare a global provider but before that, we will make a file named counterValue.dart that will have 3 very important things :

1. Counter Value
2. Increment Function
3. Decrement Function

And it will look like this :

import ‘package:flutter/cupertino.dart’;

import ‘package:flutter/foundation.dart’;

class CounterValue extends ChangeNotifier {

int counter = 0;

int get getCounterValue => counter;

void increment() {

counter += 1;

notifyListeners();

}

void decrement() {

counter -= 1;

notifyListeners();

}

}

Now we can declare a provider which will listen to the value of the counter and will be able to call both of these functions. Let’s declare our provider below main() function like this :

void main(){

runApp(MyApp());

}

final counterProvider = ChangeNotifierProvider((ref)=>CounterValue());

Now we can use this counterProvider anywhere in our project so let’s use it and modify the counter app. We will add a ProviderScope to our MaterialApp and then we will be able to use the provider inside of our application.

class MyApp extends StatelessWidget {

@override

Widget build(BuildContext context) {

return ProviderScope(

child: MaterialApp(

title: ‘Flutter Demo’,

debugShowCheckedModeBanner: false,

theme: ThemeData(

primarySwatch: Colors.green,

),

home: MyHomePage(),

),

);

}

}

Now inside our HomePage class, we will cut the Text widget which shows the counter value, and replace it with a Consumer, and inside the consumer’s builder, we will paste that Text widget.

Consumer(

builder: (builder, counter, child) {

final count = counter(counterProvider);

return Text(count.counter.toString(),

style: Theme.of(context).textTheme.headline4);

},

),

And thereafter we will make two floating buttons and call those increment and decrement functions we created above.

Row(

mainAxisAlignment: MainAxisAlignment.center,

children: [

FloatingActionButton(

onPressed: () {

context.read(counterProvider).increment();

},

tooltip: ‘Increment’,

child: Icon(Icons.exposure_plus_1),

),

SizedBox(

width: 20,

),

FloatingActionButton(

onPressed: () {

context.read(counterProvider).decrement();

},

tooltip: ‘Decrement’,

child: Icon(Icons.exposure_minus_1),

),

],

)

And that’s it we have applied Riverpod to our application so let’s have a look at the complete code of this app.

import ‘dart:developer’;

import ‘package:flutter/material.dart’;

import ‘package:flutter_riverpod/flutter_riverpod.dart’;

import ‘package:pro/counterValue.dart’;

void main() {

runApp(MyApp());

}

final counterProvider = ChangeNotifierProvider((ref) => CounterValue());

class MyApp extends StatelessWidget {

@override

Widget build(BuildContext context) {

return ProviderScope(

child: MaterialApp(

title: ‘Flutter Demo’,

debugShowCheckedModeBanner: false,

theme: ThemeData(

primarySwatch: Colors.green,

),

home: MyHomePage(),

),

);

}

}

class MyHomePage extends StatelessWidget {

@override

Widget build(BuildContext context) {

return Scaffold(

appBar: AppBar(

centerTitle: true,

title: Text(‘Simple Counter Application’),

),

body: Center(

child: Column(

mainAxisAlignment: MainAxisAlignment.center,

children: <Widget>[

Text(

‘You have pushed the button this many times:’,

),

Consumer(

builder: (builder, counter, child) {

final count = counter(counterProvider);

return Text(count.counter.toString(),

style: Theme.of(context).textTheme.headline4);

},

),

SizedBox(

height: 20,

),

Row(

mainAxisAlignment: MainAxisAlignment.center,

children: [

FloatingActionButton(

onPressed: () {

context.read(counterProvider).increment();

},

tooltip: ‘Increment’,

child: Icon(Icons.exposure_plus_1),

),

SizedBox(

width: 20,

),

FloatingActionButton(

onPressed: () {

context.read(counterProvider).decrement();

},

tooltip: ‘Decrement’,

child: Icon(Icons.exposure_minus_1),

),

],

)

],

),

),

);

}

}

So we have done it, We added Riverpod to the oldskool counter application and modified that into a modern counter application.

That’s it, for now, we will meet in the next blog. Bye Bye…..

Flutter was unveiled at the 2015 Dart developer summit with the stated intent of being able to render consistently at 120 fps. During the keynote of Google Developer Days in Shanghai, Google announced Flutter Release Preview 2, which is the last big release before Flutter 1.0. On December 4, 2018, Flutter 1.0 was released at the Flutter Live event, denoting the first “stable” version of the Framework.

Flutter can be downloaded from flutter. dev and installed by following simple steps provided at the website or you can also install it (if on windows) by watching this video => https://www.youtube.com/watch?v=5Ga1cLW2S-U

So! Let’s Get onto our topic!

Flutter provides a simple counter application whenever you execute the below command for creating a new project with flutter

flutter create projectname

Our today’s task will be to use the provider package inside of this pre-created counter application. Hence, first of all, we will have to add the provider package in our pubspec.YAML file like this

provider : ^5.0.0

After adding the provider package to our pubspec.YAML let’s get onto our main. dart file and cook some code.

First of let’s edit the MyApp class of the pre-created counter application.

We first add our whole MaterialApp inside a ChangeNotifierProvider which will listen to our counter value. Then let’s quickly remove the title variable inside MyHomePage class and also because now we have immortal powers of the provider package let’s convert that class from StatefulWidget to StatelessWidget. It will look like this

class MyApp extends StatelessWidget {

@override

Widget build(BuildContext context) {

return ChangeNotifierProvider(

create: (_) => CounterValue(),

child: MaterialApp(

title: ‘Flutter Demo’,

theme: ThemeData(

primarySwatch: Colors.blue,

),

home: MyHomePage(),

),

);

}

}

And after that let’s create a new file named counterValue.dart which will have our counter variable and two very special increment and decrement functions using which we will increment and decrement values of our counter variable. This file will have a CounterValue class which will extend ChangeNotifier so that we can notify our listeners about the changes happening to the value of the counter variable. So this is what our CounterValue class will look like

class CounterValue extends ChangeNotifier {

int counter = 0;

int get getCounterValue => counter;

void increment() {

counter += 1;

notifyListeners();

}

void decrement() {

counter -= 1;

notifyListeners();

}

}

So that’s it, Now let’s use this variable value as well as both functions to complete our version of the counter application. First thing first let’s add two buttons, one for incrementing counter value and the second for decrementing the same. Next, let’s move on to our MyHomePage class which will have a text widget that will show the current value of the counter hence, let’s put it inside a Consumer of type CounterValue so that it can consume our counter value from CounterValue class we’ve just made. Also, we will make a final variable called counterProvider that will be equal to

final counterProvider = Provider.of<CounterValue>(context, listen: false);

And After that, we are ready to rock with this MyHomePage class

class MyHomePage extends StatelessWidget {

@override

Widget build(BuildContext context) {

final counterProvider = Provider.of<CounterValue>(context, listen: false);

return Scaffold(

appBar: AppBar(

title: Text(‘Provider’),

),

body: Center(

child: Column(

mainAxisAlignment: MainAxisAlignment.center,

children: <Widget>[

Text(

‘You have pushed the button this many times:’,

),

Consumer<CounterValue>(

builder: (context, data, child) {

return Text(‘${data.counter}’,

style: Theme.of(context).textTheme.headline4);

},

),

SizedBox(

height: 20,

),

Row(

mainAxisAlignment: MainAxisAlignment.center,

children: [

FloatingActionButton(

onPressed: () {

counterProvider.increment();

},

tooltip: ‘Increment’,

child: Icon(Icons.exposure_plus_1),

),

SizedBox(

width: 20,

),

FloatingActionButton(

onPressed: () {

counterProvider.decrement();

},

tooltip: ‘Decrement’,

child: Icon(Icons.exposure_minus_1),

),

],

)

],

),

),

// This trailing comma makes auto-formatting nicer for build methods.

);

}

So that’s it we are done with adding provider to flutter’s pre-created counter application. We have added more functionalities to it by giving it the powers to increment and decrement the counter value with the help of our new and loyal friend Provider.

Last but not the least Don’t forget to like, share and follow.