lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/tools/search_api.py

@@ -0,0 +1,87 @@
+from typing import Any
+
+from langchain.tools import StructuredTool
+from langchain_community.utilities.searchapi import SearchApiAPIWrapper
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import DictInput, IntInput, MessageTextInput, MultilineInput, SecretStrInput
+from lfx.schema.data import Data
+
+
+class SearchAPIComponent(LCToolComponent):
+    display_name: str = "Search API [DEPRECATED]"
+    description: str = "Call the searchapi.io API with result limiting"
+    name = "SearchAPI"
+    documentation: str = "https://www.searchapi.io/docs/google"
+    icon = "SearchAPI"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(name="engine", display_name="Engine", value="google"),
+        SecretStrInput(name="api_key", display_name="SearchAPI API Key", required=True),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+        ),
+        DictInput(name="search_params", display_name="Search parameters", advanced=True, is_list=True),
+        IntInput(name="max_results", display_name="Max Results", value=5, advanced=True),
+        IntInput(name="max_snippet_length", display_name="Max Snippet Length", value=100, advanced=True),
+    ]
+
+    class SearchAPISchema(BaseModel):
+        query: str = Field(..., description="The search query")
+        params: dict[str, Any] = Field(default_factory=dict, description="Additional search parameters")
+        max_results: int = Field(5, description="Maximum number of results to return")
+        max_snippet_length: int = Field(100, description="Maximum length of each result snippet")
+
+    def _build_wrapper(self):
+        return SearchApiAPIWrapper(engine=self.engine, searchapi_api_key=self.api_key)
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper()
+
+        def search_func(
+            query: str, params: dict[str, Any] | None = None, max_results: int = 5, max_snippet_length: int = 100
+        ) -> list[dict[str, Any]]:
+            params = params or {}
+            full_results = wrapper.results(query=query, **params)
+            organic_results = full_results.get("organic_results", [])[:max_results]
+
+            limited_results = []
+            for result in organic_results:
+                limited_result = {
+                    "title": result.get("title", "")[:max_snippet_length],
+                    "link": result.get("link", ""),
+                    "snippet": result.get("snippet", "")[:max_snippet_length],
+                }
+                limited_results.append(limited_result)
+
+            return limited_results
+
+        tool = StructuredTool.from_function(
+            name="search_api",
+            description="Search for recent results using searchapi.io with result limiting",
+            func=search_func,
+            args_schema=self.SearchAPISchema,
+        )
+
+        self.status = f"Search API Tool created with engine: {self.engine}"
+        return tool
+
+    def run_model(self) -> list[Data]:
+        tool = self.build_tool()
+        results = tool.run(
+            {
+                "query": self.input_value,
+                "params": self.search_params or {},
+                "max_results": self.max_results,
+                "max_snippet_length": self.max_snippet_length,
+            }
+        )
+
+        data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
+
+        self.status = data_list
+        return data_list

lfx/components/tools/searxng.py

