lfx-nightly 0.1.12.dev27__py3-none-any.whl → 0.1.12.dev28__py3-none-any.whl

lfx/components/data/web_search.py

@@ -1,43 +1,133 @@
+"""Unified Web Search Component.
+
+This component consolidates Web Search, News Search, and RSS Reader into a single
+component with tabs for different search modes.
+"""
+
 import re
-from urllib.parse import parse_qs, unquote, urlparse
+from typing import Any
+from urllib.parse import parse_qs, quote_plus, unquote, urlparse
 
 import pandas as pd
 import requests
 from bs4 import BeautifulSoup
 
 from lfx.custom import Component
-from lfx.io import IntInput, MessageTextInput, Output
+from lfx.io import IntInput, MessageTextInput, Output, TabInput
 from lfx.schema import DataFrame
 from lfx.utils.request_utils import get_user_agent
 
 
 class WebSearchComponent(Component):
     display_name = "Web Search"
-    description = "Performs a basic DuckDuckGo search (HTML scraping). May be subject to rate limits."
+    description = "Search the web, news, or RSS feeds."
     documentation: str = "https://docs.langflow.org/components-data#web-search"
     icon = "search"
-    name = "WebSearchNoAPI"
+    name = "UnifiedWebSearch"
 
     inputs = [
+        TabInput(
+            name="search_mode",
+            display_name="Search Mode",
+            options=["Web", "News", "RSS"],
+            info="Choose search mode: Web (DuckDuckGo), News (Google News), or RSS (Feed Reader)",
+            value="Web",
+            real_time_refresh=True,
+            tool_mode=True,
+        ),
         MessageTextInput(
             name="query",
             display_name="Search Query",
-            info="Keywords to search for.",
+            info="Search keywords for news articles.",
             tool_mode=True,
             required=True,
         ),
+        MessageTextInput(
+            name="hl",
+            display_name="Language (hl)",
+            info="Language code, e.g. en-US, fr, de. Default: en-US.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="gl",
+            display_name="Country (gl)",
+            info="Country code, e.g. US, FR, DE. Default: US.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="ceid",
+            display_name="Country:Language (ceid)",
+            info="e.g. US:en, FR:fr. Default: US:en.",
+            tool_mode=False,
+            value="US:en",
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="topic",
+            display_name="Topic",
+            info="One of: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SCIENCE, SPORTS, HEALTH.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="location",
+            display_name="Location (Geo)",
+            info="City, state, or country for location-based news. Leave blank for keyword search.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
         IntInput(
             name="timeout",
             display_name="Timeout",
-            info="Timeout for the web search request.",
+            info="Timeout for the request in seconds.",
             value=5,
+            required=False,
             advanced=True,
         ),
     ]
 
-    outputs = [Output(name="results", display_name="Search Results", method="perform_search")]
+    outputs = [Output(name="results", display_name="Results", method="perform_search")]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        """Update input visibility based on search mode."""
+        if field_name == "search_mode":
+            # Show/hide inputs based on search mode
+            is_news = field_value == "News"
+            is_rss = field_value == "RSS"
+
+            # Update query field info based on mode
+            if is_rss:
+                build_config["query"]["info"] = "RSS feed URL to parse"
+                build_config["query"]["display_name"] = "RSS Feed URL"
+            elif is_news:
+                build_config["query"]["info"] = "Search keywords for news articles."
+                build_config["query"]["display_name"] = "Search Query"
+            else:  # Web
+                build_config["query"]["info"] = "Keywords to search for"
+                build_config["query"]["display_name"] = "Search Query"
+
+            # Keep news-specific fields as advanced (matching original News Search component)
+            # They remain advanced=True in all modes, just like in the original component
+
+        return build_config
 
     def validate_url(self, string: str) -> bool:
+        """Validate URL format."""
         url_regex = re.compile(
             r"^(https?:\/\/)?" r"(www\.)?" r"([a-zA-Z0-9.-]+)" r"(\.[a-zA-Z]{2,})?" r"(:\d+)?" r"(\/[^\s]*)?$",
             re.IGNORECASE,
@@ -45,6 +135,7 @@ class WebSearchComponent(Component):
         return bool(url_regex.match(string))
 
     def ensure_url(self, url: str) -> str:
+        """Ensure URL has proper protocol."""
         if not url.startswith(("http://", "https://")):
             url = "https://" + url
         if not self.validate_url(url):
@@ -54,14 +145,19 @@ class WebSearchComponent(Component):
 
     def _sanitize_query(self, query: str) -> str:
         """Sanitize search query."""
-        # Remove potentially dangerous characters
         return re.sub(r'[<>"\']', "", query.strip())
 
-    def perform_search(self) -> DataFrame:
+    def clean_html(self, html_string: str) -> str:
+        """Remove HTML tags from text."""
+        return BeautifulSoup(html_string, "html.parser").get_text(separator=" ", strip=True)
+
+    def perform_web_search(self) -> DataFrame:
+        """Perform DuckDuckGo web search."""
         query = self._sanitize_query(self.query)
         if not query:
             msg = "Empty search query"
             raise ValueError(msg)
+
         headers = {"User-Agent": get_user_agent()}
         params = {"q": query, "kl": "us-en"}
         url = "https://html.duckduckgo.com/html/"
@@ -78,6 +174,7 @@ class WebSearchComponent(Component):
             return DataFrame(
                 pd.DataFrame([{"title": "Error", "link": "", "snippet": "No results found", "content": ""}])
             )
+
         soup = BeautifulSoup(response.text, "html.parser")
         results = []
 
@@ -108,5 +205,122 @@ class WebSearchComponent(Component):
                     }
                 )
 
