Custom LLM agent with custom tool not work due to lack func argument

[elvis-cai]

while following https://python.langchain.com/docs/modules/agents/how_to/custom_llm_agent#set-up-tool, we also want to custom tool adding extra schema validation, from the example for the tool listed, we need name, description, and func field, for custom tool we only have name and description field, here's the custom tool code https://gist.github.com/elvis-cai/203487d2bfd11d57625d84f8122e875e,

this is the custom tool we are referring to https://python.langchain.com/docs/modules/agents/tools/custom_tools#subclassing-the-basetool-class.

not sure how to make it work with pydantic validation, thanks.

[dosubot[bot]]

🤖

Hello,

To make your custom tool work with pydantic validation in the LangChain framework, you can use the BaseTool class or the StructuredTool class. Since your custom tool only has name and description fields, you can use the BaseTool class to define your tool. Here's an example:

from typing import Optional, Type
from langchain.callbacks.manager import CallbackManagerForToolRun
from langchain.tools import BaseTool
from pydantic.v1 import BaseModel, Field

class CustomTool(BaseTool):
    name = "custom_tool"
    description = "This is a custom tool"

    def _run(
        self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool."""
        # Implement your tool's functionality here
        return "Result of custom tool"

    async def _arun(
        self, query: str, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool asynchronously."""
        raise NotImplementedError("custom_tool does not support async")

In this example, the _run method is where you would implement your tool's functionality. The run_manager parameter is optional and can be used to manage callbacks. If your tool supports asynchronous operations, you can implement the _arun method.

If you want to use pydantic validation, you can define a custom args_schema:

class CustomToolInput(BaseModel):
    query: str = Field()

class CustomTool(BaseTool):
    name = "custom_tool"
    description = "This is a custom tool"
    args_schema: Type[BaseModel] = CustomToolInput

    def _run(
        self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool."""
        # Implement your tool's functionality here
        return "Result of custom tool"

    async def _arun(
        self, query: str, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool asynchronously."""
        raise NotImplementedError("custom_tool does not support async")

In this example, the CustomToolInput class is a pydantic model that defines the expected input for your tool. The args_schema attribute of your tool is set to this class, which means that the input to your tool will be validated against this schema.

In the context shared, it's important to note that LangChain is currently compatible with both Pydantic v1 and v2. However, you should avoid mixing v1 and v2 code in the same tool. If you're using Pydantic v1, make sure to import from pydantic.v1. If you're using Pydantic v2, you'll need to wait until LangChain has migrated to v2 internally before you can use v2 features in your tools.

If you want to create a tool from a function, you can use the StructuredTool.from_function method. This method allows you to create a tool from a function, with the option to infer the schema from the function's signature. If you choose to infer the schema, the function's arguments will be used to create a pydantic model that will be used for validation. If you provide an args_schema, it will be used instead of the inferred schema. The name and description parameters can be used to set the tool's name and description. The return_direct parameter determines whether the tool's output should be returned directly or as a callback. If return_direct is True, the tool's output will be returned directly. If False, the tool's output will be returned as a callback.

I hope this helps! Let me know if you have any other questions.

Sources

• docs/extras/modules/agents/tools/custom_tools.ipynb
• docs/extras/guides/pydantic_compatibility.md
• libs/langchain/langchain/tools/base.py
• libs/langchain/tests/unit_tests/schema/runnable/test_runnable.py

---

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.

If you want to continue the conversation, start your reply with @dosu-bot.