Skip to content

TinyFishSearchTool

autogen.tools.experimental.TinyFishSearchTool #

TinyFishSearchTool(*, llm_config=None, tinyfish_api_key=None)

Bases: Tool

TinyFishSearchTool uses the TinyFish Search API to search the web.

TinyFish Search returns ranked results with title, snippet, site name, and URL. This tool requires a TinyFish API key, which can be provided during initialization or set as an environment variable TINYFISH_API_KEY.

ATTRIBUTE DESCRIPTION
tinyfish_api_key

The API key used for authenticating with the TinyFish API.

TYPE: str

Initializes the TinyFishSearchTool.

PARAMETER DESCRIPTION
llm_config

LLM configuration. (Currently unused but kept for potential future integration).

TYPE: Optional[Union[LLMConfig, dict[str, Any]]] DEFAULT: None

tinyfish_api_key

The API key for the TinyFish API. If not provided, it attempts to read from the TINYFISH_API_KEY environment variable.

TYPE: Optional[str] DEFAULT: None

RAISES DESCRIPTION
ValueError

If tinyfish_api_key is not provided either directly or via the environment variable.

Source code in autogen/tools/experimental/tinyfish/tinyfish_tool.py
def __init__(
    self,
    *,
    llm_config: LLMConfig | dict[str, Any] | None = None,
    tinyfish_api_key: str | None = None,
):
    """Initializes the TinyFishSearchTool.

    Args:
        llm_config (Optional[Union[LLMConfig, dict[str, Any]]]): LLM configuration.
            (Currently unused but kept for potential future integration).
        tinyfish_api_key (Optional[str]): The API key for the TinyFish API. If not provided,
            it attempts to read from the ``TINYFISH_API_KEY`` environment variable.

    Raises:
        ValueError: If ``tinyfish_api_key`` is not provided either directly or via the environment variable.
    """
    self.tinyfish_api_key = tinyfish_api_key or os.getenv("TINYFISH_API_KEY")

    if self.tinyfish_api_key is None:
        raise ValueError("tinyfish_api_key must be provided either as an argument or via TINYFISH_API_KEY env var")

    def tinyfish_search(
        query: Annotated[str, "The search query string."],
        tinyfish_api_key: Annotated[str | None, Depends(on(self.tinyfish_api_key))],
        location: Annotated[str | None, "Optional country or location for geo-targeted results."] = None,
        language: Annotated[str | None, "Optional language code for result language."] = None,
    ) -> dict[str, Any]:
        """Search the web using TinyFish Search.

        Args:
            query: The search query string.
            tinyfish_api_key: The API key for TinyFish (injected dependency).
            location: Optional country or location for geo-targeted results.
            language: Optional language code for result language.

        Returns:
            A dictionary containing the query, total result count, and ranked results.

        Raises:
            ValueError: If the TinyFish API key is not available.
        """
        if tinyfish_api_key is None:
            raise ValueError("TinyFish API key is missing.")
        return _tinyfish_search(
            query=query,
            tinyfish_api_key=tinyfish_api_key,
            location=location,
            language=language,
        )

    super().__init__(
        name="tinyfish_search",
        description="Search the web using TinyFish. Returns ranked results with titles, snippets, site names, and URLs.",
        func_or_tool=tinyfish_search,
    )

name property #

name

description property #

description

func property #

func

tool_schema property #

tool_schema

Get the schema for the tool.

This is the preferred way of handling function calls with OpeaAI and compatible frameworks.

function_schema property #

function_schema

Get the schema for the function.

This is the old way of handling function calls with OpenAI and compatible frameworks. It is provided for backward compatibility.

realtime_tool_schema property #

realtime_tool_schema

Get the schema for the tool.

This is the preferred way of handling function calls with OpeaAI and compatible frameworks.

tinyfish_api_key instance-attribute #

tinyfish_api_key = tinyfish_api_key or getenv('TINYFISH_API_KEY')

register_for_llm #

register_for_llm(agent)

Registers the tool for use with a ConversableAgent's language model (LLM).

This method registers the tool so that it can be invoked by the agent during interactions with the language model.

PARAMETER DESCRIPTION
agent

The agent to which the tool will be registered.

TYPE: ConversableAgent

Source code in autogen/tools/tool.py
def register_for_llm(self, agent: "ConversableAgent") -> None:
    """Registers the tool for use with a ConversableAgent's language model (LLM).

    This method registers the tool so that it can be invoked by the agent during
    interactions with the language model.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    if self._func_schema:
        agent.update_tool_signature(self._func_schema, is_remove=False)
    else:
        agent.register_for_llm()(self)

register_for_execution #

register_for_execution(agent)

Registers the tool for direct execution by a ConversableAgent.

This method registers the tool so that it can be executed by the agent, typically outside of the context of an LLM interaction.

PARAMETER DESCRIPTION
agent

The agent to which the tool will be registered.

TYPE: ConversableAgent

Source code in autogen/tools/tool.py
def register_for_execution(self, agent: "ConversableAgent") -> None:
    """Registers the tool for direct execution by a ConversableAgent.

    This method registers the tool so that it can be executed by the agent,
    typically outside of the context of an LLM interaction.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    agent.register_for_execution()(self)

register_tool #

register_tool(agent)

Register a tool to be both proposed and executed by an agent.

Equivalent to calling both register_for_llm and register_for_execution with the same agent.

Note: This will not make the agent recommend and execute the call in the one step. If the agent recommends the tool, it will need to be the next agent to speak in order to execute the tool.

PARAMETER DESCRIPTION
agent

The agent to which the tool will be registered.

TYPE: ConversableAgent

Source code in autogen/tools/tool.py
def register_tool(self, agent: "ConversableAgent") -> None:
    """Register a tool to be both proposed and executed by an agent.

    Equivalent to calling both `register_for_llm` and `register_for_execution` with the same agent.

    Note: This will not make the agent recommend and execute the call in the one step. If the agent
    recommends the tool, it will need to be the next agent to speak in order to execute the tool.

    Args:
        agent (ConversableAgent): The agent to which the tool will be registered.
    """
    self.register_for_llm(agent)
    self.register_for_execution(agent)