-        df_results = pd.DataFrame(results)
-        return DataFrame(df_results)
+        return DataFrame(pd.DataFrame(results))
+
+    def perform_news_search(self) -> DataFrame:
+        """Perform Google News search."""
+        query = getattr(self, "query", "")
+        hl = getattr(self, "hl", "en-US") or "en-US"
+        gl = getattr(self, "gl", "US") or "US"
+        topic = getattr(self, "topic", None)
+        location = getattr(self, "location", None)
+
+        ceid = f"{gl}:{hl.split('-')[0]}"
+
+        # Build RSS URL based on parameters
+        if topic:
+            # Topic-based feed
+            base_url = f"https://news.google.com/rss/headlines/section/topic/{quote_plus(topic.upper())}"
+            params = f"?hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = base_url + params
+        elif location:
+            # Location-based feed
+            base_url = f"https://news.google.com/rss/headlines/section/geo/{quote_plus(location)}"
+            params = f"?hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = base_url + params
+        elif query:
+            # Keyword search feed
+            base_url = "https://news.google.com/rss/search?q="
+            query_encoded = quote_plus(query)
+            params = f"&hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = f"{base_url}{query_encoded}{params}"
+        else:
+            self.status = "No search query, topic, or location provided."
+            return DataFrame(
+                pd.DataFrame(
+                    [{"title": "Error", "link": "", "published": "", "summary": "No search parameters provided"}]
+                )
+            )
+
+        try:
+            response = requests.get(rss_url, timeout=self.timeout)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.content, "xml")
+            items = soup.find_all("item")
+        except requests.RequestException as e:
+            self.status = f"Failed to fetch news: {e}"
+            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": str(e)}]))
+
+        if not items:
+            self.status = "No news articles found."
+            return DataFrame(pd.DataFrame([{"title": "No articles found", "link": "", "published": "", "summary": ""}]))
+
+        articles = []
+        for item in items:
+            try:
+                title = self.clean_html(item.title.text if item.title else "")
+                link = item.link.text if item.link else ""
+                published = item.pubDate.text if item.pubDate else ""
+                summary = self.clean_html(item.description.text if item.description else "")
+                articles.append({"title": title, "link": link, "published": published, "summary": summary})
+            except (AttributeError, ValueError, TypeError) as e:
+                self.log(f"Error parsing article: {e!s}")
+                continue
+
+        return DataFrame(pd.DataFrame(articles))
+
+    def perform_rss_read(self) -> DataFrame:
+        """Read RSS feed."""
+        rss_url = getattr(self, "query", "")
+        if not rss_url:
+            return DataFrame(
+                pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": "No RSS URL provided"}])
+            )
+
+        try:
+            response = requests.get(rss_url, timeout=self.timeout)
+            response.raise_for_status()
+            if not response.content.strip():
+                msg = "Empty response received"
+                raise ValueError(msg)
+
+            # Validate XML
+            try:
+                BeautifulSoup(response.content, "xml")
+            except Exception as e:
+                msg = f"Invalid XML response: {e}"
+                raise ValueError(msg) from e
+
+            soup = BeautifulSoup(response.content, "xml")
+            items = soup.find_all("item")
+        except (requests.RequestException, ValueError) as e:
+            self.status = f"Failed to fetch RSS: {e}"
+            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": str(e)}]))
+
+        articles = [
+            {
+                "title": item.title.text if item.title else "",
+                "link": item.link.text if item.link else "",
+                "published": item.pubDate.text if item.pubDate else "",
+                "summary": item.description.text if item.description else "",
+            }
+            for item in items
+        ]
+
+        # Ensure DataFrame has correct columns even if empty
+        df_articles = pd.DataFrame(articles, columns=["title", "link", "published", "summary"])
+        self.log(f"Fetched {len(df_articles)} articles.")
+        return DataFrame(df_articles)
+
+    def perform_search(self) -> DataFrame:
+        """Main search method that routes to appropriate search function based on mode."""
+        search_mode = getattr(self, "search_mode", "Web")
+
+        if search_mode == "Web":
+            return self.perform_web_search()
+        if search_mode == "News":
+            return self.perform_news_search()
+        if search_mode == "RSS":
+            return self.perform_rss_read()
+        # Fallback to web search
+        return self.perform_web_search()

