Forem: arunagri82

Adding Human-in-the-Loop (HITL) to Your AI Agent with LangGraph

arunagri82 — Mon, 01 Dec 2025 06:19:47 +0000

Modern AI agents are powerful, but you don’t always want them to act fully on their own.
Sometimes you need a human to review, approve, or correct what the AI is doing — especially for publishing content, sending emails or notifications, or taking actions in production systems.
This pattern is called Human-in-the-Loop (HITL).

In this guide, we’ll see how to build a simple HITL workflow using LangGraph (built on top of LangChain). By the end, you’ll have a working example that lets the AI draft a response, sends that draft to a human for review, and either finalizes or revises the response based on human feedback, looping until the human is happy.

What is LangGraph?
LangGraph is a framework on top of LangChain for building stateful, multi-step workflows with LLMs, tools/APIs, and humans. Instead of writing one long function, you define a graph where each node is a step in your workflow, and edges control the flow. You can add conditions, loops, and retries, which makes it natural to add HITL into your AI agent.
Example: Human Review for AI Responses
We’ll build a small workflow where the user asks a question, the AI drafts an answer, a human reviews the draft, and then either approves or requests changes. If they approve, we finalize the answer. If they suggest changes, the AI revises the answer and sends it back for review, repeating until they approve.

Step 1: Define the Workflow State
We define a shared state object that flows through the graph. Each node reads from and writes to this state. In our case, the state tracks: the user’s original question, the AI’s draft, the human feedback, and the final approved response.
Python state definition:

class HumanInTheLoopState(TypedDict):
    question: str           # User's original question
    ai_draft: str           # AI's current draft
    human_feedback: str     # Human review / comments
    final_response: str     # Final approved response

Step 2: Define the Workflow Nodes
We define separate functions for each step in the process:

draft_response – AI drafts the initial answer.
get_human_feedback – human reviews and either approves or suggests changes.
decide_next_step – decides whether to revise or finalize.
revise_response – AI updates the answer based on feedback.
finalize_response – produces the final, approved response. Each of these functions receives the current state (a dict), prints some helpful information, and returns a dict with the updated fields. Step 3: Wire It Up with LangGraph

We then use StateGraph from LangGraph to connect all the nodes and control execution order. We add nodes, add edges to define the flow, and add a conditional edge from human_review to either revise or finalize, based on human_feedback.
The flow looks like this:
[draft] → [human_review] → (decide)
↓
revise? → [revise] → back to [human_review]
approve? → [finalize] → END

Step 4: Running the Workflow

After compiling the graph using graph.compile(), we call workflow.invoke(initial_state) with an initial state. The system will automatically run through the nodes according to the edges, calling the human review step whenever needed, and looping until the human types 'approve'.
At the end, the final approved response is available in final_state['final_response'], which you can send back to the user or store.
Summary:
In this document we covered:

What Human-in-the-Loop (HITL) means.
How LangGraph lets you build stateful workflows with clear steps and branching.
How to define state, nodes, and conditional edges for a HITL approval loop.
How to adapt the console-based example into a real application UI.

AI for Bharat: Tired of Just Reading About AI? It’s Time to Start Building

arunagri82 — Sun, 23 Nov 2025 18:09:26 +0000

Artificial Intelligence is reshaping industries, accelerating careers, and creating new opportunities every single day. Yet most developers in India are stuck in the same cycle:

👉 Watching tutorials
👉 Saving AI videos
👉 Reading articles

…but not building anything real.

AI for Bharat is here to break that cycle.

This is your chance to join a nationwide movement designed for one purpose:

Turn AI theory into real-world building.

⭐ Program Highlights at a Glance

Before we dive deeper, here’s everything you need to know right away:

👥 Team Size: 1–5 Members

Work solo or collaborate with a small, powerful team.

🎓 Age Requirement: 18+

Anyone above 18 can participate—students, professionals, beginners, all are welcome.

🇮🇳 India Only

A movement built for Indian developers, shaping India’s AI future.

🌐 Fully Online

Participate from anywhere in India—no travel, no barriers.

💰 Prize Pool: INR 40 Lakhs

Massive rewards for innovators who build impactful AI solutions.

A Nationwide Movement to Build India’s Next Generation of AI Builders

AI for Bharat is more than a program—it’s a mission.
A mission to empower Indian developers with hands-on experience, guidance, and real challenges that turn learning into action.

It's designed for anyone who believes India should not just consume AI…
India should create, innovate, and lead with AI.

🔥 Why AI for Bharat?

✓ Practical, Hands-On Learning

No boring lectures. You will build from Day 1 through guided workshops and tool-based sessions.

✓ Real-World AI Challenges

Tackle problems inspired by actual Indian use cases—healthcare, agriculture, governance, accessibility & more.

✓ Build With Industry-Ready Tools

Learn the same tools used by startups, research labs, and AI innovators worldwide.

✓ Work Solo or With a Team

Choose to build alone or collaborate with up to 4 friends or colleagues.

