创建工具，继承BaseTool并且传递了BaseTool中不包含的参数

[zh19990906]

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

class DynamicToolBase(BaseTool):
    """
    A base class for dynamically creating tools with customizable attributes.
    """

    def __init__(self, name: str, description: str, return_direct: bool, args_schema: Type[BaseModel],
                 start_url: str, requests_type: str = 'GET', headers: dict = {}):
        super().__init__(
            name=name,
            description=description
        )
        self.name = name
        self.description = description
        self.return_direct = return_direct
        self.args_schema = args_schema
        self.requests_type = requests_type.lower()
        self.start_url = start_url
        self.headers = headers

    def _run(self, *args, **kwargs) -> Dict[str, Any]:

        if getattr(server_response, self.requests_type, None) is None:
            raise Exception('请求方式异常')

        key_dict = self.get_requests_parameter(kwargs)

        return getattr(server_response, self.requests_type)(**key_dict)

    async def _arun(self, *args, **kwargs) -> Dict[str, Any]:
        if getattr(server_request_util, self.requests_type, None) is None:
            raise Exception('请求方式异常')
        key_dict = self.get_requests_parameter(kwargs)
        return await getattr(server_request_util, self.requests_type)(**key_dict)

    def get_requests_parameter(self, *args, **kwargs):

        # 只处理kwargs中的参数
        key_dict = {'body': {}, 'params': {}, 'json': {}, 'timeout': 20, 'headers': self.headers, 'url': self.start_url}
        # 所有的参数调用采用关键词_参数名的要求进行创建变量名，当参数中包含下划线是，使用join进行其他参数的名称的合并，以满足对数据要求

        for key, value in kwargs.items():
            key_cut = key.split('_')
            if key_cut[0] in key_dict:
                key_dict[key_cut[0]]['_'.join(key_cut[1:])] = value
        key_dict = {k: v for k, v in key_dict.items() if v}
        if 'json' in key_dict:
            key_dict['json_data'] = key_dict['json']
            del key_dict['json']
        return key_dict

Description

File "D:\code\agent_platform_backend\langflow\utils\requests_tool_util.py", line 30, in init
self.requests_type = requests_type.lower()
KeyboardInterrupt

System Info

langchain==0.2.9
python==3.10.1

[dosubot[bot]]

To create a tool by inheriting from BaseTool and passing parameters not included in BaseTool, you can follow the example provided in the LangChain documentation. Here is a step-by-step guide:

1. Define the input schema using Pydantic's BaseModel.
2. Create a custom tool class by subclassing BaseTool.
3. Add any additional parameters to your custom tool class.
4. Implement the _run and optionally _arun methods.

Here is an example based on your provided code:

from typing import Optional, Type, Dict, Any
from pydantic import BaseModel, Field
from langchain_core.tools import BaseTool

# Define the input schema
class CustomToolInput(BaseModel):
    param1: str = Field(description="Description for param1")
    param2: int = Field(description="Description for param2")

# Create a custom tool class by subclassing BaseTool
class DynamicToolBase(BaseTool):
    """
    A base class for dynamically creating tools with customizable attributes.
    """

    def __init__(self, name: str, description: str, return_direct: bool, args_schema: Type[BaseModel],
                 start_url: str, requests_type: str = 'GET', headers: dict = {}):
        super().__init__(
            name=name,
            description=description
        )
        self.name = name
        self.description = description
        self.return_direct = return_direct
        self.args_schema = args_schema
        self.requests_type = requests_type.lower()
        self.start_url = start_url
        self.headers = headers

    def _run(self, *args, **kwargs) -> Dict[str, Any]:
        if getattr(server_response, self.requests_type, None) is None:
            raise Exception('请求方式异常')

        key_dict = self.get_requests_parameter(kwargs)
        return getattr(server_response, self.requests_type)(**key_dict)

    async def _arun(self, *args, **kwargs) -> Dict[str, Any]:
        if getattr(server_request_util, self.requests_type, None) is None:
            raise Exception('请求方式异常')
        key_dict = self.get_requests_parameter(kwargs)
        return await getattr(server_request_util, self.requests_type)(**key_dict)

    def get_requests_parameter(self, *args, **kwargs) -> Dict[str, Any]:
        key_dict = {'body': {}, 'params': {}, 'json': {}, 'timeout': 20, 'headers': self.headers, 'url': self.start_url}
        for key, value in kwargs.items():
            key_cut = key.split('_')
            if key_cut[0] in key_dict:
                key_dict[key_cut[0]]['_'.join(key_cut[1:])] = value
        key_dict = {k: v for k, v in key_dict.items() if v}
        if 'json' in key_dict:
            key_dict['json_data'] = key_dict['json']
            del key_dict['json']
        return key_dict

# Instantiate and use the custom tool
custom_tool = DynamicToolBase(
    name="CustomTool",
    description="A custom tool for demonstration",
    return_direct=True,
    args_schema=CustomToolInput,
    start_url="http://example.com",
    requests_type="GET",
    headers={"Authorization": "Bearer token"}
)

print(custom_tool.name)
print(custom_tool.description)
print(custom_tool.args_schema)
print(custom_tool.return_direct)

This example demonstrates how to create a custom tool by inheriting from BaseTool and adding additional parameters such as start_url, requests_type, and headers. The _run and _arun methods are implemented to define the tool's functionality.

For more detailed examples and tests, you can refer to the LangChain documentation and codebase ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[zh19990906]

我的报错是ValueError: "DynamicToolBase" object has no field "requests_type" 好像是因为BaseTool中没有我自定义的参数

[dosubot[bot]]

To resolve the ValueError: "DynamicToolBase" object has no field "requests_type" when adding custom parameters to a class inheriting from BaseTool, you need to ensure that the custom parameters are properly defined in the class. Here is an example of how you can add custom parameters to a class inheriting from BaseTool:

from typing import Any, Dict, Optional, Type
from pydantic import BaseModel
from langchain_core.tools import BaseTool

class CustomToolInput(BaseModel):
    param1: str
    param2: int

class DynamicToolBase(BaseTool):
    name: str = "dynamic_tool_base"
    description: str = "A base class for dynamically creating tools with customizable attributes."
    args_schema: Type[BaseModel] = CustomToolInput

    custom_param: str

    def __init__(self, custom_param: str, **kwargs: Any):
        self.custom_param = custom_param
        super().__init__(**kwargs)

    def _run(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
        print(f"Custom parameter: {self.custom_param}")
        # Implement your logic here
        return {}

    async def _arun(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
        print(f"Custom parameter: {self.custom_param}")
        # Implement your async logic here
        return {}

# Example usage
custom_tool = DynamicToolBase(
    custom_param="example_param",
    name="CustomTool",
    description="A custom tool for demonstration",
    return_direct=True,
    args_schema=CustomToolInput
)

print(custom_tool.name)
print(custom_tool.description)
print(custom_tool.custom_param)

In this example, custom_param is a custom parameter added to the DynamicToolBase class. The __init__ method is overridden to accept this custom parameter and pass the remaining arguments to the base class initializer. This ensures that the custom parameter is properly initialized and can be used within the class methods ^[1].

To continue talking to Dosu, mention @dosu.

[zh19990906]

class ToolConfig(BaseModel):
start_url: str
requests_type: str = 'GET'
headers: dict = {}

class DynamicToolBase(BaseTool):
"""
A base class for dynamically creating tools with customizable attributes.
"""
name: str
description: str
return_direct: bool
args_schema: Type[BaseModel]
tool_config: ToolConfig

我修改成了如此的方式，就解决了