lfx/components/docling/docling_remote.py

@@ -12,6 +12,7 @@ from lfx.base.data import BaseFileComponent
 from lfx.inputs import IntInput, NestedDictInput, StrInput
 from lfx.inputs.inputs import FloatInput
 from lfx.schema import Data
+from lfx.utils.util import transform_localhost_url
 
 
 class DoclingRemoteComponent(BaseFileComponent):
@@ -103,7 +104,9 @@ class DoclingRemoteComponent(BaseFileComponent):
     ]
 
     def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
-        base_url = f"{self.api_url}/v1"
+        # Transform localhost URLs to container-accessible hosts when running in a container
+        transformed_url = transform_localhost_url(self.api_url)
+        base_url = f"{transformed_url}/v1"
 
         def _convert_document(client: httpx.Client, file_path: Path, options: dict[str, Any]) -> Data | None:
             encoded_doc = base64.b64encode(file_path.read_bytes()).decode()

lfx/components/input_output/chat.py

@@ -75,12 +75,19 @@ class ChatInput(ChatComponent):
     ]
 
     async def message_response(self) -> Message:
+        # Ensure files is a list and filter out empty/None values
+        files = self.files if self.files else []
+        if files and not isinstance(files, list):
+            files = [files]
+        # Filter out None/empty values
+        files = [f for f in files if f is not None and f != ""]
+
         message = await Message.create(
             text=self.input_value,
             sender=self.sender,
             sender_name=self.sender_name,
             session_id=self.session_id,
-            files=self.files,
+            files=files,
         )
         if self.session_id and isinstance(message, Message) and self.should_store_message:
             stored_message = await self.send_message(

lfx/components/nvidia/nvidia.py

@@ -1,8 +1,5 @@
 from typing import Any
 
-from requests.exceptions import ConnectionError  # noqa: A004
-from urllib3.exceptions import MaxRetryError, NameResolutionError
-
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
@@ -27,7 +24,7 @@ class NVIDIAModelComponent(LCModelComponent):
     except ImportError as e:
         msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
         raise ImportError(msg) from e
-    except (ConnectionError, MaxRetryError, NameResolutionError):
+    except Exception:  # noqa: BLE001
         logger.warning(
             "Failed to connect to NVIDIA API. Model list may be unavailable."
             " Please check your internet connection and API credentials."

lfx/components/processing/__init__.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from lfx.components.processing.data_operations import DataOperationsComponent
     from lfx.components.processing.data_to_dataframe import DataToDataFrameComponent
     from lfx.components.processing.dataframe_operations import DataFrameOperationsComponent
+    from lfx.components.processing.dataframe_to_toolset import DataFrameToToolsetComponent
     from lfx.components.processing.extract_key import ExtractDataKeyComponent
     from lfx.components.processing.filter_data import FilterDataComponent
     from lfx.components.processing.filter_data_values import DataFilterComponent
@@ -30,7 +31,6 @@ if TYPE_CHECKING:
     from lfx.components.processing.prompt import PromptComponent
     from lfx.components.processing.python_repl_core import PythonREPLComponent
     from lfx.components.processing.regex import RegexExtractorComponent
-    from lfx.components.processing.save_file import SaveToFileComponent
     from lfx.components.processing.select_data import SelectDataComponent
     from lfx.components.processing.split_text import SplitTextComponent
     from lfx.components.processing.structured_output import StructuredOutputComponent
@@ -45,6 +45,7 @@ _dynamic_imports = {
     "DataOperationsComponent": "data_operations",
     "DataToDataFrameComponent": "data_to_dataframe",
     "DataFrameOperationsComponent": "dataframe_operations",
+    "DataFrameToToolsetComponent": "dataframe_to_toolset",
     "ExtractDataKeyComponent": "extract_key",
     "FilterDataComponent": "filter_data",
     "DataFilterComponent": "filter_data_values",
@@ -60,7 +61,6 @@ _dynamic_imports = {
     "PromptComponent": "prompt",
     "PythonREPLComponent": "python_repl_core",
     "RegexExtractorComponent": "regex",
-    "SaveToFileComponent": "save_file",
     "SelectDataComponent": "select_data",
     "SplitTextComponent": "split_text",
     "StructuredOutputComponent": "structured_output",
@@ -74,6 +74,7 @@ __all__ = [
     "CreateDataComponent",
     "DataFilterComponent",
     "DataFrameOperationsComponent",
+    "DataFrameToToolsetComponent",
     "DataOperationsComponent",
     "DataToDataFrameComponent",
     "ExtractDataKeyComponent",
@@ -90,7 +91,6 @@ __all__ = [
     "PromptComponent",
     "PythonREPLComponent",
     "RegexExtractorComponent",
-    "SaveToFileComponent",
     "SelectDataComponent",
     "SplitTextComponent",
     "StructuredOutputComponent",

lfx/components/processing/dataframe_to_toolset.py

@@ -0,0 +1,259 @@
+"""DataFrame to Toolset Component.
+
+This component converts each row of a DataFrame into a callable tool/action within a toolset.
+Each row becomes a tool where the action name comes from one column and the content/response
+comes from another column.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, create_model
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing.constants import Tool
+from lfx.io import HandleInput, Output, StrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+
+if TYPE_CHECKING:
+    from lfx.field_typing.constants import Tool
+
+
+class DataFrameToToolsetComponent(LCToolComponent):
+    """Component that converts DataFrame rows into a toolset with multiple callable actions."""
+
+    display_name = "DataFrame to Toolset"
+    description = "Convert each row of a DataFrame into a callable tool/action in a toolset."
+    icon = "wrench"
+    name = "DataFrameToToolset"
+
+    inputs = [
+        HandleInput(
+            name="dataframe",
+            display_name="DataFrame",
+            input_types=["DataFrame"],
+            info="DataFrame where each row will become a tool/action",
+            required=True,
+        ),
+        StrInput(
+            name="tool_name_column",
+            display_name="Tool Name Column",
+            info="Column with tool names",
+            required=True,
+        ),
+        StrInput(
+            name="tool_output_column",
+            display_name="Tool Output Column",
+            info="Column with tool outputs/responses",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Tools", name="tools", method="build_tools"),
+        Output(display_name="Message", name="message", method="get_message"),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._tools_cache: list[Tool] = []
+        self._action_data: dict[str, dict[str, str]] = {}
+
+    def _sanitize_tool_name(self, name: str) -> str:
+        """Sanitize tool name to match required format '^[a-zA-Z0-9_-]+$'."""
+        # Replace any non-alphanumeric characters (except _ and -) with underscores
+        sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", str(name))
+        # Ensure it starts with a letter or underscore
+        if sanitized and not sanitized[0].isalpha() and sanitized[0] != "_":
+            sanitized = f"tool_{sanitized}"
+        return sanitized or "unnamed_tool"
+
+    def _prepare_action_data(self) -> None:
+        """Prepare action data from DataFrame."""
+        # Check if dataframe exists and is valid
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            self._action_data = {}
+            return
+
+        if not isinstance(self.dataframe, DataFrame):
+            self._action_data = {}
+            return
+
+        if not hasattr(self.dataframe, "columns"):
+            self._action_data = {}
+            return
+
+        # Check if column names are provided
+        if not self.tool_name_column or not self.tool_output_column:
+            self._action_data = {}
+            return
+
+        if self.tool_name_column not in self.dataframe.columns:
+            msg = (
+                f"Tool name column '{self.tool_name_column}' not found in DataFrame columns: "
+                f"{list(self.dataframe.columns)}"
+            )
+            raise ValueError(msg)
+
+        if self.tool_output_column not in self.dataframe.columns:
+            msg = (
+                f"Tool output column '{self.tool_output_column}' not found in DataFrame columns: "
+                f"{list(self.dataframe.columns)}"
+            )
+            raise ValueError(msg)
+
+        # Clear previous data
+        self._action_data = {}
+
+        # Process each row to create action mappings
+        for _, row in self.dataframe.iterrows():
+            action_name = str(row[self.tool_name_column]).strip()
+            content = str(row[self.tool_output_column]).strip()
+
+            if action_name and content:
+                sanitized_name = self._sanitize_tool_name(action_name)
+                self._action_data[sanitized_name] = {
+                    "original_name": action_name,
+                    "content": content,
+                    "sanitized_name": sanitized_name,
+                }
+
+    def _create_action_function(self, action_name: str, content: str):
+        """Create a function for a specific action that returns the content."""
+
+        def action_function(**kwargs) -> str:
+            # You could extend this to use kwargs to modify the content
+            # For now, just return the stored content
+            self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
+            return content
+
+        action_function.__name__ = f"execute_{action_name}"
+        action_function.__doc__ = f"Execute {action_name} action and return the associated content."
+        return action_function
+
+    def build_tools(self) -> list[Tool]:
+        """Build the toolset from DataFrame data."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return []
+
+        self._prepare_action_data()
+
+        if not self._action_data:
+            return []
+
+        tools_description_preview_length = 100
+        tools_description_content_length = 200
+
+        tools = []
+
+        for sanitized_name, action_info in self._action_data.items():
+            original_name = action_info["original_name"]
+            content = action_info["content"]
+
+            # Create a simple schema for this tool (no parameters needed)
+            # But we could extend this to accept parameters if needed
+            tool_schema = create_model(
+                f"{sanitized_name}Schema",
+                __base__=BaseModel,
+                # Add parameters here if you want the tools to accept inputs
+                # For now, keeping it simple with no parameters
+            )
+
+            # Create the tool function
+            tool_function = self._create_action_function(sanitized_name, content)
+
+            # Create the StructuredTool
+            tool = StructuredTool(
+                name=sanitized_name,
+                description=(
+                    f"Execute {original_name} action. Returns: "
+                    f"{content[:tools_description_preview_length]}"
+                    f"{'...' if len(content) > tools_description_preview_length else ''}"
+                ),
+                func=tool_function,
+                args_schema=tool_schema,
+                handle_tool_error=True,
+                tags=[sanitized_name],
+                metadata={
+                    "display_name": original_name,
+                    "display_description": f"Action: {original_name}",
+                    "original_name": original_name,
+                    "content_preview": content[:tools_description_content_length],
+                },
+            )
+
+            tools.append(tool)
+
+        self._tools_cache = tools
+        return tools
+
+    def build_tool(self) -> Tool:
+        """Build a single tool (for compatibility with LCToolComponent)."""
+        tools = self.build_tools()
+        if not tools:
+            # Return a placeholder tool when no data is available
+            def placeholder_function(**kwargs) -> str:
+                self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
+                return "No tools available. Please connect a DataFrame with appropriate columns."
+
+            return StructuredTool(
+                name="placeholder_tool",
+                description="Placeholder tool - waiting for DataFrame input",
+                func=placeholder_function,
+                args_schema=create_model("PlaceholderSchema", __base__=BaseModel),
+            )
+
+        # Return the first tool, or create a composite tool
+        return tools[0]
+
+    def get_message(self) -> Message:
+        """Get a message describing the created toolset."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return Message(text="Waiting for DataFrame input...")
+
+        self._prepare_action_data()
+
+        if not self._action_data:
+            return Message(text="No tools were created. Please check your DataFrame and column selections.")
+
+        tool_count = len(self._action_data)
+        tool_names = [info["original_name"] for info in self._action_data.values()]
+
+        message_text = f"Created toolset with {tool_count} tools:\n"
+        for i, name in enumerate(tool_names, 1):
+            message_text += f"{i}. {name}\n"
+
+        return Message(text=message_text)
+
+    def run_model(self) -> list[Data]:
+        """Run the model and return tool information as Data objects."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return [Data(data={"status": "Waiting for DataFrame input"})]
+
+        tools = self.build_tools()
+
+        if not tools:
+            return [Data(data={"status": "No tools created. Check DataFrame and column selections."})]
+
+        results = []
+        for tool in tools:
+            tool_data = {
+                "tool_name": tool.name,
+                "display_name": tool.metadata.get("display_name", tool.name)
+                if hasattr(tool, "metadata")
+                else tool.name,
+                "description": tool.description,
+                "original_name": tool.metadata.get("original_name", "") if hasattr(tool, "metadata") else "",
+                "content_preview": tool.metadata.get("content_preview", "") if hasattr(tool, "metadata") else "",
+            }
+            results.append(Data(data=tool_data))
+
+        return results

lfx/components/processing/lambda_filter.py

@@ -14,11 +14,11 @@ if TYPE_CHECKING:
 
 
 class LambdaFilterComponent(Component):
-    display_name = "Smart Function"
+    display_name = "Smart Transform"
     description = "Uses an LLM to generate a function for filtering or transforming structured data."
-    documentation: str = "https://docs.langflow.org/components-processing#smart-function"
+    documentation: str = "https://docs.langflow.org/components-processing#smart-transform"
     icon = "square-function"
-    name = "Smart Function"
+    name = "Smart Transform"
 
     inputs = [
         DataInput(