✓ Massive ₹40 Lakhs Prize Pool

Your innovation could directly earn rewards and recognition at a national level.

🧭 Program Structure: Two Power-Packed Phases

🔹 Phase 1 — Learn & Build

Hands-on workshops, guided coding tasks, and real-time tool training.

🔹 Phase 2 — Challenge & Innovate

Compete in structured AI challenges designed to bring out your best.

This program turns:

Curiosity → Skills → Real Projects → AI Innovation

👤 Who Can Join?

Students (18+)
Working professionals
Developers transitioning to AI
Startup founders
Tech enthusiasts
Anyone who wants to start building with AI

No prior AI experience required—only passion and commitment.

🇮🇳 Why India Needs AI for Bharat

India is home to millions of talented developers, but talent alone isn’t enough.
Developers need access, guidance, and opportunities.

AI for Bharat gives you everything:

✔ Real tools
✔ Real practice
✔ Real community
✔ Real rewards

This is how we transform India from an AI consumer into a global AI innovator.

🚀 Stop Reading About AI. Start Building It.

You’ve read enough AI content.
You’ve saved enough tutorials.
Now it’s time to take action.

Thousands of developers across India are already joining.
If you want to be a part of this movement…
If you want to build your first real AI project…
If you want a chance at the ₹40 lakhs prize pool…

👉 This is the moment. Don’t miss it.

🔥 Sign Up Now – Limited Spots

➡️ https://tinyurl.com/yss6xyxc

Take the first step toward becoming one of India’s next AI builders.

Don’t wait. Don’t hesitate. Just start.

Spring Security Flow

arunagri82 — Sun, 23 Nov 2025 17:57:22 +0000

When a user submits login details, Spring Security’s authentication filter intercepts the request and converts it into an Authentication object. This object is then passed to the AuthenticationManager.

The AuthenticationManager decides which authentication method to use (e.g., database authentication, OAuth, LDAP, or custom logic). It forwards the request to the appropriate AuthenticationProvider.

The AuthenticationProvider contains the logic for validating the user. It uses the UserDetailsService to load user information and the PasswordEncoder to verify the password. If authentication succeeds, it returns a fully authenticated Authentication object.

The authentication filter receives the result. If the credentials are valid, Spring Security stores the authentication object in the SecurityContext, which is maintained in the SecurityContextHolder. For every subsequent request, Spring Security checks this context (session or JWT token) to determine whether the user is already authenticated.

If the token or session is valid, the request proceeds; otherwise, the user is denied access.

Mastering Spring Annotations: The Ultimate Guide for Beginners

arunagri82 — Mon, 06 Oct 2025 18:46:17 +0000

@Component Annotation in Spring

The @Component annotation marks a class as a Spring-managed bean.
It is a stereotype annotation, meaning it indicates that the class is a candidate for auto-detection during component scanning.

If a class is not annotated with @Component (or other stereotype annotations like @Service, @Repository, or @Controller), Spring will not register it in the application context.

Functionality

Bean Registration

When a class is annotated with @Component and component scanning is enabled, Spring automatically registers the bean in the application context.

Dependency Injection

Spring can automatically inject the bean into other components where it is required, using @Autowired or constructor injection.

Example:

import org.springframework.stereotype.Component;

@Component
public class ComponentClass {
    // Class implementation here
}

@bean Annotation in Spring

The @bean annotation is a method-level annotation used to explicitly define a Spring bean.
It is typically used when you want to create a third-party or custom object that cannot be annotated directly with @Component.

A method annotated with @bean inside a class annotated with @Configuration tells Spring that the return value of this method should be registered as a bean in the application context.

Example:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public SomeApiClientFromALibrary someClassFromLibrary() {
        return new SomeApiClientFromALibrary();
    }
}

@Configuration Annotation

The @Configuration annotation indicates that a class contains Spring bean definitions.
If a class is annotated with @Configuration, the methods inside it that are annotated with @bean will produce beans managed by the IoC container.

It replaces the old XML-based configuration and provides a type-safe, Java-based configuration approach.

Example:

@Configuration
public class TestConfig {

    @Bean
    public Insert tester() {
        return new Insertion();
    }
}

@ComponentScan Annotation

The @ComponentScan annotation enables component scanning in Spring.
When enabled, Spring automatically detects and registers all the stereotype annotations —
@Controller, @Service, @Component, @Repository, and @Configuration — into the Spring IoC container, making them available for dependency injection.

@PostConstruct Annotation

The @PostConstruct annotation marks a method to be executed after the bean is initialized by Spring.
It is typically used to load or initialize data from an external source after bean creation.

The method must be non-static.

Only one @PostConstruct method is allowed per class.

It can have any access level (public, private, etc.).

Example:

import jakarta.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class PostExample {

    @PostConstruct
    public void postMethod() {
        System.out.println("PostConstruct method executed after bean initialization");
    }
}

@PreDestroy Annotation

