ag2 0.10.2__py3-none-any.whl

autogen/tools/experimental/searxng/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .searxng_search import SearxngSearchTool
+
+__all__ = ["SearxngSearchTool"]

autogen/tools/experimental/searxng/searxng_search.py

@@ -0,0 +1,142 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+"""SearxNG Search Tool
+A simple tool to perform web searches using a SearxNG instance.
+"""
+
+import logging
+from typing import Annotated, Any
+
+import requests
+
+from autogen.doc_utils import export_module
+from autogen.tools import Tool
+
+logger = logging.getLogger(__name__)
+
+
+def _execute_searxng_query(
+    query: str,
+    max_results: int = 5,
+    categories: list[str] | None = None,
+    language: str | None = None,
+    base_url: str = "https://searxng.site/search",
+) -> list[dict[str, Any]]:
+    """Execute a search query using a SearxNG instance.
+
+    Args:
+        query (str): The search query string.
+        max_results (int, optional): The maximum number of results to return. Defaults to 5.
+        categories (Optional[List[str]]): List of categories to search in.
+        language (Optional[str]): Language code.
+        base_url (str): SearxNG instance URL.
+
+    Returns:
+        list[dict[str, Any]]: A list of search results from SearxNG.
+    """
+    params = {
+        "q": query,
+        "format": "json",
+        "language": language or "en-US",
+        "categories": ",".join(categories) if categories else None,
+        "count": max_results,
+    }
+    params = {k: v for k, v in params.items() if v is not None}
+    try:
+        response = requests.get(base_url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        results = data.get("results", [])
+        if not isinstance(results, list):
+            return []
+        # Ensure each result is a dict before returning
+        typed_results: list[dict[str, Any]] = []
+        for item in results:
+            if isinstance(item, dict):
+                typed_results.append(item)
+        return typed_results
+    except Exception as e:
+        logger.error(f"SearxNG Search failed: {e}")
+        return []
+
+
+def _searxng_search(
+    query: str,
+    max_results: int = 5,
+    categories: list[str] | None = None,
+    language: str | None = None,
+    base_url: str = "https://searxng.site/search",
+) -> list[dict[str, Any]]:
+    """Perform a SearxNG search and format the results.
+
+    Args:
+        query (str): The search query string.
+        max_results (int, optional): The maximum number of results to return. Defaults to 5.
+        categories (Optional[List[str]]): List of categories to search in.
+        language (Optional[str]): Language code.
+        base_url (str): SearxNG instance URL.
+
+    Returns:
+        list[dict[str, Any]]: A list of dictionaries with 'title', 'link', and 'snippet'.
+    """
+    res = _execute_searxng_query(
+        query=query,
+        max_results=max_results,
+        categories=categories,
+        language=language,
+        base_url=base_url,
+    )
+    formatted_results: list[dict[str, Any]] = [
+        {"title": item.get("title", ""), "link": item.get("url", ""), "snippet": item.get("content", "")}
+        for item in res
+    ]
+    return formatted_results
+
+
+@export_module("autogen.tools.experimental")
+class SearxngSearchTool(Tool):
+    """SearxngSearchTool is a tool that uses SearxNG to perform a search.
+
+    This tool allows agents to leverage the SearxNG search engine for information retrieval.
+    SearxNG does not require an API key by default, making it easy to use.
+    """
+
+    def __init__(self, base_url: str = "https://searxng.site/search") -> None:
+        """Initializes the SearxngSearchTool.
+
+        Args:
+            base_url (str): The SearxNG instance URL.
+        """
+        self.base_url = base_url
+        super().__init__(
+            name="searxng_search",
+            description="Use the SearxNG API to perform a search.",
+            func_or_tool=self.searxng_search,
+        )
+
+    def searxng_search(
+        self,
+        query: Annotated[str, "The search query."],
+        max_results: Annotated[int, "The number of results to return."] = 5,
+        categories: Annotated[list[str] | None, "List of categories to search in."] = None,
+        language: Annotated[str | None, "Language code (e.g., 'en-US')."] = None,
+    ) -> list[dict[str, Any]]:
+        """Performs a search using the SearxNG API and returns formatted results.
+
+        Args:
+            query: The search query string.
+            max_results: The maximum number of results to return. Defaults to 5.
+            categories: List of categories to search in.
+            language: Language code.
+
+        Returns:
+            A list of dictionaries, each containing 'title', 'link', and 'snippet' of a search result.
+        """
+        return _searxng_search(
+            query=query,
+            max_results=max_results,
+            categories=categories,
+            language=language,
+            base_url=self.base_url,
+        )

autogen/tools/experimental/tavily/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .tavily_search import TavilySearchTool
+
+__all__ = ["TavilySearchTool"]

autogen/tools/experimental/tavily/tavily_search.py

@@ -0,0 +1,176 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import os
+from typing import Annotated, Any
+
+from ....doc_utils import export_module
+from ....import_utils import optional_import_block, require_optional_import
+from ....llm_config import LLMConfig
+from ... import Depends, Tool
+from ...dependency_injection import on
+
+with optional_import_block():
+    from tavily import TavilyClient
+
+
+@require_optional_import(
+    [
+        "tavily",
+    ],
+    "tavily",
+)
+def _execute_tavily_query(
+    query: str,
+    tavily_api_key: str,
+    search_depth: str = "basic",
+    topic: str = "general",
+    include_answer: str = "basic",
+    include_raw_content: bool = False,
+    include_domains: list[str] = [],
+    num_results: int = 5,
+) -> Any:
+    """Execute a search query using the Tavily API.
+
+    Args:
+        query (str): The search query string.
+        tavily_api_key (str): The API key for Tavily.
+        search_depth (str, optional): The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+        topic (str, optional): The topic of the search. Defaults to "general".
+        include_answer (str, optional): Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+        include_raw_content (bool, optional): Whether to include raw content in the results. Defaults to False.
+        include_domains (list[str], optional): A list of domains to include in the search. Defaults to [].
+        num_results (int, optional): The maximum number of results to return. Defaults to 5.
+
+    Returns:
+        Any: The raw response object from the Tavily API client.
+    """
+    tavily_client = TavilyClient(api_key=tavily_api_key)
+    return tavily_client.search(
+        query=query,
+        search_depth=search_depth,
+        topic=topic,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_domains=include_domains,
+        max_results=num_results,
+    )
+
+
+def _tavily_search(
+    query: str,
+    tavily_api_key: str,
+    search_depth: str = "basic",
+    topic: str = "general",
+    include_answer: str = "basic",
+    include_raw_content: bool = False,
+    include_domains: list[str] = [],
+    num_results: int = 5,
+) -> list[dict[str, Any]]:
+    """Perform a Tavily search and format the results.
+
+    This function takes search parameters, executes the query using `_execute_tavily_query`,
+    and formats the results into a list of dictionaries containing title, link, and snippet.
+
+    Args:
+        query (str): The search query string.
+        tavily_api_key (str): The API key for Tavily.
+        search_depth (str, optional): The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+        topic (str, optional): The topic of the search. Defaults to "general".
+        include_answer (str, optional): Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+        include_raw_content (bool, optional): Whether to include raw content in the results. Defaults to False.
+        include_domains (list[str], optional): A list of domains to include in the search. Defaults to [].
+        num_results (int, optional): The maximum number of results to return. Defaults to 5.
+
+    Returns:
+        list[dict[str, Any]]: A list of dictionaries, where each dictionary represents a search result
+            with keys 'title', 'link', and 'snippet'. Returns an empty list if no results are found.
+    """
+    res = _execute_tavily_query(
+        query=query,
+        tavily_api_key=tavily_api_key,
+        search_depth=search_depth,
+        topic=topic,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_domains=include_domains,
+        num_results=num_results,
+    )
+
+    return [
+        {"title": item.get("title", ""), "link": item.get("url", ""), "snippet": item.get("content", "")}
+        for item in res.get("results", [])
+    ]
+
+
+@export_module("autogen.tools.experimental")
+class TavilySearchTool(Tool):
+    """TavilySearchTool is a tool that uses the Tavily Search API to perform a search.
+
+    This tool allows agents to leverage the Tavily search engine for information retrieval.
+    It requires a Tavily API key, which can be provided during initialization or set as
+    an environment variable `TAVILY_API_KEY`.
+
+    Attributes:
+        tavily_api_key (str): The API key used for authenticating with the Tavily API.
+    """
+
+    def __init__(self, *, llm_config: LLMConfig | dict[str, Any] | None = None, tavily_api_key: str | None = None):
+        """Initializes the TavilySearchTool.
+
+        Args:
+            llm_config (Optional[Union[LLMConfig, dict[str, Any]]]): LLM configuration. (Currently unused but kept for potential future integration).
+            tavily_api_key (Optional[str]): The API key for the Tavily Search API. If not provided,
+                it attempts to read from the `TAVILY_API_KEY` environment variable.
+
+        Raises:
+            ValueError: If `tavily_api_key` is not provided either directly or via the environment variable.
+        """
+        self.tavily_api_key = tavily_api_key or os.getenv("TAVILY_API_KEY")
+
+        if self.tavily_api_key is None:
+            raise ValueError("tavily_api_key must be provided either as an argument or via TAVILY_API_KEY env var")
+
+        def tavily_search(
+            query: Annotated[str, "The search query."],
+            tavily_api_key: Annotated[str | None, Depends(on(self.tavily_api_key))],
+            search_depth: Annotated[str | None, "Either 'advanced' or 'basic'"] = "basic",
+            include_answer: Annotated[str | None, "Either 'advanced' or 'basic'"] = "basic",
+            include_raw_content: Annotated[bool | None, "Include the raw contents"] = False,
+            include_domains: Annotated[list[str] | None, "Specific web domains to search"] = [],
+            num_results: Annotated[int, "The number of results to return."] = 5,
+        ) -> list[dict[str, Any]]:
+            """Performs a search using the Tavily API and returns formatted results.
+
+            Args:
+                query: The search query string.
+                tavily_api_key: The API key for Tavily (injected dependency).
+                search_depth: The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+                include_answer: Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+                include_raw_content: Whether to include raw content in the results. Defaults to False.
+                include_domains: A list of domains to include in the search. Defaults to [].
+                num_results: The maximum number of results to return. Defaults to 5.
+
+            Returns:
+                A list of dictionaries, each containing 'title', 'link', and 'snippet' of a search result.
+
+            Raises:
+                ValueError: If the Tavily API key is not available.
+            """
+            if tavily_api_key is None:
+                raise ValueError("Tavily API key is missing.")
+            return _tavily_search(
+                query=query,
+                tavily_api_key=tavily_api_key,
+                search_depth=search_depth or "basic",
+                include_answer=include_answer or "basic",
+                include_raw_content=include_raw_content or False,
+                include_domains=include_domains or [],
+                num_results=num_results,
+            )
+
+        super().__init__(
+            name="tavily_search",
+            description="Use the Tavily Search API to perform a search.",
+            func_or_tool=tavily_search,
+        )

autogen/tools/experimental/web_search_preview/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .web_search_preview import WebSearchPreviewTool
+
+__all__ = ["WebSearchPreviewTool"]

autogen/tools/experimental/web_search_preview/web_search_preview.py

@@ -0,0 +1,120 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+import copy
+import logging
+import os
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel
+
+from ....doc_utils import export_module
+from ....import_utils import optional_import_block, require_optional_import
+from ....llm_config import LLMConfig
+from ... import Tool
+
+with optional_import_block():
+    from openai import OpenAI
+    from openai.types.responses import WebSearchToolParam
+    from openai.types.responses.web_search_tool import UserLocation
+
+
+@require_optional_import("openai>=1.66.2", "openai")
+@export_module("autogen.tools.experimental")
+class WebSearchPreviewTool(Tool):
+    """WebSearchPreviewTool is a tool that uses OpenAI's web_search_preview tool to perform a search."""
+
+    def __init__(
+        self,
+        *,
+        llm_config: LLMConfig | dict[str, Any],
+        search_context_size: Literal["low", "medium", "high"] = "medium",
+        user_location: dict[str, str] | None = None,
+        instructions: str | None = None,
+        text_format: type[BaseModel] | None = None,
+    ):
+        """Initialize the WebSearchPreviewTool.
+
+        Args:
+            llm_config: The LLM configuration to use. This should be a dictionary
+                containing the model name and other parameters.
+            search_context_size: The size of the search context. One of `low`, `medium`, or `high`.
+                `medium` is the default.
+            user_location: The location of the user. This should be a dictionary containing
+                the city, country, region, and timezone.
+            instructions: Inserts a system (or developer) message as the first item in the model's context.
+            text_format: The format of the text to be returned. This should be a subclass of `BaseModel`.
+                The default is `None`, which means the text will be returned as a string.
+        """
+        self.web_search_tool_param = WebSearchToolParam(
+            type="web_search_preview",  # type: ignore[typeddict-item]
+            search_context_size=search_context_size,
+            user_location=UserLocation(**user_location) if user_location else None,  # type: ignore[typeddict-item]
+        )
+        self.instructions = instructions
+        self.text_format = text_format
+
+        if isinstance(llm_config, LLMConfig):
+            llm_config = llm_config.model_dump()
+
+        llm_config = copy.deepcopy(llm_config)
+
+        if "config_list" not in llm_config:
+            raise ValueError("llm_config must contain 'config_list' key")
+
+        # Find first OpenAI model which starts with "gpt-4"
+        self.model = None
+        self.api_key = None
+        for model in llm_config["config_list"]:
+            if model["model"].startswith("gpt-4") and model.get("api_type", "openai") == "openai":
+                self.model = model["model"]
+                self.api_key = model.get("api_key", os.getenv("OPENAI_API_KEY"))
+                break
+        if self.model is None:
+            raise ValueError(
+                "No OpenAI model starting with 'gpt-4' found in llm_config, other models do not support web_search_preview"
+            )
+
+        if not self.model.startswith("gpt-4.1") and not self.model.startswith("gpt-4o-search-preview"):
+            logging.warning(
+                f"We recommend using a model starting with 'gpt-4.1' or 'gpt-4o-search-preview' for web_search_preview, but found {self.model}. "
+                "This may result in suboptimal performance."
+            )
+
+        def web_search_preview(
+            query: Annotated[str, "The search query. Add all relevant context to the query."],
+        ) -> str | BaseModel | None:
+            client = OpenAI()
+
+            if not self.text_format:
+                response = client.responses.create(
+                    model=self.model,  # type: ignore[arg-type]
+                    tools=[self.web_search_tool_param],
+                    input=query,
+                    instructions=self.instructions,
+                )
+                text = []
+                for output in response.output:
+                    if output.type == "message":
+                        for content in output.content:
+                            if content.type == "output_text":
+                                text.append(content.text)
+                return "\n".join(text)
+
+            else:
+                response = client.responses.parse(
+                    model=self.model,  # type: ignore[arg-type]
+                    tools=[self.web_search_tool_param],
+                    input=query,
+                    instructions=self.instructions,
+                    text_format=self.text_format,
+                )
+                return response.output_parsed
+
+        super().__init__(
+            name="web_search_preview",
+            description="Tool used to perform a web search. It can be used as google search or directly searching a specific website.",
+            func_or_tool=web_search_preview,
+        )

autogen/tools/experimental/wikipedia/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .wikipedia import WikipediaPageLoadTool, WikipediaQueryRunTool
+
+__all__ = ["WikipediaPageLoadTool", "WikipediaQueryRunTool"]