Pass variable to chat agent

[juliouyehara]

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

import chainlit as cl
from tools.output_tools import *

@cl.password_auth_callback
def auth_callback(username: str, password: str):
    user_info = USERS.get(username)
    if user_info and user_info["password"] == password:
        cdfazenda = user_info.get("cdfazenda", "Livre") 
        role = user_info.get("role", "user") 
        return cl.User(
            identifier=username, 
            metadata={"cdfazenda": cdfazenda, "role": role}
        )
    else:
        return None


@cl.on_message
async def main(message: cl.Message):

 agent_executor = chain(model = "gemini_1.5_pro", session_id = cl.user_session.get("session_id"))
 response = await loop.run_in_executor(None, agent_executor.invoke, input_data)

Description

I'm using chainlit to build a chatbot, at the beginning of the chat there is a user login, where the cdfazenda variable is included in the metadata, what I want is to pass this variable to the agent to use it in a fixed way, so he doesn't need to interpret in the context what the cdfazenda variable is, so it remains in a fixed form to be used in the tools.

System Info

platform (windows)
python version 3.11

[dosubot[bot]]

To pass the cdfazenda variable to the agent so it can be used in a fixed way, you can include it in the input dictionary when invoking the agent_executor. Here's how you can modify your main function to achieve this:

import chainlit as cl
from tools.output_tools import *
import asyncio

@cl.password_auth_callback
def auth_callback(username: str, password: str):
    user_info = USERS.get(username)
    if user_info and user_info["password"] == password:
        cdfazenda = user_info.get("cdfazenda", "Livre") 
        role = user_info.get("role", "user") 
        return cl.User(
            identifier=username, 
            metadata={"cdfazenda": cdfazenda, "role": role}
        )
    else:
        return None

@cl.on_message
async def main(message: cl.Message):
    user_metadata = cl.user_session.get("metadata", {})
    cdfazenda = user_metadata.get("cdfazenda", "Livre")
    
    agent_executor = chain(model="gemini_1.5_pro", session_id=cl.user_session.get("session_id"))
    
    input_data = {
        "input": message.content,
        "chat_history": [],
        "cdfazenda": cdfazenda  # Pass the cdfazenda variable here
    }
    
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, agent_executor.invoke, input_data)
    
    await message.reply(response)

In this code, the cdfazenda variable is retrieved from the user session metadata and included in the input_data dictionary. This way, the cdfazenda variable is passed to the agent and can be used in a fixed manner within the tools.

Make sure that your agent and tools are designed to handle and utilize the cdfazenda variable from the input data.

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu When I use this solution that you gave me, the error occurs that the prompt does not wait for this variable, and what I want is to always pass it directly to the tool without the need for the agent to interpret the prompt or the user message input.

[dosubot[bot]]

To modify the code to always pass the cdfazenda variable directly to the tool without the agent needing to interpret the prompt or the user message input, you can adjust the agent_executor.invoke method to include the cdfazenda variable directly. Here is how you can do it:

import chainlit as cl
from tools.output_tools import *
import asyncio

@cl.password_auth_callback
def auth_callback(username: str, password: str):
    user_info = USERS.get(username)
    if user_info and user_info["password"] == password:
        cdfazenda = user_info.get("cdfazenda", "Livre") 
        role = user_info.get("role", "user") 
        return cl.User(
            identifier=username, 
            metadata={"cdfazenda": cdfazenda, "role": role}
        )
    else:
        return None

@cl.on_message
async def main(message: cl.Message):
    user_metadata = cl.user_session.get("metadata", {})
    cdfazenda = user_metadata.get("cdfazenda", "Livre")
    
    # Modify the agent to always use cdfazenda
    agent = (
        {
            "input": lambda x: cdfazenda,  # Always pass cdfazenda
            "agent_scratchpad": lambda x: convert_intermediate_steps(
                x["intermediate_steps"]
            ),
        }
        | prompt.partial(tools=convert_tools(tool_list))
        | model.bind(stop=["</tool_input>", "</final_answer>"])
        | XMLAgentOutputParser()
    )

    agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True)

    # Invoke the agent without needing to pass user input
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(None, agent_executor.invoke, {"input": ""})
    
    await message.reply(response)

In this modification, the input lambda function is set to always return the cdfazenda variable, ensuring that it is passed directly to the tool. Additionally, you can adjust the FORMAT_INSTRUCTIONS and SUFFIX in the LangChain framework to ensure the cdfazenda is always included in the input:

FORMAT_INSTRUCTIONS = """Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).

Valid "action" values: "Final Answer" or {tool_names}

Provide only ONE action per $JSON_BLOB, as shown:

{{{{
"action": $TOOL_NAME,
"action_input": $INPUT
}}}}

Follow this format:

Question: input question to answer
Thought: consider previous and subsequent steps
Action:

$JSON_BLOB

Observation: action result
... (repeat Thought/Action/Observation N times)
Thought: I know what to respond
Action:

{{{{
"action": "Final Answer",
"action_input": "Final response to human"
}}}}

SUFFIX = """Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation:.
Thought:"""

This ensures that the cdfazenda variable is always part of the input message processed by the agent ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.