Agent calling two or more tools at same time

[juliouyehara]

I would like to know if there is a way to call two tools in a user input using the structured chat agent, for example in the input the user to perform two procedures that require two different tools, and the agent identifies and activates these two tools in the same input.

[dosubot[bot]]

I found some relevant information regarding your question. The structured chat agent in LangChain can handle multiple tool invocations in a single user input using a multi-hop approach. This allows the agent to use multiple tools in sequence to complete a task. Each action is specified in a separate JSON blob, like this:

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

The agent processes the input by repeating the Thought/Action/Observation cycle multiple times if necessary, with each action encapsulated in its own JSON blob. This ensures that the agent handles each tool invocation separately and sequentially ^[1][2][3].

Additionally, there was a similar closed issue where it was suggested to modify the agent's iteration logic to include a decision-making process about whether to use a tool, which can help in managing multiple tool calls effectively ^[4].

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu But in a practical way, how can I use two tools at the same time in an input, for example, I want the numbers 3 and 4 to be added, multiplied, and these commands to be executed using two different tools?

[dosubot[bot]]

Yes, you can implement this solution using a structured chat agent in LangChain. The structured chat agent can handle multiple tool invocations in a single input by using a multi-hop approach, allowing the agent to use multiple tools in sequence to complete a task.

Regarding calling tools without looping, while the document does not explicitly mention a method to prevent looping, it describes setting up a tool-calling agent using the create_react_agent function. This setup allows the agent to decide when to use tools based on the input it receives, implying that the agent can choose not to use tools for every query. Additionally, you can use the AgentExecutor or write a custom execution loop to manage tool calls, providing more control over when and how tools are invoked, potentially reducing unnecessary looping by customizing the execution logic ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu Show me a way to make the structured chat agent call to or more tools in in a single input

[dosubot[bot]]

To make a structured chat agent call two or more tools in a single input using LangChain, you can follow these steps:

1. Define Your Tools: Create the tools you want to use. For example, you can define tools for addition, multiplication, and exponentiation.

   from langchain_core.tools import tool
   
   @tool
   def add(first_int: int, second_int: int) -> int:
       "Add two integers."
       return first_int + second_int
   
   @tool
   def multiply(first_int: int, second_int: int) -> int:
       "Multiply two integers together."
       return first_int * second_int
   
   @tool
   def exponentiate(base: int, exponent: int) -> int:
       "Exponentiate the base to the exponent power."
       return base**exponent
   
   tools = [multiply, add, exponentiate]

2. Create a Tool Calling Agent: Use the create_tool_calling_agent function to create an agent that can use these tools.

   from langchain import hub
   from langchain.agents import AgentExecutor, create_tool_calling_agent
   from langchain_openai.chat_models import ChatOpenAI
   
   llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
   prompt = hub.pull("hwchase17/openai-tools-agent")
   
   agent = create_tool_calling_agent(llm, tools, prompt)

3. Execute the Agent: Use the AgentExecutor to execute the agent with the input that requires multiple tool calls.

   agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
   
   result = agent_executor.invoke(
       {
           "input": "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result"
       }
   )

This setup allows the agent to decide how many times to use the tools and in what order, based on the input provided ^[1].

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu but using the structured chat agent when i input a message ask for using two tools, he only select one to use

[dosubot[bot]]

To make the structured chat agent use two tools simultaneously, you can use an agent that allows for multiple tool invocations. The AgentExecutor can handle multiple tools by executing them in sequence based on the input. Here's how you can set it up:

1. Define Your Tools: Create the tools you want to use, such as multiply, add, and exponentiate.

2. Create a Tool Calling Agent: Use the create_tool_calling_agent function with your language model and tools.

3. Execute the Agent: Use AgentExecutor to execute the agent with the tools.

Here's a code snippet demonstrating this setup:

from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool

@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int

@tool
def add(first_int: int, second_int: int) -> int:
    "Add two integers."
    return first_int + second_int

@tool
def exponentiate(base: int, exponent: int) -> int:
    "Exponentiate the base to the exponent power."
    return base**exponent

tools = [multiply, add, exponentiate]

# Get the prompt to use
prompt = hub.pull("hwchase17/openai-tools-agent")

