langchain_community.tools.edenai.image_objectdetection.EdenAiObjectDetectionTool

注意

EdenAiObjectDetectionTool 实现了标准的 Runnable 接口。 🏃

Runnable 接口 具有在可运行对象上可用的其他方法，例如 with_types、 with_retry、 assign、 bind、 get_graph 等。

class langchain_community.tools.edenai.image_objectdetection.EdenAiObjectDetectionTool

基类: EdenaiTool

查询 Eden AI 对象检测 API 的工具。

有关 API 参考，请查看 edenai 文档: https://docs.edenai.co/reference/image_object_detection_create。

要使用此工具，您应该设置环境变量 EDENAI_API_KEY 以及您的 API 令牌。您可以在这里找到您的令牌：https://app.edenai.run/admin/account/settings

初始化工具。

param args_schema: Type[BaseModel] = <class 'langchain_community.tools.edenai.image_objectdetection.ObjectDetectionInput'>

Pydantic 模型类，用于验证和解析工具的输入参数。

参数模式应为以下之一

• pydantic.BaseModel 的子类。

或 - 如果在 pydantic 2 中访问 v1 命名空间，则为 pydantic.v1.BaseModel 的子类

param callback_manager: Optional[BaseCallbackManager] = None

已弃用。请改用 callbacks。

param callbacks: Callbacks = None

在工具执行期间要调用的回调。

param description: str = 'A wrapper around edenai Services Object Detection . Useful for when you have to do an  to identify and locate\n        (with bounding boxes) objects in an image Input should be the string url of the image to identify.'

用于告知模型如何/何时/为何使用该工具。

您可以提供少量示例作为描述的一部分。

param edenai_api_key: Optional[str] = None

param feature: str = 'image'

param handle_tool_error: Optional[Union[bool, str, Callable[[ToolException], str]]] = False

处理抛出的 ToolException 的内容。

param handle_validation_error: Optional[Union[bool, str, Callable[[ValidationError], str]]] = False

处理抛出的 ValidationError 的内容。

param is_async: bool = False

param metadata: Optional[Dict[str, Any]] = None

与工具关联的可选元数据。默认为 None。此元数据将与每次调用此工具关联，并作为参数传递给 callbacks 中定义的处理程序。您可以使用这些元数据来识别工具的特定实例及其用例。

param providers: List[str] [必需]

用于 API 调用的提供商。

param response_format: Literal['content', 'content_and_artifact'] = 'content'

工具响应格式。默认为 “content”。

如果为 “content”，则工具的输出将被解释为 ToolMessage 的内容。 如果为 “content_and_artifact”，则输出应为与 ToolMessage 的 (content, artifact) 对应的二元组。

param return_direct: bool = False

是否直接返回工具的输出。

将其设置为 True 意味着在调用工具后，AgentExecutor 将停止循环。

param show_positions: bool = False

param subfeature: str = 'object_detection'

param tags: Optional[List[str]] = None

与工具关联的可选标签列表。默认为 None。这些标签将与每次调用此工具关联，并作为参数传递给 callbacks 中定义的处理程序。您可以使用这些标签来识别工具的特定实例及其用例。

param verbose: bool = False

是否记录工具的进度。

__call__(tool_input: str, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None) → str

Deprecated since version langchain-core==0.1.47: Use invoke instead.

使工具可调用。

参数

• tool_input (str) –

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –

返回类型

str

async abatch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]

默认实现使用 asyncio.gather 并行运行 ainvoke。

批处理的默认实现非常适合 IO 绑定的可运行对象。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 Runnable 使用支持批处理模式的 API。

参数

• inputs (List[Input]) – Runnable 的输入列表。

• config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 调用 Runnable 时要使用的配置。 该配置支持标准键，例如用于跟踪目的的 “tags”、“metadata”，用于控制并行执行多少工作的 “max_concurrency” 以及其他键。 有关更多详细信息，请参阅 RunnableConfig。 默认为 None。

• return_exceptions (bool) – 是否返回异常而不是引发异常。 默认为 False。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

返回值

Runnable 的输出列表。

返回类型

List[Output]

async abatch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → AsyncIterator[Tuple[int, Union[Output, Exception]]]

