lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/tools/search_api.py

@@ -0,0 +1,88 @@
+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"
+    description: str = "Call the searchapi.io API with result limiting"
+    name = "SearchAPI"
+    documentation: str = "https://www.searchapi.io/docs/google"
+    icon = "SearchAPI"
+    legacy = True
+    replacement = ["searchapi.SearchComponent"]
+
+    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,120 @@
+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"
+    description = "Call Serp Search API with result limiting"
+    name = "SerpAPI"
+    icon = "SerpSearch"
+    legacy = True
+    replacement = ["serpapi.Serp"]
+
+    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