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

lfx/components/redis/redis.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.vectorstores.redis import Redis
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class RedisVectorStoreComponent(LCVectorStoreComponent):
+    """A custom component for implementing a Vector Store using Redis."""
+
+    display_name: str = "Redis"
+    description: str = "Implementation of Vector Store using Redis"
+    name = "Redis"
+    icon = "Redis"
+
+    inputs = [
+        SecretStrInput(name="redis_server_url", display_name="Redis Server Connection String", required=True),
+        StrInput(
+            name="redis_index_name",
+            display_name="Redis Index",
+        ),
+        StrInput(name="code", display_name="Code", advanced=True),
+        StrInput(
+            name="schema",
+            display_name="Schema",
+        ),
+        *LCVectorStoreComponent.inputs,
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Redis:
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+        Path("docuemnts.txt").write_text(str(documents), encoding="utf-8")
+
+        if not documents:
+            if self.schema is None:
+                msg = "If no documents are provided, a schema must be provided."
+                raise ValueError(msg)
+            redis_vs = Redis.from_existing_index(
+                embedding=self.embedding,
+                index_name=self.redis_index_name,
+                schema=self.schema,
+                key_prefix=None,
+                redis_url=self.redis_server_url,
+            )
+        else:
+            text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+            docs = text_splitter.split_documents(documents)
+            redis_vs = Redis.from_documents(
+                documents=docs,
+                embedding=self.embedding,
+                redis_url=self.redis_server_url,
+                index_name=self.redis_index_name,
+            )
+        return redis_vs
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/redis/redis_chat.py

@@ -0,0 +1,43 @@
+from urllib import parse
+
+from langchain_community.chat_message_histories.redis import RedisChatMessageHistory
+
+from lfx.base.memory.model import LCChatMemoryComponent
+from lfx.field_typing.constants import Memory
+from lfx.inputs.inputs import IntInput, MessageTextInput, SecretStrInput, StrInput
+
+
+class RedisIndexChatMemory(LCChatMemoryComponent):
+    display_name = "Redis Chat Memory"
+    description = "Retrieves and store chat messages from Redis."
+    name = "RedisChatMemory"
+    icon = "Redis"
+
+    inputs = [
+        StrInput(
+            name="host", display_name="hostname", required=True, value="localhost", info="IP address or hostname."
+        ),
+        IntInput(name="port", display_name="port", required=True, value=6379, info="Redis Port Number."),
+        StrInput(name="database", display_name="database", required=True, value="0", info="Redis database."),
+        MessageTextInput(
+            name="username", display_name="Username", value="", info="The Redis user name.", advanced=True
+        ),
+        SecretStrInput(
+            name="password", display_name="Password", value="", info="The password for username.", advanced=True
+        ),
+        StrInput(name="key_prefix", display_name="Key prefix", info="Key prefix.", advanced=True),
+        MessageTextInput(
+            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
+        ),
+    ]
+
+    def build_message_history(self) -> Memory:
+        kwargs = {}
+        password: str | None = self.password
+        if self.key_prefix:
+            kwargs["key_prefix"] = self.key_prefix
+        if password:
+            password = parse.quote_plus(password)
+
+        url = f"redis://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+        return RedisChatMessageHistory(session_id=self.session_id, url=url, **kwargs)

lfx/components/sambanova/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.sambanova.sambanova import SambaNovaComponent
+
+_dynamic_imports = {
+    "SambaNovaComponent": "sambanova",
+}
+
+__all__ = ["SambaNovaComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import sambanova components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/sambanova/sambanova.py

@@ -0,0 +1,84 @@
+from langchain_sambanova import ChatSambaNovaCloud
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.sambanova_constants import SAMBANOVA_MODEL_NAMES
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+
+
+class SambaNovaComponent(LCModelComponent):
+    display_name = "SambaNova"
+    description = "Generate text using Sambanova LLMs."
+    documentation = "https://cloud.sambanova.ai/"
+    icon = "SambaNova"
+    name = "SambaNovaModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        StrInput(
+            name="base_url",
+            display_name="SambaNova Cloud Base Url",
+            advanced=True,
+            info="The base URL of the Sambanova Cloud API. "
+            "Defaults to https://api.sambanova.ai/v1/chat/completions. "
+            "You can change this to use other urls like Sambastudio",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=SAMBANOVA_MODEL_NAMES,
+            value=SAMBANOVA_MODEL_NAMES[0],
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Sambanova API Key",
+            info="The Sambanova API Key to use for the Sambanova model.",
+            advanced=False,
+            value="SAMBANOVA_API_KEY",
+            required=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            value=2048,
+            info="The maximum number of tokens to generate.",
+        ),
+        SliderInput(
+            name="top_p",
+            display_name="top_p",
+            advanced=True,
+            value=1.0,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            info="Model top_p",
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        sambanova_url = self.base_url
+        sambanova_api_key = self.api_key
+        model_name = self.model_name
+        max_tokens = self.max_tokens
+        top_p = self.top_p
+        temperature = self.temperature
+
+        api_key = SecretStr(sambanova_api_key).get_secret_value() if sambanova_api_key else None
+
+        return ChatSambaNovaCloud(
+            model=model_name,
+            max_tokens=max_tokens or 1024,
+            temperature=temperature or 0.07,
+            top_p=top_p,
+            sambanova_url=sambanova_url,
+            sambanova_api_key=api_key,
+        )

lfx/components/scrapegraph/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .scrapegraph_markdownify_api import ScrapeGraphMarkdownifyApi
+    from .scrapegraph_search_api import ScrapeGraphSearchApi
+    from .scrapegraph_smart_scraper_api import ScrapeGraphSmartScraperApi
+
+_dynamic_imports = {
+    "ScrapeGraphMarkdownifyApi": "scrapegraph_markdownify_api",
+    "ScrapeGraphSearchApi": "scrapegraph_search_api",
+    "ScrapeGraphSmartScraperApi": "scrapegraph_smart_scraper_api",
+}
+
+__all__ = [
+    "ScrapeGraphMarkdownifyApi",
+    "ScrapeGraphSearchApi",
+    "ScrapeGraphSmartScraperApi",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import scrapegraph components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/scrapegraph/scrapegraph_markdownify_api.py

@@ -0,0 +1,64 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import (
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from lfx.schema.data import Data
+
+
+class ScrapeGraphMarkdownifyApi(Component):
+    display_name: str = "ScrapeGraph Markdownify API"
+    description: str = "Given a URL, it will return the markdownified content of the website."
+    name = "ScrapeGraphMarkdownifyApi"
+
+    output_types: list[str] = ["Document"]
+    documentation: str = "https://docs.scrapegraphai.com/services/markdownify"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="ScrapeGraph API Key",
+            required=True,
+            password=True,
+            info="The API key to use ScrapeGraph API.",
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            tool_mode=True,
+            info="The URL to markdownify.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="scrape"),
+    ]
+
+    def scrape(self) -> list[Data]:
+        try:
+            from scrapegraph_py import Client
+            from scrapegraph_py.logger import sgai_logger
+        except ImportError as e:
+            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
+            raise ImportError(msg) from e
+
+        # Set logging level
+        sgai_logger.set_logging(level="INFO")
+
+        # Initialize the client with API key
+        sgai_client = Client(api_key=self.api_key)
+
+        try:
+            # Markdownify request
+            response = sgai_client.markdownify(
+                website_url=self.url,
+            )
+
+            # Close the client
+            sgai_client.close()
+
+            return Data(data=response)
+        except Exception:
+            sgai_client.close()
+            raise

lfx/components/scrapegraph/scrapegraph_search_api.py

@@ -0,0 +1,64 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import (
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from lfx.schema.data import Data
+
+
+class ScrapeGraphSearchApi(Component):
+    display_name: str = "ScrapeGraph Search API"
+    description: str = "Given a search prompt, it will return search results using ScrapeGraph's search functionality."
+    name = "ScrapeGraphSearchApi"
+
+    documentation: str = "https://docs.scrapegraphai.com/services/searchscraper"
+    icon = "ScrapeGraph"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="ScrapeGraph API Key",
+            required=True,
+            password=True,
+            info="The API key to use ScrapeGraph API.",
+        ),
+        MessageTextInput(
+            name="user_prompt",
+            display_name="Search Prompt",
+            tool_mode=True,
+            info="The search prompt to use.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="search"),
+    ]
+
+    def search(self) -> list[Data]:
+        try:
+            from scrapegraph_py import Client
+            from scrapegraph_py.logger import sgai_logger
+        except ImportError as e:
+            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
+            raise ImportError(msg) from e
+
+        # Set logging level
+        sgai_logger.set_logging(level="INFO")
+
+        # Initialize the client with API key
+        sgai_client = Client(api_key=self.api_key)
+
+        try:
+            # SearchScraper request
+            response = sgai_client.searchscraper(
+                user_prompt=self.user_prompt,
+            )
+
+            # Close the client
+            sgai_client.close()
+
+            return Data(data=response)
+        except Exception:
+            sgai_client.close()
+            raise

lfx/components/scrapegraph/scrapegraph_smart_scraper_api.py

@@ -0,0 +1,71 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import (
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from lfx.schema.data import Data
+
+
+class ScrapeGraphSmartScraperApi(Component):
+    display_name: str = "ScrapeGraph Smart Scraper API"
+    description: str = "Given a URL, it will return the structured data of the website."
+    name = "ScrapeGraphSmartScraperApi"
+
+    output_types: list[str] = ["Document"]
+    documentation: str = "https://docs.scrapegraphai.com/services/smartscraper"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="ScrapeGraph API Key",
+            required=True,
+            password=True,
+            info="The API key to use ScrapeGraph API.",
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            tool_mode=True,
+            info="The URL to scrape.",
+        ),
+        MessageTextInput(
+            name="prompt",
+            display_name="Prompt",
+            tool_mode=True,
+            info="The prompt to use for the smart scraper.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="scrape"),
+    ]
+
+    def scrape(self) -> list[Data]:
+        try:
+            from scrapegraph_py import Client
+            from scrapegraph_py.logger import sgai_logger
+        except ImportError as e:
+            msg = "Could not import scrapegraph-py package. Please install it with `pip install scrapegraph-py`."
+            raise ImportError(msg) from e
+
+        # Set logging level
+        sgai_logger.set_logging(level="INFO")
+
+        # Initialize the client with API key
+        sgai_client = Client(api_key=self.api_key)
+
+        try:
+            # SmartScraper request
+            response = sgai_client.smartscraper(
+                website_url=self.url,
+                user_prompt=self.prompt,
+            )
+
+            # Close the client
+            sgai_client.close()
+
+            return Data(data=response)
+        except Exception:
+            sgai_client.close()
+            raise

lfx/components/searchapi/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.searchapi.search import SearchComponent
+
+_dynamic_imports = {
+    "SearchComponent": "search",
+}
+
+__all__ = [
+    "SearchComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import searchapi components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/searchapi/search.py

@@ -0,0 +1,79 @@
+from typing import Any
+
+from langchain_community.utilities.searchapi import SearchApiAPIWrapper
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DictInput, DropdownInput, IntInput, MultilineInput, SecretStrInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class SearchComponent(Component):
+    display_name: str = "SearchApi"
+    description: str = "Calls the SearchApi API with result limiting. Supports Google, Bing and DuckDuckGo."
+    documentation: str = "https://www.searchapi.io/docs/google"
+    icon = "SearchAPI"
+
+    inputs = [
+        DropdownInput(name="engine", display_name="Engine", value="google", options=["google", "bing", "duckduckgo"]),
+        SecretStrInput(name="api_key", display_name="SearchAPI API Key", required=True),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        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),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def _build_wrapper(self):
+        return SearchApiAPIWrapper(engine=self.engine, searchapi_api_key=self.api_key)
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def fetch_content(self) -> list[Data]:
+        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[Data]:
+            params = params or {}
+            full_results = wrapper.results(query=query, **params)
+            organic_results = full_results.get("organic_results", [])[:max_results]
+
+            return [
+                Data(
+                    text=result.get("snippet", ""),
+                    data={
+                        "title": result.get("title", "")[:max_snippet_length],
+                        "link": result.get("link", ""),
+                        "snippet": result.get("snippet", "")[:max_snippet_length],
+                    },
+                )
+                for result in organic_results
+            ]
+
+        results = search_func(
+            self.input_value,
+            self.search_params or {},
+            self.max_results,
+            self.max_snippet_length,
+        )
+        self.status = results
+        return results
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        """Convert the search results to a DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame containing the search results.
+        """
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/serpapi/__init__.py

@@ -0,0 +1,3 @@
+from .serp import SerpComponent
+
+__all__ = ["SerpComponent"]