在输入列表上并行运行 ainvoke，并在结果完成时生成结果。

参数

• inputs (Sequence[Input]) – Runnable 的输入列表。

• config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 调用 Runnable 时要使用的配置。 该配置支持标准键，例如用于跟踪目的的 “tags”、“metadata”，用于控制并行执行多少工作的 “max_concurrency” 以及其他键。 有关更多详细信息，请参阅 RunnableConfig。 默认为 None。 默认为 None。

• return_exceptions (bool) – 是否返回异常而不是引发异常。 默认为 False。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

输入索引和 Runnable 输出的元组。

返回类型

AsyncIterator[Tuple[int, Union[Output, Exception]]]

async ainvoke(input: Union[str, Dict, ToolCall], config: Optional[RunnableConfig] = None, **kwargs: Any) → Any

ainvoke 的默认实现，从线程调用 invoke。

即使 Runnable 没有实现 invoke 的原生异步版本，默认实现也允许使用异步代码。

如果子类可以异步运行，则应覆盖此方法。

参数

• input (Union[str, Dict, ToolCall]) –

• config (Optional[RunnableConfig]) –

• kwargs (Any) –

返回类型

Any

async arun(tool_input: Union[str, Dict], verbose: Optional[bool] = None, start_color: Optional[str] = 'green', color: Optional[str] = 'green', callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, run_id: Optional[UUID] = None, config: Optional[RunnableConfig] = None, tool_call_id: Optional[str] = None, **kwargs: Any) → Any

异步运行工具。

参数

• tool_input (Union[str, Dict]) – 工具的输入。

• verbose (Optional[bool]) – 是否记录工具的进度。默认为 None。

• start_color (Optional[str]) – 启动工具时使用的颜色。默认为 ‘green’。

• color (Optional[str]) – 结束工具时使用的颜色。默认为 ‘green’。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 在工具执行期间调用的回调函数。默认为 None。

• tags (Optional[List[str]]) – 与工具关联的可选标签列表。默认为 None。

• metadata (Optional[Dict[str, Any]]) – 与工具关联的可选元数据。默认为 None。

• run_name (Optional[str]) – 运行的名称。默认为 None。

• run_id (Optional[UUID]) – 运行的 ID。默认为 None。

• config (Optional[RunnableConfig]) – 工具的配置。默认为 None。

• tool_call_id (Optional[str]) – 工具调用的 ID。默认为 None。

• kwargs (Any) – 传递给工具的附加参数

返回值

工具的输出。

Raises

ToolException – 如果工具执行期间发生错误。

返回类型

Any

as_tool(args_schema: Optional[Type[BaseModel]] = None, *, name: Optional[str] = None, description: Optional[str] = None, arg_types: Optional[Dict[str, Type]] = None) → BaseTool

Beta

此 API 处于测试阶段，将来可能会发生变化。

从 Runnable 创建一个 BaseTool。

as_tool 将从 Runnable 实例化一个具有名称、描述和 args_schema 的 BaseTool。在可能的情况下，模式会从 runnable.get_input_schema 推断。或者（例如，如果 Runnable 接受 dict 作为输入，并且特定的 dict 键没有类型化），模式可以直接使用 args_schema 指定。您还可以传递 arg_types 来仅指定必需的参数及其类型。

参数

• args_schema (Optional[Type[BaseModel]]) – 工具的模式。默认为 None。

• name (Optional[str]) – 工具的名称。默认为 None。

• description (Optional[str]) – 工具的描述。默认为 None。

