How to Set a Default Tool for my Agent Executor?

[mrctito]

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

Since it is a conceptual question, I did not include any source code.

Description

Hi @dosu, please help me!

I have an agent with 10 available tools, and I need it to execute a specific default tool if it doesn't know which tool to use.

How can I do this?

System Info

Since it is a conceptual question, I did not include any source code.

[dosubot[bot]]

To set a default tool for your agent executor in LangChain, you can initialize and configure the tool, then integrate it into your AgentExecutor. Here's an example using the WikipediaQueryRun tool:

1. Initialize the Tool:

from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# Initialize the API wrapper
api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)

# Initialize the tool with the API wrapper
tool = WikipediaQueryRun(api_wrapper=api_wrapper)

# Optionally, customize the tool's name, description, and JSON schema
from langchain_core.pydantic_v1 import BaseModel, Field

class WikiInputs(BaseModel):
    """Inputs to the wikipedia tool."""
    query: str = Field(description="query to look up in Wikipedia, should be 3 or less words")

tool = WikipediaQueryRun(
    name="wiki-tool",
    description="look up things in wikipedia",
    args_schema=WikiInputs,
    api_wrapper=api_wrapper,
    return_direct=True,
)

# Set this tool as the default tool for your agent executor
default_tool = tool

2. Integrate the Default Tool into AgentExecutor:

from langchain.agents.agent import AgentExecutor
from langchain.agents.base import BaseSingleActionAgent

# Assuming you have an agent instance
agent = BaseSingleActionAgent()

# Create the AgentExecutor with the default tool
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=[default_tool]
)

# Now, the agent executor will use the default tool if it doesn't know which tool to use

This setup ensures that the WikipediaQueryRun tool is used as the default tool by your agent executor if it doesn't know which tool to use ^[1][2].

To continue talking to Dosu, mention @dosu.

[dosubot[bot]]

The provided code does not create a multi-agent setup. It creates a single-agent setup using the AgentExecutor class with a single agent instance (agent) and a list of tools.

A multi-agent setup is necessary when you want to simulate interactions between multiple autonomous entities, each with its own behavior and decision-making process. For example, you might use a multi-agent setup to simulate a debate, a negotiation, or any scenario where multiple agents need to interact with each other.

In LangChain, a multi-agent setup typically involves creating multiple DialogueAgent instances and managing their interactions using a DialogueSimulator or similar class. Here is an example of a multi-agent setup for a simulated debate:

characters = []
for character_name, character_system_message, bidding_template in zip(
    character_names, character_system_messages, character_bidding_templates
):
    characters.append(
        BiddingDialogueAgent(
            name=character_name,
            system_message=character_system_message,
            model=ChatOpenAI(temperature=0.2),
            bidding_template=bidding_template,
        )
    )

max_iters = 10
n = 0

simulator = DialogueSimulator(agents=characters, selection_function=select_next_speaker)
simulator.reset()
simulator.inject("Debate Moderator", specified_topic)
print(f"(Debate Moderator): {specified_topic}")
print("\n")

while n < max_iters:
    name, message = simulator.step()
    print(f"({name}): {message}")
    print("\n")
    n += 1

This code initializes multiple BiddingDialogueAgent instances and uses a DialogueSimulator to manage their interactions, thus creating a multi-agent setup ^[1][2][3].

In summary, your code creates a single-agent setup. You would need a multi-agent setup when you want to simulate interactions between multiple agents with distinct roles and behaviors.

To continue talking to Dosu, mention @dosu.

[mrctito]

Thank you @dosu!

Please @dosu,

But why does LangChain raise an exception when I set return_direct = True in my tools?

[dosubot[bot]]

LangChain raises an exception when setting return_direct=True in your tools because tools with return_direct=True are not allowed in multi-action agents. This is explicitly checked in the code and raises a ValueError if such tools are used.

To resolve this issue, ensure that you are not using tools with return_direct=True in a multi-action agent. Here is the relevant code snippet that performs this check:

if isinstance(agent, BaseMultiActionAgent):
    for tool in tools:
        if tool.return_direct:
            raise ValueError(
                "Tools that have `return_direct=True` are not allowed "
                "in multi-action agents"
            )

Make sure to either set return_direct=False for your tools or avoid using multi-action agents if you need to use tools with return_direct=True ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[mrctito]

@dosu,

multi-action agent is an Agent that uses several tools?

Thank you!

[dosubot[bot]]

A multi-action agent in LangChain is an agent that can perform multiple actions or use multiple tools within a single execution cycle. This is different from a single-action agent, which can only perform one action or use one tool per cycle.

In a multi-action agent setup, the agent can decide to use several tools sequentially or in parallel to achieve a more complex task. This is why tools with return_direct=True are not allowed, as they would disrupt the multi-step process by returning a result directly and prematurely ending the execution cycle.

If you need to use multiple tools but want to avoid the constraints of a multi-action agent, consider structuring your logic to ensure only one tool is used per cycle or avoid setting return_direct=True for any of your tools.

To continue talking to Dosu, mention @dosu.