@@ -0,0 +1,145 @@
+import json
+from collections.abc import Sequence
+from typing import Any
+
+import requests
+from langchain.agents import Tool
+from langchain_core.tools import StructuredTool
+from pydantic.v1 import Field, create_model
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.inputs.inputs import DropdownInput, IntInput, MessageTextInput, MultiselectInput
+from lfx.io import Output
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+
+
+class SearXNGToolComponent(LCToolComponent):
+    search_headers: dict = {}
+    display_name = "SearXNG Search"
+    description = "A component that searches for tools using SearXNG."
+    name = "SearXNGTool"
+    legacy: bool = True
+
+    inputs = [
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            value="http://localhost",
+            required=True,
+            refresh_button=True,
+        ),
+        IntInput(
+            name="max_results",
+            display_name="Max Results",
+            value=10,
+            required=True,
+        ),
+        MultiselectInput(
+            name="categories",
+            display_name="Categories",
+            options=[],
+            value=[],
+        ),
+        DropdownInput(
+            name="language",
+            display_name="Language",
+            options=[],
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Tool", name="result_tool", method="build_tool"),
+    ]
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        if field_name is None:
+            return build_config
+
+        if field_name != "url":
+            return build_config
+
+        try:
+            url = f"{field_value}/config"
+
+            response = requests.get(url=url, headers=self.search_headers.copy(), timeout=10)
+            data = None
+            if response.headers.get("Content-Encoding") == "zstd":
+                data = json.loads(response.content)
+            else:
+                data = response.json()
+            build_config["categories"]["options"] = data["categories"].copy()
+            for selected_category in build_config["categories"]["value"]:
+                if selected_category not in build_config["categories"]["options"]:
+                    build_config["categories"]["value"].remove(selected_category)
+            languages = list(data["locales"])
+            build_config["language"]["options"] = languages.copy()
+        except Exception as e:  # noqa: BLE001
+            self.status = f"Failed to extract names: {e}"
+            logger.debug(self.status, exc_info=True)
+            build_config["categories"]["options"] = ["Failed to parse", str(e)]
+        return build_config
+
+    def build_tool(self) -> Tool:
+        class SearxSearch:
+            _url: str = ""
+            _categories: list[str] = []
+            _language: str = ""
+            _headers: dict = {}
+            _max_results: int = 10
+
+            @staticmethod
+            def search(query: str, categories: Sequence[str] = ()) -> list:
+                if not SearxSearch._categories and not categories:
+                    msg = "No categories provided."
+                    raise ValueError(msg)
+                all_categories = SearxSearch._categories + list(set(categories) - set(SearxSearch._categories))
+                try:
+                    url = f"{SearxSearch._url}/"
+                    headers = SearxSearch._headers.copy()
+                    response = requests.get(
+                        url=url,
+                        headers=headers,
+                        params={
+                            "q": query,
+                            "categories": ",".join(all_categories),
+                            "language": SearxSearch._language,
+                            "format": "json",
+                        },
+                        timeout=10,
+                    ).json()
+
+                    num_results = min(SearxSearch._max_results, len(response["results"]))
+                    return [response["results"][i] for i in range(num_results)]
+                except Exception as e:  # noqa: BLE001
+                    logger.debug("Error running SearXNG Search", exc_info=True)
+                    return [f"Failed to search: {e}"]
+
+        SearxSearch._url = self.url
+        SearxSearch._categories = self.categories.copy()
+        SearxSearch._language = self.language
+        SearxSearch._headers = self.search_headers.copy()
+        SearxSearch._max_results = self.max_results
+
+        globals_ = globals()
+        local = {}
+        local["SearxSearch"] = SearxSearch
+        globals_.update(local)
+
+        schema_fields = {
+            "query": (str, Field(..., description="The query to search for.")),
+            "categories": (
+                list[str],
+                Field(default=[], description="The categories to search in."),
+            ),
+        }
+
+        searx_search_schema = create_model("SearxSearchSchema", **schema_fields)
+
+        return StructuredTool.from_function(
+            func=local["SearxSearch"].search,
+            args_schema=searx_search_schema,
+            name="searxng_search_tool",
+            description="A tool that searches for tools using SearXNG.\nThe available categories are: "
+            + ", ".join(self.categories),
+        )

lfx/components/tools/serp_api.py