• arg_types (Optional[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。

返回值

一个 BaseTool 实例。

返回类型

BaseTool

类型化的字典输入

from typing import List
from typing_extensions import TypedDict
from langchain_core.runnables import RunnableLambda

class Args(TypedDict):
    a: int
    b: List[int]

def f(x: Args) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool()
as_tool.invoke({"a": 3, "b": [1, 2]})

字典输入，通过 args_schema 指定模式

from typing import Any, Dict, List
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

class FSchema(BaseModel):
    """Apply a function to an integer and list of integers."""

    a: int = Field(..., description="Integer")
    b: List[int] = Field(..., description="List of ints")

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(FSchema)
as_tool.invoke({"a": 3, "b": [1, 2]})

字典输入，通过 arg_types 指定模式

from typing import Any, Dict, List
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(arg_types={"a": int, "b": List[int]})
as_tool.invoke({"a": 3, "b": [1, 2]})

字符串输入

from langchain_core.runnables import RunnableLambda

def f(x: str) -> str:
    return x + "a"

def g(x: str) -> str:
    return x + "z"

runnable = RunnableLambda(f) | g
as_tool = runnable.as_tool()
as_tool.invoke("b")

0.2.14 版本新增。

async astream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → AsyncIterator[Output]

astream 的默认实现，它调用 ainvoke。如果子类支持流式输出，则应重写此方法。

参数

• input (Input) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

Runnable 的输出。

返回类型

AsyncIterator[Output]

astream_events(input: Any, config: Optional[RunnableConfig] = None, *, version: Literal['v1', 'v2'], include_names: Optional[Sequence[str]] = None, include_types: Optional[Sequence[str]] = None, include_tags: Optional[Sequence[str]] = None, exclude_names: Optional[Sequence[str]] = None, exclude_types: Optional[Sequence[str]] = None, exclude_tags: Optional[Sequence[str]] = None, **kwargs: Any) → AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

Beta

此 API 处于测试阶段，将来可能会发生变化。

生成事件流。

用于创建一个 StreamEvents 的迭代器，该迭代器提供关于 Runnable 进度的实时信息，包括来自中间结果的 StreamEvents。

StreamEvent 是一个具有以下模式的字典

• event: str - 事件名称的格式为

  格式：on_[runnable_type]_(start|stream|end)。

• name: str - 生成事件的 Runnable 的名称。

• run_id: str - 与发出事件的 Runnable 的给定执行随机关联的 ID。子 Runnable 作为父 Runnable 执行的一部分被调用时，会被分配自己的唯一 ID。

  Runnable 的给定执行相关联的随机生成的 ID。作为父 Runnable 执行的一部分调用的子 Runnable 将被分配其自己的唯一 ID。

• parent_ids: List[str] - 生成事件的父 runnables 的 ID 列表。

  生成事件的父 runnables 的 ID。根 Runnable 将有一个空列表。API 的 v1 版本将返回一个空列表。

• tags: Optional[List[str]] - 生成事件的 Runnable 的标签。

  生成事件的 Runnable 的标签。

• metadata: Optional[Dict[str, Any]] - 生成事件的 Runnable 的元数据。

  生成事件的 Runnable 的元数据。

• data: Dict[str, Any]

下表说明了各种链可能发出的一些事件。为了简洁起见，表中省略了元数据字段。链定义已包含在表后。

注意 此参考表适用于模式的 V2 版本。

事件	名称	块	输入	输出
on_chat_model_start	[模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}
on_chat_model_stream	[模型名称]	AIMessageChunk(content=”hello”)
on_chat_model_end	[模型名称]		{“messages”: [[SystemMessage, HumanMessage]]}	AIMessageChunk(content=”hello world”)
on_llm_start	[模型名称]		{‘input’: ‘hello’}
on_llm_stream	[模型名称]	‘Hello’
on_llm_end	[模型名称]		‘Hello human!’
on_chain_start	format_docs
on_chain_stream	format_docs	“hello world!, goodbye world!”
on_chain_end	format_docs		[Document(…)]	“hello world!, goodbye world!”
on_tool_start	some_tool		{“x”: 1, “y”: “2”}
on_tool_end	some_tool			{“x”: 1, “y”: “2”}
on_retriever_start	[检索器名称]		{“query”: “hello”}
on_retriever_end	[检索器名称]		{“query”: “hello”}	[Document(…), ..]
on_prompt_start	[模板名称]		{“question”: “hello”}
on_prompt_end	[模板名称]		{“question”: “hello”}	ChatPromptValue(messages: [SystemMessage, …])

除了标准事件外，用户还可以调度自定义事件（请参阅下面的示例）。

自定义事件将仅在 API 的 v2 版本中显示！

自定义事件具有以下格式

属性	类型	描述
名称	str	用户定义的事件名称。
数据	Any	与事件关联的数据。这可以是任何内容，但我们建议使其可 JSON 序列化。

以下是与上面显示的标准事件相关的声明

format_docs:

def format_docs(docs: List[Document]) -> str:
    '''Format the docs.'''
    return ", ".join([doc.page_content for doc in docs])

format_docs = RunnableLambda(format_docs)

some_tool:

@tool
def some_tool(x: int, y: str) -> dict:
    '''Some_tool.'''
    return {"x": x, "y": y}

提示:

template = ChatPromptTemplate.from_messages(
    [("system", "You are Cat Agent 007"), ("human", "{question}")]
).with_config({"run_name": "my_template", "tags": ["my_template"]})

示例

from langchain_core.runnables import RunnableLambda

async def reverse(s: str) -> str:
    return s[::-1]

chain = RunnableLambda(func=reverse)

events = [
    event async for event in chain.astream_events("hello", version="v2")
]

# will produce the following events (run_id, and parent_ids
# has been omitted for brevity):
[
    {
        "data": {"input": "hello"},
        "event": "on_chain_start",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"chunk": "olleh"},
        "event": "on_chain_stream",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"output": "olleh"},
        "event": "on_chain_end",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
]

示例：调度自定义事件

from langchain_core.callbacks.manager import (
    adispatch_custom_event,
)
from langchain_core.runnables import RunnableLambda, RunnableConfig
import asyncio


async def slow_thing(some_input: str, config: RunnableConfig) -> str:
    """Do something that takes a long time."""
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 1 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 2 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    return "Done"

slow_thing = RunnableLambda(slow_thing)

async for event in slow_thing.astream_events("some_input", version="v2"):
    print(event)

参数

• input (Any) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。

• version (Literal['v1', 'v2']) – 要使用的模式版本，可以是 v2 或 v1。用户应使用 v2。v1 用于向后兼容，将在 0.4.0 中弃用。在 API 稳定之前，不会分配默认值。自定义事件将仅在 v2 中显示。

• include_names (Optional[Sequence[str]]) – 仅包括来自名称匹配的 runnables 的事件。

• include_types (Optional[Sequence[str]]) – 仅包括来自类型匹配的 runnables 的事件。

• include_tags (Optional[Sequence[str]]) – 仅包括来自标签匹配的 runnables 的事件。

• exclude_names (Optional[Sequence[str]]) – 排除来自名称匹配的 runnables 的事件。

• exclude_types (Optional[Sequence[str]]) – 排除来自类型匹配的 runnables 的事件。

• exclude_tags (Optional[Sequence[str]]) – 排除来自标签匹配的 runnables 的事件。

• kwargs (Any) – 传递给 Runnable 的附加关键字参数。这些参数将传递给 astream_log，因为 astream_events 的此实现是基于 astream_log 构建的。

Yields

StreamEvents 的异步流。

Raises

NotImplementedError – 如果版本不是 v1 或 v2。

返回类型

AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

batch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]