The @PreDestroy annotation marks a method to be executed before the bean is destroyed.
It is useful for performing cleanup operations, such as closing connections, clearing caches, or stopping background threads.

Example:

import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class PreDestroyExample {

    @PreDestroy
    public void destruct() {
        System.out.println("PreDestroy method executed before bean destruction");
    }
}

@primary Annotation

The @primary annotation is used when multiple beans of the same type exist in the Spring context.
It tells Spring which bean should be given preference during autowiring.

If a bean is annotated with @primary, that bean will be injected by default when there are multiple candidates.

Example:

public interface Message {
    String message();
}

@Component
public class WhatsApp implements Message {
    @Override
    public String message() {
        return "Hi from WhatsApp";
    }
}

@Component
@Primary
public class Telegram implements Message {
    @Override
    public String message() {
        return "Hello from Telegram";
    }
}

@Component
public class MessageService {

    @Autowired
    private Message msg;

    public String sendMessage() {
        return msg.message();
    }
}

➡ Here, Telegram will be injected because it is marked as @primary.

@Qualifier Annotation

The @Qualifier annotation is used when multiple beans of the same type exist and you want to specify exactly which bean should be injected.

It works alongside @Autowired to disambiguate bean selection.

Example:

public interface Message {
    String message();
}

@Component("whatsapp")
public class WhatsApp implements Message {
    @Override
    public String message() {
        return "Hi from WhatsApp";
    }
}

@Component("telegram")
public class Telegram implements Message {
    @Override
    public String message() {
        return "Hello from Telegram";
    }
}

@Component
public class MessageService {

    @Autowired
    @Qualifier("telegram")
    private Message telegramMessage;

    @Autowired
    @Qualifier("whatsapp")
    private Message whatsappMessage;

    public void displayMessages() {
        System.out.println(telegramMessage.message());
        System.out.println(whatsappMessage.message());
    }
}

➡ Here, @Qualifier("telegram") ensures the Telegram bean is injected.

REST API and Common HTTP Methods

arunagri82 — Sun, 21 Sep 2025 11:29:10 +0000

REST stands for Representational State Transfer. It is a type of API (Application Programming Interface) that helps clients send HTTP requests to a server and receive responses, usually in XML or JSON format.

Commonly Used HTTP Methods

REST APIs typically use the following five common HTTP methods to communicate with servers:

GET
POST
PUT
PATCH
DELETE

GET Method

The GET method is used to retrieve data from the server.

On success, it returns HTTP 200 (OK).

On failure:

404 (Not Found) → Resource does not exist.

400 (Bad Request) → Invalid request.

Example:

GET /user/123

POST Method

The POST method is used to create a new resource in the database.

On success, it returns HTTP 201 (Created).

Example:

POST /user
{
"userId": "1234",
"name": "Siva"
}

PUT Method

The PUT method is used to update an entire resource.

If the resource exists → It is updated.

If the resource does not exist → A new resource is created.

Example:

PUT /user/1234
{
"userId": "1234",
"name": "Kumar"
}

*PATCH Method
*
The PATCH method is used to partially update a resource.

It sends only the fields that need to be modified, instead of replacing the whole resource.

Example:

PATCH /user/1234
{
"name": "Kumar"
}

DELETE Method

The DELETE method is used to remove a resource from the database.

On success, it typically returns HTTP 200 (OK) or 204 (No Content).

Example:

DELETE /user/1234

✅ With these methods, REST APIs make communication between client and server simple, consistent, and standardized.

Understanding the Spring MVC Design Pattern

arunagri82 — Sat, 20 Sep 2025 19:26:17 +0000

Spring MVC internally follows the MVC (Model–View–Controller) design pattern. It divides the application into three parts:

Model – Manages data and business logic.
View – Represents the front-end (such as JSP pages, Thymeleaf templates). It displays information to the user and collects input.
Controller – Acts as an intermediary between the View and the Model. It processes user requests, invokes business logic, and sends data back to the View. In Spring MVC, the @Controller and @RequestMapping annotations are mainly responsible for handling HTTP requests.

Key Components in Spring MVC Pattern

Client
- The browser (or any client) sends an HTTP request.
DispatcherServlet
- Known as the Front Controller.
- This is the entry point of the Spring MVC application.
- It receives every request from the client and delegates it to the right component.
Handler Mapping
- Determines which Controller should handle the incoming request.
Controller
- Connects the View and the Model.
- Handles the client request and invokes business logic from the Model.
Model
- Represents the data and business logic of the application.
View Resolver
- Selects the appropriate View (such as JSP, Thymeleaf).
- In case of a REST controller, the data is returned directly without going through a View.
View
- The final output shown to the user (HTML, JSON, XML, etc.).

Advantages of Spring MVC

Lightweight – Works with a lightweight servlet container.
Separation of concerns – Clear separation between front-end and back-end code.
Loosely coupled – Easy to maintain and extend.
Team-friendly – Multiple developers can work together efficiently (front-end and back-end separately).