Use @tool with a member function?

[rlnasuti]

Hello everyone!

I'm trying to create an Agent with access to some tools where the Agent and the tools themselves are part of a class. This is pretty standard stuff outside of a class, but I'm running into issues when I try to use it as part of a custom class.

Specifically, I'm trying to use the @tool decorator on a member function. Here's an example:

@tool
 def summarize_document(self) -> str:
    """Useful for retrieving a summary of the document."""
    return "No summary available"

The problem I'm running into is that the Agent will supply the self parameter:

> Entering new AgentExecutor chain...
Invoking: `summarize_document` with `{'self': {}}`

which causes an error:
TypeError: _run() got multiple values for argument 'self'

So my question - has anyone encountered this issue and figured out a way to work around it? I tried giving it an arg_schema that was an empty class along with infer_schema=False, but it still tried to send in that self parameter. I'd like it to call the member function like this:

> Entering new AgentExecutor chain...

Invoking: `self.summarize_document` with `{}`

[dosubot[bot]]

🤖

Hello,

The issue you're encountering is due to the fact that the @tool decorator is not designed to be used with instance methods, which require a self parameter. When you use the @tool decorator on an instance method, the AgentExecutor tries to supply the self parameter, leading to the TypeError you're seeing.

One way to work around this is to use the @staticmethod decorator in conjunction with the @tool decorator. This tells Python that the method does not require access to any instance or class-specific data, allowing it to be called without an instance of the class. Here's an example:

class MyClass:
    @staticmethod
    @tool("my_tool", return_direct=True)
    def my_method(input: str) -> str:
        # Your code here
        return processed_input

In this example, my_method is a static method, which means it doesn't take a self parameter. The @tool decorator can then be used without encountering a TypeError.

Please note that static methods cannot access or modify the instance or class state, so this approach is only suitable for methods that don't need to interact with other parts of the class.

If you need to access or modify the instance or class state, you might need to rethink your design. One possibility is to move the method outside of the class and pass any necessary data as arguments.

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

Sources

• libs/langchain/langchain/tools/base.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.

[Paul-Williamson-90]

I came across this today and came up with a solution:

I use in the doc string to grab the method description, and "{arg}: " for each arg description.

Essentially just writing the pydantic model yourself to exclude the self arg.

from langchain.tools import StructuredTool
from langchain.pydantic_v1 import Field, create_model
from typing import Callable

def create_tool(callable:Callable):
    method = callable
    args = {k:v for k,v in method.__annotations__.items() if k != "self"}
    name = method.__name__
    doc = method.__doc__
    func_desc = doc[doc.find("<desc>") + len("<desc>"):doc.find("</desc>")]
    arg_desc = dict()
    for arg in args.keys():
        desc = doc[doc.find(f"{arg}: ")+len(f"{arg}: "):]
        desc = desc[:desc.find("\n")]
        arg_desc[arg] = desc
    arg_fields = dict()
    for k,v in args.items():
        arg_fields[k] = (v, Field(description=arg_desc[k]))

    Model = create_model('Model', **arg_fields)

    tool = StructuredTool.from_function(
        func=method,
        name=name,
        description=func_desc,
        args_schema=Model,
        return_direct=False,
    )
    return tool

[meet1919]

@Paul-Williamson-90 I also solved this in a similar way. I am using AST to get all the function extract necessary details and create a structured tool from it. Your code seems more readable and simple than mine.

[Paul-Williamson-90]

Just an update on the solution I provided above:

I ran into an error on 'return' arg missing. Wasn't sure how it got in there but extending the args dictionary solves it:
args = {k:v for k,v in method.__annotations__.items() if k not in ["self", "return"]}

Additionally, if you don't want to rely on docustrings (which are a bit fragile to use), it is easy to adapt that function to specify the pydantic schema and descriptors yourself.

[KshitizHelix]

@dosu-bot any updates on this?

[kanwalgupta]

Could you please provide any code sample to help me reproduce this issue ?

[faizan2sheikh]

I was also able to solve the issue, I passed the self argument in the metadata, then utilized that field from metadata

[meet1919]

My implementation include similar technique

[rd-0015]

I was also able to solve the issue, I passed the self argument in the metadata, then utilized that field from metadata

@faizan2sheikh Could you please elaborate on the changes you made or provide some sample code, if possible. I have a similar TypeError issue where self parameter is getting passed.

[faizan2sheikh]

I defined tools in a way mentioned here: https://blog.langchain.dev/structured-tools/
In the _run function I used a variable called state (for example with a variable name and to modify it) from metadata:
self.metadata['state'].name = response

Now when passing tools to Agent I used this approach
tools = [tool_name(metadata={'state':self})]

[faizan2sheikh]

You can also refer to an example from @meet1919 here: #6828

[danielbentes]

These solutions to me sound more like workarounds. The proper solution is to have the support for using instance methods, which require a self parameter, for Agents where the tools themselves are part of a class. Maybe something that the people behind Langchain can fix?

[meet1919]

Yeah, but until they do we need workarounds.

[ahmedmoorsy]

I was reviewing the tools in the LangChain repository tools file

There are two updates needed:

1. Update this line:

   langchain/libs/core/langchain_core/tools.py

   Line 308 in adf2dc1

   if k in tool_input

   to be like this:

   if k in tool_input and k != "self"
   

2. Modify the _run method :
   

   langchain/libs/core/langchain_core/tools.py

   Line 617 in adf2dc1

   def _run(

   to the following implementation:

       def _run(
           self,
           *args: Any,
           run_manager: Optional[CallbackManagerForToolRun] = None,
           **kwargs: Any,
       ) -> Any:
           """Use the tool."""
           if self.func:
               new_argument_supported = signature(self.func).parameters.get("callbacks")
               bound_func = self.func.__get__(self, self.__class__)  # Bind the function to the instance
               return (
                   bound_func(
                       *args,
                       callbacks=run_manager.get_child() if run_manager else None,
                       **kwargs,
                   )
                   if new_argument_supported
                   else bound_func(*args, **kwargs)
               )
           raise NotImplementedError("Tool does not support sync")
   

I managed to fix the problem by applying these updates, and it is now working fine!

[ahmedmoorsy]

Example of the inference code

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o")


class Test:
    def __init__(self):
      pass

    @tool
    def magic_function(self, input: int) -> int:
        """Applies a magic function to an input."""
        return input + 2

test = Test()
tools = [test.magic_function]

query = "what is the value of magic_function(3)?"
app = create_react_agent(model, tools)

messages = app.invoke({"messages": [("human", query)]})

print({
    "input": query,
    "output": messages["messages"][-1].content,
})

output:

{'input': 'what is the value of magic_function(3)?', 'output': 'The value of `magic_function(3)` is 5.'}

[itsparser]

Hey Hi, @ahmedmoorsy can you share how you make it work

[panzer]

I was able to solve my use case with the StructuredTool.from_function method

from langchain.tools.base import StructuredTool
from langgraph.prebuilt import create_react_agent
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o-mini")

class Example:
    def __init__(self):
        self.agent = create_react_agent(model, tools=[StructuredTool.from_function(self.magic_function)])

    def magic_function(self, value: str) -> str:
        """Determine the magic value of the given value"""
        return value + "... magic!"
    
example = Example()
result = example.agent.invoke(
    {"messages": [HumanMessage("What is the magic value of 'Watermelon'?")]}
)

print(result["messages"][-1].content)

In my case, I had to figure out to not use the @tool decorator.