mirror of
https://github.com/Mintplex-Labs/langchain-python.git
synced 2026-08-26 16:55:38 -04:00
Ankush Gola
7b5e160d28
Follow-up of @hinthornw's PR: - Migrate the Tool abstraction to a separate file (`BaseTool`). - `Tool` implementation of `BaseTool` takes in function and coroutine to more easily maintain backwards compatibility - Add a Toolkit abstraction that can own the generation of tools around a shared concept or state --------- Co-authored-by: William FH <13333726+hinthornw@users.noreply.github.com> Co-authored-by: Harrison Chase <hw.chase.17@gmail.com> Co-authored-by: Francisco Ingham <fpingham@gmail.com> Co-authored-by: Dhruv Anand <105786647+dhruv-anand-aintech@users.noreply.github.com> Co-authored-by: cragwolfe <cragcw@gmail.com> Co-authored-by: Anton Troynikov <atroyn@users.noreply.github.com> Co-authored-by: Oliver Klingefjord <oliver@klingefjord.com> Co-authored-by: William Fu-Hinthorn <whinthorn@Williams-MBP-3.attlocal.net> Co-authored-by: Bruno Bornsztein <bruno.bornsztein@gmail.com>
104 lines
3.5 KiB
Python
104 lines
3.5 KiB
Python
"""Interface for tools."""
|
|
from inspect import signature
|
|
from typing import Any, Awaitable, Callable, Optional, Union
|
|
|
|
from langchain.tools.base import BaseTool
|
|
|
|
|
|
class Tool(BaseTool):
|
|
"""Tool that takes in function or coroutine directly."""
|
|
|
|
description: str = ""
|
|
func: Callable[[str], str]
|
|
coroutine: Optional[Callable[[str], Awaitable[str]]] = None
|
|
|
|
def _run(self, tool_input: str) -> str:
|
|
"""Use the tool."""
|
|
return self.func(tool_input)
|
|
|
|
async def _arun(self, tool_input: str) -> str:
|
|
"""Use the tool asynchronously."""
|
|
if self.coroutine:
|
|
return await self.coroutine(tool_input)
|
|
raise NotImplementedError("Tool does not support async")
|
|
|
|
# TODO: this is for backwards compatibility, remove in future
|
|
def __init__(
|
|
self, name: str, func: Callable[[str], str], description: str, **kwargs: Any
|
|
) -> None:
|
|
"""Initialize tool."""
|
|
super(Tool, self).__init__(
|
|
name=name, func=func, description=description, **kwargs
|
|
)
|
|
|
|
|
|
class InvalidTool(BaseTool):
|
|
"""Tool that is run when invalid tool name is encountered by agent."""
|
|
|
|
name = "invalid_tool"
|
|
description = "Called when tool name is invalid."
|
|
|
|
def _run(self, tool_name: str) -> str:
|
|
"""Use the tool."""
|
|
return f"{tool_name} is not a valid tool, try another one."
|
|
|
|
async def _arun(self, tool_name: str) -> str:
|
|
"""Use the tool asynchronously."""
|
|
return f"{tool_name} is not a valid tool, try another one."
|
|
|
|
|
|
def tool(*args: Union[str, Callable], return_direct: bool = False) -> Callable:
|
|
"""Make tools out of functions, can be used with or without arguments.
|
|
|
|
Requires:
|
|
- Function must be of type (str) -> str
|
|
- Function must have a docstring
|
|
|
|
Examples:
|
|
.. code-block:: python
|
|
|
|
@tool
|
|
def search_api(query: str) -> str:
|
|
# Searches the API for the query.
|
|
return
|
|
|
|
@tool("search", return_direct=True)
|
|
def search_api(query: str) -> str:
|
|
# Searches the API for the query.
|
|
return
|
|
"""
|
|
|
|
def _make_with_name(tool_name: str) -> Callable:
|
|
def _make_tool(func: Callable[[str], str]) -> Tool:
|
|
assert func.__doc__, "Function must have a docstring"
|
|
# Description example:
|
|
# search_api(query: str) - Searches the API for the query.
|
|
description = f"{tool_name}{signature(func)} - {func.__doc__.strip()}"
|
|
tool_ = Tool(
|
|
name=tool_name,
|
|
func=func,
|
|
description=description,
|
|
return_direct=return_direct,
|
|
)
|
|
return tool_
|
|
|
|
return _make_tool
|
|
|
|
if len(args) == 1 and isinstance(args[0], str):
|
|
# if the argument is a string, then we use the string as the tool name
|
|
# Example usage: @tool("search", return_direct=True)
|
|
return _make_with_name(args[0])
|
|
elif len(args) == 1 and callable(args[0]):
|
|
# if the argument is a function, then we use the function name as the tool name
|
|
# Example usage: @tool
|
|
return _make_with_name(args[0].__name__)(args[0])
|
|
elif len(args) == 0:
|
|
# if there are no arguments, then we use the function name as the tool name
|
|
# Example usage: @tool(return_direct=True)
|
|
def _partial(func: Callable[[str], str]) -> BaseTool:
|
|
return _make_with_name(func.__name__)(func)
|
|
|
|
return _partial
|
|
else:
|
|
raise ValueError("Too many arguments for tool decorator")
|