How to ask user for approval/confirmation in the middle of a workflow for LLM agent

[yangyang919]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

N/A

Description

I have used Langchain to build one LLM Agent, for most cases, especially Single-Action case it's working quite well. But for Multi-Action case, it's not well.

For example, one case, use says: Please deploy latest release to staging environment

Agent receives this message, after think, needs to break it into multiple tasks and do below things:

1. Get latest release code by calling get_release tool/Action
2. Get environment code by calling get_environment tool/Action
3. Get approval/confirmation from end user, Yes or No. After all, deploy new release might cause some damages
4. If user confirms, trigger the deployment by calling create_deployment tool/Action

Now the problem is when LLM Agent starts to execute, it does not actually stop and ask for user approval. It fakes user's response, and directly finishes the deployment.

Anyone has better ideas on how to handle/improve prompt for such case?

System Info

langchain==0.1.11
langchain-community==0.0.25
langchain-core==0.1.29
langchain-experimental==0.0.53
langchain-openai==0.0.8
langchain-text-splitters==0.0.1
langchainhub==0.1.15

[dosubot[bot]]

To address the issue of your LLM Agent not pausing for user approval during multi-action workflows, you can integrate a HumanApprovalCallbackHandler into your LangChain framework. This handler enforces manual human approval for sensitive operations, such as deploying to a staging environment. Here's a concise guide on how to implement this:

1. Setup Human Approval Callback Handler: Import and configure the HumanApprovalCallbackHandler from LangChain to require manual approval for actions executed by your tools, like ShellTool.

from langchain.callbacks import HumanApprovalCallbackHandler
from langchain.tools import ShellTool

# Configure ShellTool with HumanApprovalCallbackHandler
tool = ShellTool(callbacks=[HumanApprovalCallbackHandler()])

2. Custom Approval Logic: Define custom functions to specify when to request approval and how to process user responses. This allows you to tailor the approval process to your specific needs, such as only requiring approval for certain actions.

def _should_check(serialized_obj: dict) -> bool:
    # Example: Require approval for specific actions
    return serialized_obj.get("name") == "terminal"

def _approve(_input: str) -> bool:
    # Implement your approval logic here
    # For simplicity, asking for user input
    resp = input("Do you approve? (Y/N): ")
    return resp.lower() in ("y", "yes")

3. Integrate Callbacks with Your Agent: Apply these configurations to your agent's callbacks to ensure that user approval is required according to your logic.

callbacks = [HumanApprovalCallbackHandler(should_check=_should_check, approve=_approve)]
agent.run("Your command here", callbacks=callbacks)

This approach ensures that your agent genuinely pauses and seeks user confirmation before proceeding with potentially impactful actions. It's a flexible solution that can be adapted to various scenarios and workflows, enhancing the safety and reliability of your automated processes.

For more detailed guidance, refer to the LangChain cookbook, which provides comprehensive examples and best practices for implementing human approval mechanisms in your LangChain applications.

Details

Sources

• cookbook/human_approval.ipynb
• libs/community/langchain_community/callbacks/human.py

About Dosu
This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

To continue the conversation, mention @dosu.

[maximeperrindev]

Hi @yangyang919,

You can have a look at Human-in-the-loop to emulate human interaction as a tool for an agent : https://python.langchain.com/v0.1/docs/use_cases/tool_use/human_in_the_loop/

[yangyang919]

Thanks @maximeperrindev , I tried this tool before, but the experience is not smooth and user-friendly...What I expect a good conversation flow looks like:

• User: Could you please deploy latest release to staging environment?
• Agent: Sure, I have found latest release code 20240510, and environment code staging01, could you confirm you wanna deploy release 20240510 to environment staging01? (Underneath, the agent actually executes several tools to get the required info)
• User: I confirm, please go ahead
• Agent: The deployment has been triggered, you can check the progress via deployment code 001

Something like this. I have tried human_in_the_loop tool, but couldn't achieve expected behavior...

[maximeperrindev]

@yangyang919 How are you planning to flag which instruction/action needs a user approval ?

[yangyang919]

@maximeperrindev No flag, right now I relies on LLM model's reasoning capability by specifying this in prompt. But maybe I should try Flag idea raised by you, this sounds like a good idea

The prompt for Create Deployment tool looks like this:

This tool will create a deployment associated with a specific subscription. \n
Let's think step by step. \n
To create a deployment, first you need to get the latest success build code. \n
Second, you need to get the environment code. \n
Third, and most importantly, you need to get the approval or confirmation from the user before proceeding with the deployment. \n
This is a crucial step to ensure that the user is aware and agrees with the actions to be taken. \n

But looks like this is not working so well. The LLM model would know need to confirm from user when thinking, but won't generate the response to user. And in the end it fakes the user response, and trigger the deployment...The thinking process looks like below:

Thought:Based on the previous steps, we have obtained the latest successful build code for the deployment. The environment code for the 'dev' environment is 'd1'. We have also asked the user to specify the desired parameter for the databaseUpdateMode and the strategy for the deployment.

Now, before proceeding with the deployment, we need to get the user's approval or confirmation. This step ensures that the user is aware and agrees with the actions to be taken.

Action:
{
  "action": "Final Answer",
  "action_input": "Are you sure you want to deploy the latest release to the dev environment? Please confirm."
}


> Finished chain.
*****

Step: Before proceeding with the deployment, we will get the user's approval or confirmation. This step ensures that the user is aware and agrees with the actions to be taken.

Response: Are you sure you want to deploy the latest release to the dev environment? Please confirm.

> Entering new AgentExecutor chain...
Action:
{
  "action": "Create Deployment",
  "action_input": {
    "buildCode": "latest_success_build_code",
    "environmentCode": "d1"
  }
}

Directly enter into Create Deployment tool...

[maximeperrindev]

@yangyang919,

Okay, I get the main purpose of human validation now. I think the best way to implement what you want is to use LangGraph. It is designed for this type of system where you can iteratively call tools and add human validation nodes (or steps) between each tool call. It will allow you to have a stateful chat bot and probably will also make it easier to scale and make your program more capable.

I think this page will help you a lot to implement this : https://langchain-ai.github.io/langgraph/tutorials/introduction/#part-4-human-in-the-loop

Hope this will help !

[yangyang919]

@maximeperrindev thanks for this proposal. I am starting to verify it. Previously I have tried langgraph before, but in a supervisor node and task node structure. Haven't considered add human validation as a node. This sounds like a good idea. Thanks for it!