Skip to content

Tool spec

基础工具规范类。

BaseToolSpec #

基础工具规范类。

Source code in llama_index/core/tools/tool_spec/base.py 
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
class BaseToolSpec:
    """基础工具规范类。"""

    # list of functions that you'd want to convert to spec
    spec_functions: List[SPEC_FUNCTION_TYPE]

    def get_fn_schema_from_fn_name(
        self, fn_name: str, spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None
    ) -> Optional[Type[BaseModel]]:
        """从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。
在这种情况下，由下游工具实现来推断模式。
"""
        spec_functions = spec_functions or self.spec_functions
        for fn in spec_functions:
            if fn == fn_name:
                return create_schema_from_function(fn_name, getattr(self, fn_name))

        raise ValueError(f"Invalid function name: {fn_name}")

    def get_metadata_from_fn_name(
        self, fn_name: str, spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None
    ) -> Optional[ToolMetadata]:
        """从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。
在这种情况下，由下游工具实现来推断模式。
"""
        try:
            func = getattr(self, fn_name)
        except AttributeError:
            return None
        name = fn_name
        docstring = func.__doc__ or ""
        description = f"{name}{signature(func)}\n{docstring}"
        fn_schema = self.get_fn_schema_from_fn_name(
            fn_name, spec_functions=spec_functions
        )
        return ToolMetadata(name=name, description=description, fn_schema=fn_schema)

    def to_tool_list(
        self,
        spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None,
        func_to_metadata_mapping: Optional[Dict[str, ToolMetadata]] = None,
    ) -> List[FunctionTool]:
        """将工具规范转换为工具列表。"""
        spec_functions = spec_functions or self.spec_functions
        func_to_metadata_mapping = func_to_metadata_mapping or {}
        tool_list = []
        for func_spec in spec_functions:
            func_sync = None
            func_async = None
            if isinstance(func_spec, str):
                func = getattr(self, func_spec)
                if asyncio.iscoroutinefunction(func):
                    func_async = func
                else:
                    func_sync = func
                metadata = func_to_metadata_mapping.get(func_spec, None)
                if metadata is None:
                    metadata = self.get_metadata_from_fn_name(func_spec)
            elif isinstance(func_spec, tuple) and len(func_spec) == 2:
                func_sync = getattr(self, func_spec[0])
                func_async = getattr(self, func_spec[1])
                metadata = func_to_metadata_mapping.get(func_spec[0], None)
                if metadata is None:
                    metadata = func_to_metadata_mapping.get(func_spec[1], None)
                    if metadata is None:
                        metadata = self.get_metadata_from_fn_name(func_spec[0])
            else:
                raise ValueError(
                    "spec_functions must be of type: List[Union[str, Tuple[str, str]]]"
                )

            if func_sync is None:
                if func_async is not None:
                    func_sync = patch_sync(func_async)
                else:
                    raise ValueError(
                        f"Could not retrieve a function for spec: {func_spec}"
                    )

            tool = FunctionTool.from_defaults(
                fn=func_sync,
                async_fn=func_async,
                tool_metadata=metadata,
            )
            tool_list.append(tool)
        return tool_list

get_fn_schema_from_fn_name #

get_fn_schema_from_fn_name(
    fn_name: str,
    spec_functions: Optional[
        List[SPEC_FUNCTION_TYPE]
    ] = None,
) -> Optional[Type[BaseModel]]

从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。 在这种情况下，由下游工具实现来推断模式。

Source code in llama_index/core/tools/tool_spec/base.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    def get_fn_schema_from_fn_name(
        self, fn_name: str, spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None
    ) -> Optional[Type[BaseModel]]:
        """从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。
在这种情况下，由下游工具实现来推断模式。
"""
        spec_functions = spec_functions or self.spec_functions
        for fn in spec_functions:
            if fn == fn_name:
                return create_schema_from_function(fn_name, getattr(self, fn_name))

        raise ValueError(f"Invalid function name: {fn_name}")

get_metadata_from_fn_name #

get_metadata_from_fn_name(
    fn_name: str,
    spec_functions: Optional[
        List[SPEC_FUNCTION_TYPE]
    ] = None,
) -> Optional[ToolMetadata]

从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。 在这种情况下，由下游工具实现来推断模式。

Source code in llama_index/core/tools/tool_spec/base.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    def get_metadata_from_fn_name(
        self, fn_name: str, spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None
    ) -> Optional[ToolMetadata]:
        """从函数名称返回映射。

返回类型是Optional，意味着模式可以是None。
在这种情况下，由下游工具实现来推断模式。
"""
        try:
            func = getattr(self, fn_name)
        except AttributeError:
            return None
        name = fn_name
        docstring = func.__doc__ or ""
        description = f"{name}{signature(func)}\n{docstring}"
        fn_schema = self.get_fn_schema_from_fn_name(
            fn_name, spec_functions=spec_functions
        )
        return ToolMetadata(name=name, description=description, fn_schema=fn_schema)

to_tool_list #

to_tool_list(
    spec_functions: Optional[
        List[SPEC_FUNCTION_TYPE]
    ] = None,
    func_to_metadata_mapping: Optional[
        Dict[str, ToolMetadata]
    ] = None,
) -> List[FunctionTool]

将工具规范转换为工具列表。

Source code in llama_index/core/tools/tool_spec/base.py 
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def to_tool_list(
    self,
    spec_functions: Optional[List[SPEC_FUNCTION_TYPE]] = None,
    func_to_metadata_mapping: Optional[Dict[str, ToolMetadata]] = None,
) -> List[FunctionTool]:
    """将工具规范转换为工具列表。"""
    spec_functions = spec_functions or self.spec_functions
    func_to_metadata_mapping = func_to_metadata_mapping or {}
    tool_list = []
    for func_spec in spec_functions:
        func_sync = None
        func_async = None
        if isinstance(func_spec, str):
            func = getattr(self, func_spec)
            if asyncio.iscoroutinefunction(func):
                func_async = func
            else:
                func_sync = func
            metadata = func_to_metadata_mapping.get(func_spec, None)
            if metadata is None:
                metadata = self.get_metadata_from_fn_name(func_spec)
        elif isinstance(func_spec, tuple) and len(func_spec) == 2:
            func_sync = getattr(self, func_spec[0])
            func_async = getattr(self, func_spec[1])
            metadata = func_to_metadata_mapping.get(func_spec[0], None)
            if metadata is None:
                metadata = func_to_metadata_mapping.get(func_spec[1], None)
                if metadata is None:
                    metadata = self.get_metadata_from_fn_name(func_spec[0])
        else:
            raise ValueError(
                "spec_functions must be of type: List[Union[str, Tuple[str, str]]]"
            )

        if func_sync is None:
            if func_async is not None:
                func_sync = patch_sync(func_async)
            else:
                raise ValueError(
                    f"Could not retrieve a function for spec: {func_spec}"
                )

        tool = FunctionTool.from_defaults(
            fn=func_sync,
            async_fn=func_async,
            tool_metadata=metadata,
        )
        tool_list.append(tool)
    return tool_list