@@ -0,0 +1,119 @@
+from typing import Any
+
+from langchain.tools import StructuredTool
+from langchain_community.utilities.serpapi import SerpAPIWrapper
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class SerpAPISchema(BaseModel):
+    """Schema for SerpAPI search parameters."""
+
+    query: str = Field(..., description="The search query")
+    params: dict[str, Any] | None = Field(
+        default={
+            "engine": "google",
+            "google_domain": "google.com",
+            "gl": "us",
+            "hl": "en",
+        },
+        description="Additional search parameters",
+    )
+    max_results: int = Field(5, description="Maximum number of results to return")
+    max_snippet_length: int = Field(100, description="Maximum length of each result snippet")
+
+
+class SerpAPIComponent(LCToolComponent):
+    display_name = "Serp Search API [DEPRECATED]"
+    description = "Call Serp Search API with result limiting"
+    name = "SerpAPI"
+    icon = "SerpSearch"
+    legacy = True
+
+    inputs = [
+        SecretStrInput(name="serpapi_api_key", display_name="SerpAPI API Key", required=True),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+        ),
+        DictInput(name="search_params", display_name="Parameters", advanced=True, is_list=True),
+        IntInput(name="max_results", display_name="Max Results", value=5, advanced=True),
+        IntInput(name="max_snippet_length", display_name="Max Snippet Length", value=100, advanced=True),
+    ]
+
+    def _build_wrapper(self, params: dict[str, Any] | None = None) -> SerpAPIWrapper:
+        """Build a SerpAPIWrapper with the provided parameters."""
+        params = params or {}
+        if params:
+            return SerpAPIWrapper(
+                serpapi_api_key=self.serpapi_api_key,
+                params=params,
+            )
+        return SerpAPIWrapper(serpapi_api_key=self.serpapi_api_key)
+
+    def build_tool(self) -> Tool:
+        wrapper = self._build_wrapper(self.search_params)
+
+        def search_func(
+            query: str, params: dict[str, Any] | None = None, max_results: int = 5, max_snippet_length: int = 100
+        ) -> list[dict[str, Any]]:
+            try:
+                local_wrapper = wrapper
+                if params:
+                    local_wrapper = self._build_wrapper(params)
+
+                full_results = local_wrapper.results(query)
+                organic_results = full_results.get("organic_results", [])[:max_results]
+
+                limited_results = []
+                for result in organic_results:
+                    limited_result = {
+                        "title": result.get("title", "")[:max_snippet_length],
+                        "link": result.get("link", ""),
+                        "snippet": result.get("snippet", "")[:max_snippet_length],
+                    }
+                    limited_results.append(limited_result)
+
+            except Exception as e:
+                error_message = f"Error in SerpAPI search: {e!s}"
+                logger.debug(error_message)
+                raise ToolException(error_message) from e
+            return limited_results
+
+        tool = StructuredTool.from_function(
+            name="serp_search_api",
+            description="Search for recent results using SerpAPI with result limiting",
+            func=search_func,
+            args_schema=SerpAPISchema,
+        )
+
+        self.status = "SerpAPI Tool created"
+        return tool
+
+    def run_model(self) -> list[Data]:
+        tool = self.build_tool()
+        try:
+            results = tool.run(
+                {
+                    "query": self.input_value,
+                    "params": self.search_params or {},
+                    "max_results": self.max_results,
+                    "max_snippet_length": self.max_snippet_length,
+                }
+            )
+
+            data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
+
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error running SerpAPI", exc_info=True)
+            self.status = f"Error: {e}"
+            return [Data(data={"error": str(e)}, text=str(e))]
+
+        self.status = data_list  # type: ignore[assignment]
+        return data_list

lfx/components/tools/tavily_search_tool.py