默认实现使用线程池执行器并行运行 invoke。

批处理的默认实现非常适合 IO 绑定的可运行对象。

如果子类可以更有效地进行批处理，则应覆盖此方法；例如，如果底层 Runnable 使用支持批处理模式的 API。

参数

• inputs (List[Input]) –

• config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –

• return_exceptions (bool) –

• kwargs (Optional[Any]) –

返回类型

List[Output]

batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → Iterator[Tuple[int, Union[Output, Exception]]]

在输入列表上并行运行 invoke，并在结果完成时生成结果。

参数

• inputs (Sequence[Input]) –

• config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –

• return_exceptions (bool) –

• kwargs (Optional[Any]) –

返回类型

Iterator[Tuple[int, Union[Output, Exception]]]

configurable_alternatives(which: ConfigurableField, *, default_key: str = 'default', prefix_keys: bool = False, **kwargs: Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) → RunnableSerializable[Input, Output]

配置可在运行时设置的 Runnable 的备选项。

参数

• which (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。

• default_key (str) – 如果未选择任何备选项，则使用的默认键。默认为“default”。

• prefix_keys (bool) – 是否使用 ConfigurableField id 作为键的前缀。默认为 False。

• **kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。

返回值

配置了备选项的新 Runnable。

返回类型

RunnableSerializable[Input, Output]

from langchain_anthropic import ChatAnthropic
from langchain_core.runnables.utils import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatAnthropic(
    model_name="claude-3-sonnet-20240229"
).configurable_alternatives(
    ConfigurableField(id="llm"),
    default_key="anthropic",
    openai=ChatOpenAI()
)

# uses the default model ChatAnthropic
print(model.invoke("which organization created you?").content)

# uses ChatOpenAI
print(
    model.with_config(
        configurable={"llm": "openai"}
    ).invoke("which organization created you?").content
)

configurable_fields(**kwargs: Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) → RunnableSerializable[Input, Output]

在运行时配置特定的 Runnable 字段。

参数

**kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。

返回值

配置了字段的新 Runnable。

返回类型

RunnableSerializable[Input, Output]

from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatOpenAI(max_tokens=20).configurable_fields(
    max_tokens=ConfigurableField(
        id="output_token_number",
        name="Max tokens in the output",
        description="The maximum number of tokens in the output",
    )
)

# max_tokens = 20
print(
    "max_tokens_20: ",
    model.invoke("tell me something about chess").content
)

# max_tokens = 200
print("max_tokens_200: ", model.with_config(
    configurable={"output_token_number": 200}
    ).invoke("tell me something about chess").content
)

static get_user_agent() → str

返回类型

str

invoke(input: Union[str, Dict, ToolCall], config: Optional[RunnableConfig] = None, **kwargs: Any) → Any

将单个输入转换为输出。覆盖以实现。

参数

• input (Union[str, Dict, ToolCall]) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 调用 Runnable 时使用的配置。该配置支持标准键，如用于跟踪目的的“tags”、“metadata”，用于控制并行执行多少工作的“max_concurrency”以及其他键。有关更多详细信息，请参阅 RunnableConfig。

• kwargs (Any) –

返回值

Runnable 的输出。

返回类型

Any

run(tool_input: Union[str, Dict[str, Any]], verbose: Optional[bool] = None, start_color: Optional[str] = 'green', color: Optional[str] = 'green', callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, run_id: Optional[UUID] = None, config: Optional[RunnableConfig] = None, tool_call_id: Optional[str] = None, **kwargs: Any) → Any

运行该工具。

参数

• tool_input (Union[str, Dict[str, Any]]) – 该工具的输入。

• verbose (Optional[bool]) – 是否记录工具的进度。默认为 None。

• start_color (Optional[str]) – 启动工具时使用的颜色。默认为 ‘green’。

• color (Optional[str]) – 结束工具时使用的颜色。默认为 ‘green’。

• callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 在工具执行期间调用的回调函数。默认为 None。

• tags (Optional[List[str]]) – 与工具关联的可选标签列表。默认为 None。

• metadata (Optional[Dict[str, Any]]) – 与工具关联的可选元数据。默认为 None。

• run_name (Optional[str]) – 运行的名称。默认为 None。

• run_id (Optional[UUID]) – 运行的 ID。默认为 None。

• config (Optional[RunnableConfig]) – 工具的配置。默认为 None。

• tool_call_id (Optional[str]) – 工具调用的 ID。默认为 None。

• kwargs (Any) – 传递给工具的附加参数

返回值

工具的输出。

Raises

ToolException – 如果工具执行期间发生错误。

返回类型

Any

stream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → Iterator[Output]

stream 的默认实现，它调用 invoke。如果子类支持流式输出，则应覆盖此方法。

参数

• input (Input) – Runnable 的输入。

• config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。

• kwargs (Optional[Any]) – 要传递给 Runnable 的其他关键字参数。

Yields

Runnable 的输出。

返回类型

Iterator[Output]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]

将 Runnable 序列化为 JSON。

返回值

Runnable 的 JSON 可序列化表示形式。

返回类型

Union[SerializedConstructor, SerializedNotImplemented]

property args: dict

property is_single_input: bool

该工具是否只接受单个输入。

property tool_call_schema: Type[BaseModel]

使用 EdenAiObjectDetectionTool 的示例

• Eden AI