Ollamafunction. How to get required inputs from User for "required" field in tools. How to prompt user till intuitively if the "required" field is not populated.

[Amogh1506]

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

.

Description

I am using Ollamafunction. How to intuitively get the required inputs from User for "required" field in tools. Example of 'get_weather' tool where location is 'required'. But if I ask, give me the weather info, it should ask about the location since I have not given it. I am using ollama, langchain, lamma3. I don't want to put hardcoding like if no location, then ask.

System Info

Windows

[dosubot[bot]]

Hey there, @Amogh1506! I'm a bot designed to help you with bug fixes, answer your questions, and guide you on becoming a contributor. I'm here to assist you while waiting for a human maintainer.

To intuitively prompt the user for required inputs in the "required" field of tools, such as location in the 'get_weather' tool, without hardcoding conditions, you can use the OllamaFunctions class from LangChain along with the HumanInputRun tool. Here's how you can set it up:

1. Initialize the OllamaFunctions model:

   from langchain_experimental.llms.ollama_functions import OllamaFunctions
   
   llm = OllamaFunctions(model="llama3", format="json")

2. Bind the get_current_weather tool with the required parameters:

   llm = llm.bind_tools(
       tools=[
           {
               "name": "get_current_weather",
               "description": "Get the current weather in a given location",
               "parameters": {
                   "type": "object",
                   "properties": {
                       "location": {
                           "type": "string",
                           "description": "The city and state, e.g. San Francisco, CA",
                       },
                       "unit": {
                           "type": "string",
                           "enum": ["celsius", "fahrenheit"],
                       },
                   },
                   "required": ["location"],
               },
           }
       ],
       function_call={"name": "get_current_weather"},
   )

3. Use the HumanInputRun tool to prompt the user for required inputs:

   from langchain_core.tools import HumanInputRun
   
   human_input_tool = HumanInputRun()
   
   def get_user_input(prompt):
       return human_input_tool._run(prompt)
   
   location = get_user_input("Please provide the location for the weather information:")

4. Invoke the model with the user-provided input:

   from langchain_core.messages import AIMessage
   
   response = llm.invoke(f"what is the weather in {location}?")
   print(response)

This setup ensures that the model will prompt the user for the required location input without hardcoding conditions. The OllamaFunctions class and the JSON schema parameters handle the input requirements dynamically, and the HumanInputRun tool ensures the user is prompted correctly ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[Amogh1506]

@dosu, there are many tools (5) and get_weather is one of them. Based on the user inputs model decides which function to call. but within that function if the 'required' args are not given. I would want the model to prompt back to user requesting the required args.

[dosubot[bot]]

To handle multiple tools and dynamically prompt the user for any missing required arguments, you can extend the invoke_tool function to check for missing arguments and use the HumanInputRun tool to prompt the user. Here's how you can set it up:

1. Define the invoke_tool function to handle missing arguments:

   from typing import Any, Dict, Optional, TypedDict
   from langchain_core.runnables import RunnableConfig
   from langchain_core.tools import BaseTool
   from langchain_community.tools.human.tool import HumanInputRun
   
   class ToolCallRequest(TypedDict):
       name: str
       arguments: Dict[str, Any]
   
   def invoke_tool(
       tool_call_request: ToolCallRequest, tools: Dict[str, BaseTool], config: Optional[RunnableConfig] = None
   ):
       tool_name_to_tool = {tool.name: tool for tool in tools}
       name = tool_call_request["name"]
       requested_tool = tool_name_to_tool[name]
       
       # Check for missing arguments
       missing_args = [arg for arg in requested_tool.args if arg not in tool_call_request["arguments"]]
       if missing_args:
           # Prompt the user for missing arguments
           human_input_tool = HumanInputRun()
           for arg in missing_args:
               user_input = human_input_tool._run(f"Please provide the following missing argument for the tool '{name}': {arg}")
               tool_call_request["arguments"][arg] = user_input
       
       return requested_tool.invoke(tool_call_request["arguments"], config=config)

2. Initialize the tools and bind them to the model:

   from langchain_experimental.llms.ollama_functions import OllamaFunctions
   
   llm = OllamaFunctions(model="llama3", format="json")
   
   tools = [
       {
           "name": "get_current_weather",
           "description": "Get the current weather in a given location",
           "parameters": {
               "type": "object",
               "properties": {
                   "location": {
                       "type": "string",
                       "description": "The city and state, e.g. San Francisco, CA",
                   },
                   "unit": {
                       "type": "string",
                       "enum": ["celsius", "fahrenheit"],
                   },
               },
               "required": ["location"],
           },
       },
       # Add other tools here
   ]
   
   llm = llm.bind_tools(tools=tools, function_call={"name": "get_current_weather"})

3. Invoke the model with the user-provided input:

   tool_call_request = {
       "name": "get_current_weather",
       "arguments": {}  # Initially empty, will be populated by user input
   }
   
   response = invoke_tool(tool_call_request, tools)
   print(response)

This setup ensures that the model will dynamically prompt the user for any missing required arguments for all tools, not just get_current_weather. The HumanInputRun tool is used to collect the missing arguments from the user interactively ^[1][2].

To continue talking to Dosu, mention @dosu.

[Amogh1506]

@dosu When I dont give any argument, it somehow automatically assumes New york! how to ensure that the model asks back for location when the location arg is missing

[dosubot[bot]]

To ensure that the model prompts the user for the location when the location argument is missing, you can modify the setup to include a validation step that checks if the location is provided. If not, it should prompt the user for the location. Here's how you can do it:

