Skip to content

TinyFishTool

autogen.tools.experimental.TinyFishTool #

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

Bases: Tool

TinyFishTool is a tool that uses the TinyFish API to deep-scrape web pages with a natural language goal.

TinyFish performs goal-directed web scraping — you provide a URL and describe what information you want to extract, and it returns structured results.

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 TinyFishTool.

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 TinyFishTool.

    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_scrape(
        url: Annotated[str, "The URL to scrape."],
        goal: Annotated[str, "A natural language description of what information to extract from the page."],
        tinyfish_api_key: Annotated[str | None, Depends(on(self.tinyfish_api_key))],
    ) -> dict[str, Any]:
        """Deep-scrape a URL using TinyFish with a natural language goal.

        Pass a URL and describe what you want to extract. TinyFish will navigate the page
        and return structured data matching your goal.

        Args:
            url: The URL to scrape.
            goal: A natural language description of what to extract (e.g.,
                "Find all team members and their roles",
                "Extract pricing information and plan details").
            tinyfish_api_key: The API key for TinyFish (injected dependency).

        Returns:
            A dictionary containing the URL, goal, and extracted data.

        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_scrape(
            url=url,
            goal=goal,
            tinyfish_api_key=tinyfish_api_key,
        )

    super().__init__(
        name="tinyfish_scrape",
        description="Deep-scrape a URL using TinyFish. Pass a URL and a natural language goal describing what to extract.",
        func_or_tool=tinyfish_scrape,
    )

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)