# Construct the tool calling agent
agent = create_tool_calling_agent(llm, tools, prompt)

# Create an agent executor by passing in the agent and tools
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Invoke the agent with a complex input that requires multiple tool uses
agent_executor.invoke(
    {
        "input": "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result"
    }
)

This setup allows the agent to decide how many times to use the tools and in what order, effectively enabling the use of multiple tools simultaneously ^[1].

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu Recently I have been facing a Pydantic error, in the tool I declare a variable, for example observation: list[str] = None. It is not mandatory, when this information is not sent, the agent returns it as observation: "", which generates an error since I defined it as a list[str], how can I avoid this error?

{
  "action": "input_aptidao",
  "action_input": {
    "cdfazenda": "26250",
    "numero": ["1121", "5465", "548", "4488", "64830"],
    "data": ["31/10/2024", "30/10/2024", "27/10/2024", "31/10/2024", "28/10/2024"],
    "peso": ["500", "350", "150", "320", "440"],
    "observacao": ""
  }
}
```1 validation error for input_aptidao
observacao
  Input should be a valid list [type=list_type, input_value='', input_type=str]
    For further information visit https://errors.pydantic.dev/2.9/v/list_type

[dosubot[bot]]

To avoid the Pydantic error when a field is expected to be a list but is provided as an empty string, you can set a default value for the field using Field with default_factory. This ensures that if the field is not provided or is given as an empty string, it defaults to an empty list. Here's how you can modify your Pydantic model:

from pydantic import BaseModel, Field
from typing import List, Optional

class InputAptidao(BaseModel):
    cdfazenda: str
    numero: List[str]
    data: List[str]
    peso: List[str]
    observacao: List[str] = Field(default_factory=list)  # Use default_factory to ensure a list

# Example usage
input_data = {
    "cdfazenda": "26250",
    "numero": ["1121", "5465", "548", "4488", "64830"],
    "data": ["31/10/2024", "30/10/2024", "27/10/2024", "31/10/2024", "28/10/2024"],
    "peso": ["500", "350", "150", "320", "440"],
    "observacao": ""  # This will be converted to an empty list
}

input_aptidao = InputAptidao(**input_data)
print(input_aptidao)

By using Field(default_factory=list), you ensure that observacao defaults to an empty list if not provided or if an empty string is passed, thus avoiding the validation error.

To continue talking to Dosu, mention @dosu.

[juliouyehara]

@dosu Now i geting another error

{
 "action": "input_inseminacao_cobertura",
 "action_input": {
  "cdfazenda": "26250",
  "numero": [],
  "data": [],
  "numeroreprodutor": [],
  "cio": []
 }
}
```8 validation errors for input_inseminacao_cobertura
cdloteproduto
  Field required [type=missing, input_value={'cdfazenda': '26250', 'n...rodutor': [], 'cio': []}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.9/v/missing

[dosubot[bot]]

Parece que o erro atual está relacionado a um campo obrigatório chamado cdloteproduto que não está sendo fornecido no seu JSON de entrada. Para resolver esse problema, você precisa garantir que todos os campos obrigatórios definidos no seu modelo Pydantic estejam presentes no JSON de entrada.

Você poderia verificar se o campo cdloteproduto está definido como obrigatório no seu modelo Pydantic? Se sim, você precisa incluí-lo no action_input com um valor apropriado. Se ele não for necessário, você pode torná-lo opcional no seu modelo Pydantic. Aqui está um exemplo de como torná-lo opcional:

from pydantic import BaseModel, Field
from typing import List, Optional

class InputInseminacaoCobertura(BaseModel):
    cdfazenda: str
    numero: List[str]
    data: List[str]
    numeroreprodutor: List[str]
    cio: List[str]
    cdloteproduto: Optional[str] = None  # Torne o campo opcional

# Exemplo de uso
input_data = {
    "cdfazenda": "26250",
    "numero": [],
    "data": [],
    "numeroreprodutor": [],
    "cio": []
}

input_inseminacao_cobertura = InputInseminacaoCobertura(**input_data)
print(input_inseminacao_cobertura)

Se cdloteproduto for necessário, certifique-se de incluí-lo no seu JSON de entrada.

To continue talking to Dosu, mention @dosu.