1. Modify the tool definitions to include a validation step:

   from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
   from typing import Optional
   
   class GetWeather(BaseModel):
       '''Get the current weather in a given location'''
   
       location: Optional[str] = Field(
           None, description="The city and state, e.g. San Francisco, CA"
       )
   
       @root_validator(pre=True)
       def check_location(cls, values):
           if not values.get('location'):
               raise ValueError("Location is required. Please provide the location.")
           return values
   
   # Define other tools similarly

2. Use the HumanInputRun tool to prompt the user for missing arguments:

   from langchain_community.tools.human.tool import HumanInputRun
   
   human_input_tool = HumanInputRun()
   
   def get_user_input(prompt):
       return human_input_tool._run(prompt)

3. Extend the invoke_tool function to handle missing arguments:

   from typing import Any, Dict, Optional, TypedDict
   from langchain_core.runnables import RunnableConfig
   from langchain_core.tools import BaseTool
   
   class ToolCallRequest(TypedDict):
       name: str
       arguments: Dict[str, Any]
   
   def invoke_tool(
       tool_call_request: ToolCallRequest, tools: Dict[str, BaseTool], config: Optional[RunnableConfig] = None
   ):
       tool_name_to_tool = {tool.name: tool for tool in tools}
       name = tool_call_request["name"]
       requested_tool = tool_name_to_tool[name]
       
       # Check for missing arguments
       missing_args = [arg for arg in requested_tool.args if arg not in tool_call_request["arguments"]]
       if missing_args:
           # Prompt the user for missing arguments
           for arg in missing_args:
               user_input = get_user_input(f"Please provide the following missing argument for the tool '{name}': {arg}")
               tool_call_request["arguments"][arg] = user_input
       
       return requested_tool.invoke(tool_call_request["arguments"], config=config)

4. Initialize the tools and bind them to the model:

   from langchain_experimental.llms.ollama_functions import OllamaFunctions
   
   llm = OllamaFunctions(model="llama3", format="json")
   
   tools = [
       GetWeather(),
       # Add other tools here
   ]
   
   llm = llm.bind_tools(tools=tools)

5. Invoke the model with the user-provided input:

   tool_call_request = {
       "name": "get_current_weather",
       "arguments": {}  # Initially empty, will be populated by user input
   }
   
   response = invoke_tool(tool_call_request, tools)
   print(response)

This setup ensures that the model will prompt the user for the location if it is not provided, rather than assuming a default value like "New York" ^[1].

To continue talking to Dosu, mention @dosu.

[Amogh1506]

@dosu model is already invoked once that has taken incomplete inputs from the user. now how invoke again to ask for missing args?

[dosubot[bot]]

To handle the scenario where the model has already been invoked with incomplete inputs and you need to prompt the user for missing arguments, you can modify the invoke_tool function to check for missing arguments after the initial invocation and then prompt the user accordingly. Here's how you can do it:

1. Define the invoke_tool function to handle missing arguments after the initial invocation:

   from typing import Any, Dict, Optional, TypedDict
   from langchain_core.runnables import RunnableConfig
   from langchain_core.tools import BaseTool
   from langchain_community.tools.human.tool import HumanInputRun
   
   class ToolCallRequest(TypedDict):
       name: str
       arguments: Dict[str, Any]
   
   def invoke_tool(
       tool_call_request: ToolCallRequest, tools: Dict[str, BaseTool], config: Optional[RunnableConfig] = None
   ):
       tool_name_to_tool = {tool.name: tool for tool in tools}
       name = tool_call_request["name"]
       requested_tool = tool_name_to_tool[name]
       
       # Check for missing arguments
       missing_args = [arg for arg in requested_tool.args if arg not in tool_call_request["arguments"]]
       if missing_args:
           # Prompt the user for missing arguments
           human_input_tool = HumanInputRun()
           for arg in missing_args:
               user_input = human_input_tool._run(f"Please provide the following missing argument for the tool '{name}': {arg}")
               tool_call_request["arguments"][arg] = user_input
       
       return requested_tool.invoke(tool_call_request["arguments"], config=config)

2. Initialize the tools and bind them to the model:

   from langchain_experimental.llms.ollama_functions import OllamaFunctions
   
   llm = OllamaFunctions(model="llama3", format="json")
   
   tools = [
       {
           "name": "get_current_weather",
           "description": "Get the current weather in a given location",
           "parameters": {
               "type": "object",
               "properties": {
                   "location": {
                       "type": "string",
                       "description": "The city and state, e.g. San Francisco, CA",
                   },
                   "unit": {
                       "type": "string",
                       "enum": ["celsius", "fahrenheit"],
                   },
               },
               "required": ["location"],
           },
       },
       # Add other tools here
   ]
   
   llm = llm.bind_tools(tools=tools)

3. Invoke the model with the user-provided input and handle missing arguments:

   tool_call_request = {
       "name": "get_current_weather",
       "arguments": {}  # Initially empty, will be populated by user input
   }
   
   # First invocation with incomplete inputs
   initial_response = invoke_tool(tool_call_request, tools)
   print(initial_response)
   
   # Check and prompt for missing arguments, then invoke again
   final_response = invoke_tool(tool_call_request, tools)
   print(final_response)

This setup ensures that after the initial invocation with incomplete inputs, the invoke_tool function will check for any missing required arguments and prompt the user to provide them before invoking the tool again ^[1][2].

To continue talking to Dosu, mention @dosu.