@@ -0,0 +1,344 @@
+from enum import Enum
+
+import httpx
+from langchain.tools import StructuredTool
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+# Add at the top with other constants
+MAX_CHUNKS_PER_SOURCE = 3
+
+
+class TavilySearchDepth(Enum):
+    BASIC = "basic"
+    ADVANCED = "advanced"
+
+
+class TavilySearchTopic(Enum):
+    GENERAL = "general"
+    NEWS = "news"
+
+
+class TavilySearchTimeRange(Enum):
+    DAY = "day"
+    WEEK = "week"
+    MONTH = "month"
+    YEAR = "year"
+
+
+class TavilySearchSchema(BaseModel):
+    query: str = Field(..., description="The search query you want to execute with Tavily.")
+    search_depth: TavilySearchDepth = Field(TavilySearchDepth.BASIC, description="The depth of the search.")
+    topic: TavilySearchTopic = Field(TavilySearchTopic.GENERAL, description="The category of the search.")
+    max_results: int = Field(5, description="The maximum number of search results to return.")
+    include_images: bool = Field(default=False, description="Include a list of query-related images in the response.")
+    include_answer: bool = Field(default=False, description="Include a short answer to original query.")
+    chunks_per_source: int = Field(
+        default=MAX_CHUNKS_PER_SOURCE,
+        description=(
+            "The number of content chunks to retrieve from each source (max 500 chars each). Only for advanced search."
+        ),
+        ge=1,
+        le=MAX_CHUNKS_PER_SOURCE,
+    )
+    include_domains: list[str] = Field(
+        default=[],
+        description="A list of domains to specifically include in the search results.",
+    )
+    exclude_domains: list[str] = Field(
+        default=[],
+        description="A list of domains to specifically exclude from the search results.",
+    )
+    include_raw_content: bool = Field(
+        default=False,
+        description="Include the cleaned and parsed HTML content of each search result.",
+    )
+    days: int = Field(
+        default=7,
+        description="Number of days back from the current date to include. Only available if topic is news.",
+        ge=1,
+    )
+    time_range: TavilySearchTimeRange | None = Field(
+        default=None,
+        description="The time range back from the current date to filter results.",
+    )
+
+
+class TavilySearchToolComponent(LCToolComponent):
+    display_name = "Tavily Search API"
+    description = """**Tavily Search API** is a search engine optimized for LLMs and RAG, \
+        aimed at efficient, quick, and persistent search results. It can be used independently or as an agent tool.
+
+Note: Check 'Advanced' for all options.
+"""
+    icon = "TavilyIcon"
+    name = "TavilyAISearch"
+    documentation = "https://docs.tavily.com/"
+    legacy = True
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Tavily API Key",
+            required=True,
+            info="Your Tavily API Key.",
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="Search Query",
+            info="The search query you want to execute with Tavily.",
+        ),
+        DropdownInput(
+            name="search_depth",
+            display_name="Search Depth",
+            info="The depth of the search.",
+            options=list(TavilySearchDepth),
+            value=TavilySearchDepth.ADVANCED,
+            advanced=True,
+        ),
+        IntInput(
+            name="chunks_per_source",
+            display_name="Chunks Per Source",
+            info=("The number of content chunks to retrieve from each source (1-3). Only works with advanced search."),
+            value=MAX_CHUNKS_PER_SOURCE,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="topic",
+            display_name="Search Topic",
+            info="The category of the search.",
+            options=list(TavilySearchTopic),
+            value=TavilySearchTopic.GENERAL,
+            advanced=True,
+        ),
+        IntInput(
+            name="days",
+            display_name="Days",
+            info="Number of days back from current date to include. Only available with news topic.",
+            value=7,
+            advanced=True,
+        ),
+        IntInput(
+            name="max_results",
+            display_name="Max Results",
+            info="The maximum number of search results to return.",
+            value=5,
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_answer",
+            display_name="Include Answer",
+            info="Include a short answer to original query.",
+            value=True,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="time_range",
+            display_name="Time Range",
+            info="The time range back from the current date to filter results.",
+            options=list(TavilySearchTimeRange),
+            value=None,
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_images",
+            display_name="Include Images",
+            info="Include a list of query-related images in the response.",
+            value=True,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="include_domains",
+            display_name="Include Domains",
+            info="Comma-separated list of domains to include in the search results.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="exclude_domains",
+            display_name="Exclude Domains",
+            info="Comma-separated list of domains to exclude from the search results.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_raw_content",
+            display_name="Include Raw Content",
+            info="Include the cleaned and parsed HTML content of each search result.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    def run_model(self) -> list[Data]:
+        # Convert string values to enum instances with validation
+        try:
+            search_depth_enum = (
+                self.search_depth
+                if isinstance(self.search_depth, TavilySearchDepth)
+                else TavilySearchDepth(str(self.search_depth).lower())
+            )
+        except ValueError as e:
+            error_message = f"Invalid search depth value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        try:
+            topic_enum = (
+                self.topic if isinstance(self.topic, TavilySearchTopic) else TavilySearchTopic(str(self.topic).lower())
+            )
+        except ValueError as e:
+            error_message = f"Invalid topic value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        try:
+            time_range_enum = (
+                self.time_range
+                if isinstance(self.time_range, TavilySearchTimeRange)
+                else TavilySearchTimeRange(str(self.time_range).lower())
+                if self.time_range
+                else None
+            )
+        except ValueError as e:
+            error_message = f"Invalid time range value: {e!s}"
+            self.status = error_message
+            return [Data(data={"error": error_message})]
+
+        # Initialize domain variables as None
+        include_domains = None
+        exclude_domains = None
+
+        # Only process domains if they're provided
+        if self.include_domains:
+            include_domains = [domain.strip() for domain in self.include_domains.split(",") if domain.strip()]
+
+        if self.exclude_domains:
+            exclude_domains = [domain.strip() for domain in self.exclude_domains.split(",") if domain.strip()]
+
+        return self._tavily_search(
+            self.query,
+            search_depth=search_depth_enum,
+            topic=topic_enum,
+            max_results=self.max_results,
+            include_images=self.include_images,
+            include_answer=self.include_answer,
+            chunks_per_source=self.chunks_per_source,
+            include_domains=include_domains,
+            exclude_domains=exclude_domains,
+            include_raw_content=self.include_raw_content,
+            days=self.days,
+            time_range=time_range_enum,
+        )
+
+    def build_tool(self) -> Tool:
+        return StructuredTool.from_function(
+            name="tavily_search",
+            description="Perform a web search using the Tavily API.",
+            func=self._tavily_search,
+            args_schema=TavilySearchSchema,
+        )
+
+    def _tavily_search(
+        self,
+        query: str,
+        *,
+        search_depth: TavilySearchDepth = TavilySearchDepth.BASIC,
+        topic: TavilySearchTopic = TavilySearchTopic.GENERAL,
+        max_results: int = 5,
+        include_images: bool = False,
+        include_answer: bool = False,
+        chunks_per_source: int = MAX_CHUNKS_PER_SOURCE,
+        include_domains: list[str] | None = None,
+        exclude_domains: list[str] | None = None,
+        include_raw_content: bool = False,
+        days: int = 7,
+        time_range: TavilySearchTimeRange | None = None,
+    ) -> list[Data]:
+        # Validate enum values
+        if not isinstance(search_depth, TavilySearchDepth):
+            msg = f"Invalid search_depth value: {search_depth}"
+            raise TypeError(msg)
+        if not isinstance(topic, TavilySearchTopic):
+            msg = f"Invalid topic value: {topic}"
+            raise TypeError(msg)
+
+        # Validate chunks_per_source range
+        if not 1 <= chunks_per_source <= MAX_CHUNKS_PER_SOURCE:
+            msg = f"chunks_per_source must be between 1 and {MAX_CHUNKS_PER_SOURCE}, got {chunks_per_source}"
+            raise ValueError(msg)
+
+        # Validate days is positive
+        if days < 1:
+            msg = f"days must be greater than or equal to 1, got {days}"
+            raise ValueError(msg)
+
+        try:
+            url = "https://api.tavily.com/search"
+            headers = {
+                "content-type": "application/json",
+                "accept": "application/json",
+            }
+            payload = {
+                "api_key": self.api_key,
+                "query": query,
+                "search_depth": search_depth.value,
+                "topic": topic.value,
+                "max_results": max_results,
+                "include_images": include_images,
+                "include_answer": include_answer,
+                "chunks_per_source": chunks_per_source if search_depth == TavilySearchDepth.ADVANCED else None,
+                "include_domains": include_domains if include_domains else None,
+                "exclude_domains": exclude_domains if exclude_domains else None,
+                "include_raw_content": include_raw_content,
+                "days": days if topic == TavilySearchTopic.NEWS else None,
+                "time_range": time_range.value if time_range else None,
+            }
+
+            with httpx.Client(timeout=90.0) as client:
+                response = client.post(url, json=payload, headers=headers)
+
+            response.raise_for_status()
+            search_results = response.json()
+
+            data_results = [
+                Data(
+                    data={
+                        "title": result.get("title"),
+                        "url": result.get("url"),
+                        "content": result.get("content"),
+                        "score": result.get("score"),
+                        "raw_content": result.get("raw_content") if include_raw_content else None,
+                    }
+                )
+                for result in search_results.get("results", [])
+            ]
+
+            if include_answer and search_results.get("answer"):
+                data_results.insert(0, Data(data={"answer": search_results["answer"]}))
+
+            if include_images and search_results.get("images"):
+                data_results.append(Data(data={"images": search_results["images"]}))
+
+            self.status = data_results  # type: ignore[assignment]
+
+        except httpx.TimeoutException as e:
+            error_message = "Request timed out (90s). Please try again or adjust parameters."
+            logger.error(f"Timeout error: {e}")
+            self.status = error_message
+            raise ToolException(error_message) from e
+        except httpx.HTTPStatusError as e:
+            error_message = f"HTTP error: {e.response.status_code} - {e.response.text}"
+            logger.debug(error_message)
+            self.status = error_message
+            raise ToolException(error_message) from e
+        except Exception as e:
+            error_message = f"Unexpected error: {e}"
+            logger.debug("Error running Tavily Search", exc_info=True)
+            self.status = error_message
+            raise ToolException(error_message) from e
+        return data_results