lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/langchain_utilities/csv_agent.py

@@ -1,6 +1,9 @@
-from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+import contextlib
+import tempfile
+from pathlib import Path
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.field_typing import AgentExecutor
 from lfx.inputs.inputs import (
     DictInput,
@@ -10,7 +13,9 @@ from lfx.inputs.inputs import (
     MessageTextInput,
 )
 from lfx.schema.message import Message
+from lfx.services.deps import get_settings_service
 from lfx.template.field.base import Output
+from lfx.utils.async_helpers import run_until_complete
 
 
 class CSVAgentComponent(LCAgentComponent):
@@ -70,32 +75,60 @@ class CSVAgentComponent(LCAgentComponent):
         return self.path
 
     def build_agent_response(self) -> Message:
-        agent_kwargs = {
-            "verbose": self.verbose,
-            "allow_dangerous_code": True,
-        }
+        """Build and execute the CSV agent, returning the response."""
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
 
-        agent_csv = create_csv_agent(
-            llm=self.llm,
-            path=self._path(),
-            agent_type=self.agent_type,
-            handle_parsing_errors=self.handle_parsing_errors,
-            pandas_kwargs=self.pandas_kwargs,
-            **agent_kwargs,
-        )
+        try:
+            agent_kwargs = {
+                "verbose": self.verbose,
+                "allow_dangerous_code": True,
+            }
+
+            # Get local path (downloads from S3 if needed)
+            local_path = self._get_local_path()
 
-        result = agent_csv.invoke({"input": self.input_value})
-        return Message(text=str(result["output"]))
+            agent_csv = create_csv_agent(
+                llm=self.llm,
+                path=local_path,
+                agent_type=self.agent_type,
+                handle_parsing_errors=self.handle_parsing_errors,
+                pandas_kwargs=self.pandas_kwargs,
+                **agent_kwargs,
+            )
+
+            result = agent_csv.invoke({"input": self.input_value})
+            return Message(text=str(result["output"]))
+
+        finally:
+            # Clean up temp file if created
+            self._cleanup_temp_file()
 
     def build_agent(self) -> AgentExecutor:
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
+
         agent_kwargs = {
             "verbose": self.verbose,
             "allow_dangerous_code": True,
         }
 
+        # Get local path (downloads from S3 if needed)
+        local_path = self._get_local_path()
+
         agent_csv = create_csv_agent(
             llm=self.llm,
-            path=self._path(),
+            path=local_path,
             agent_type=self.agent_type,
             handle_parsing_errors=self.handle_parsing_errors,
             pandas_kwargs=self.pandas_kwargs,
@@ -104,4 +137,39 @@ class CSVAgentComponent(LCAgentComponent):
 
         self.status = Message(text=str(agent_csv))
 
+        # Note: Temp file will be cleaned up when the component is destroyed or
+        # when build_agent_response is called
         return agent_csv
+
+    def _get_local_path(self) -> str:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            str: Local file path that can be used by LangChain
+        """
+        file_path = self._path()
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            csv_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with .csv extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".csv"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(csv_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return temp_path
+
+        # Local storage - return path as-is
+        return file_path
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors

lfx/components/langchain_utilities/json_agent.py

@@ -1,13 +1,15 @@
+import contextlib
+import tempfile
 from pathlib import Path
 
 import yaml
 from langchain.agents import AgentExecutor
-from langchain_community.agent_toolkits import create_json_agent
-from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
-from langchain_community.tools.json.tool import JsonSpec
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.inputs.inputs import FileInput, HandleInput
+from lfx.services.deps import get_settings_service
+from lfx.utils.async_helpers import run_until_complete
 
 
 class JsonAgentComponent(LCAgentComponent):
@@ -32,14 +34,67 @@ class JsonAgentComponent(LCAgentComponent):
         ),
     ]
 
+    def _get_local_path(self) -> Path:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            Path: Local file path that can be used by LangChain
+        """
+        file_path = self.path
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            file_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with appropriate extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".json"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(file_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return Path(temp_path)
+
+        # Local storage - return as Path
+        return Path(file_path)
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors
+
     def build_agent(self) -> AgentExecutor:
-        path = Path(self.path)
-        if path.suffix in {"yaml", "yml"}:
-            with path.open(encoding="utf-8") as file:
-                yaml_dict = yaml.safe_load(file)
-            spec = JsonSpec(dict_=yaml_dict)
-        else:
-            spec = JsonSpec.from_file(path)
-        toolkit = JsonToolkit(spec=spec)
+        """Build the JSON agent executor."""
+        try:
+            from langchain_community.agent_toolkits import create_json_agent
+            from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
+            from langchain_community.tools.json.tool import JsonSpec
+        except ImportError as e:
+            msg = "langchain-community is not installed. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            # Get local path (downloads from S3 if needed)
+            path = self._get_local_path()
 
-        return create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+            if path.suffix in {".yaml", ".yml"}:
+                with path.open(encoding="utf-8") as file:
+                    yaml_dict = yaml.safe_load(file)
+                spec = JsonSpec(dict_=yaml_dict)
+            else:
+                spec = JsonSpec.from_file(str(path))
+            toolkit = JsonToolkit(spec=spec)
+
+            agent = create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+        except Exception:
+            # Make sure to clean up temp file on error
+            self._cleanup_temp_file()
+            raise
+        else:
+            # Clean up temp file after agent is created
+            self._cleanup_temp_file()
+            return agent

lfx/components/langchain_utilities/language_recursive.py

@@ -9,7 +9,7 @@ from lfx.inputs.inputs import DataInput, DropdownInput, IntInput
 class LanguageRecursiveTextSplitterComponent(LCTextSplitterComponent):
     display_name: str = "Language Recursive Text Splitter"
     description: str = "Split text into chunks of a specified length based on language."
-    documentation: str = "https://docs.langflow.org/components/text-splitters#languagerecursivetextsplitter"
+    documentation: str = "https://docs.langflow.org/bundles-langchain"
     name = "LanguageRecursiveTextSplitter"
     icon = "LangChain"
 

lfx/components/llm_operations/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.llm_operations.batch_run import BatchRunComponent
+    from lfx.components.llm_operations.lambda_filter import SmartTransformComponent
+    from lfx.components.llm_operations.llm_conditional_router import SmartRouterComponent
+    from lfx.components.llm_operations.llm_selector import LLMSelectorComponent
+    from lfx.components.llm_operations.structured_output import StructuredOutputComponent
+
+_dynamic_imports = {
+    "BatchRunComponent": "batch_run",
+    "SmartTransformComponent": "lambda_filter",
+    "SmartRouterComponent": "llm_conditional_router",
+    "LLMSelectorComponent": "llm_selector",
+    "StructuredOutputComponent": "structured_output",
+}
+
+__all__ = [
+    "BatchRunComponent",
+    "LLMSelectorComponent",
+    "SmartRouterComponent",
+    "SmartTransformComponent",
+    "StructuredOutputComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import LLM operation 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/{processing → llm_operations}/batch_run.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class BatchRunComponent(Component):
     display_name = "Batch Run"
     description = "Runs an LLM on each row of a DataFrame column. If no column is specified, all columns are used."
-    documentation: str = "https://docs.langflow.org/components-processing#batch-run"
+    documentation: str = "https://docs.langflow.org/batch-run"
     icon = "List"
 
     inputs = [

lfx/components/{processing → llm_operations}/lambda_filter.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class LambdaFilterComponent(Component):
     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-transform"
+    documentation: str = "https://docs.langflow.org/smart-transform"
     icon = "square-function"
     name = "Smart Transform"
 

lfx/components/{logic → llm_operations}/llm_conditional_router.py

@@ -9,7 +9,7 @@ from lfx.schema.table import EditMode
 class SmartRouterComponent(Component):
     display_name = "Smart Router"
     description = "Routes an input message using LLM-based categorization."
-    icon = "equal"
+    icon = "route"
     name = "SmartRouter"
 
     def __init__(self, **kwargs):

lfx/components/{processing/llm_router.py → llm_operations/llm_selector.py}

@@ -14,10 +14,10 @@ from lfx.schema.message import Message
 from lfx.template.field.base import Output
 
 
-class LLMRouterComponent(Component):
-    display_name = "LLM Router"
+class LLMSelectorComponent(Component):
+    display_name = "LLM Selector"
     description = "Routes the input to the most appropriate LLM based on OpenRouter model specifications"
-    documentation: str = "https://docs.langflow.org/components-processing#llm-router"
+    documentation: str = "https://docs.langflow.org/llm-selector"
     icon = "git-branch"
 
     # Constants for magic values

lfx/components/{processing → llm_operations}/structured_output.py

@@ -11,6 +11,7 @@ from lfx.io import (
     Output,
     TableInput,
 )
+from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.schema.table import EditMode
@@ -19,7 +20,7 @@ from lfx.schema.table import EditMode
 class StructuredOutputComponent(Component):
     display_name = "Structured Output"
     description = "Uses an LLM to generate structured data. Ideal for extraction and consistency."
-    documentation: str = "https://docs.langflow.org/components-processing#structured-output"
+    documentation: str = "https://docs.langflow.org/structured-output"
     name = "StructuredOutput"
     icon = "braces"
 
@@ -136,30 +137,27 @@ class StructuredOutputComponent(Component):
             raise ValueError(msg)
 
         output_model_ = build_model_from_schema(self.output_schema)
-
         output_model = create_model(
             schema_name,
             __doc__=f"A list of {schema_name}.",
-            objects=(list[output_model_], Field(description=f"A list of {schema_name}.")),  # type: ignore[valid-type]
+            objects=(
+                list[output_model_],
+                Field(
+                    description=f"A list of {schema_name}.",  # type: ignore[valid-type]
+                    min_length=1,  # help ensure non-empty output
+                ),
+            ),
         )
-
-        try:
-            llm_with_structured_output = create_extractor(self.llm, tools=[output_model])
-        except NotImplementedError as exc:
-            msg = f"{self.llm.__class__.__name__} does not support structured output."
-            raise TypeError(msg) from exc
-
+        # Tracing config
         config_dict = {
             "run_name": self.display_name,
             "project_name": self.get_project_name(),
             "callbacks": self.get_langchain_callbacks(),
         }
-        result = get_chat_result(
-            runnable=llm_with_structured_output,
-            system_message=self.system_prompt,
-            input_value=self.input_value,
-            config=config_dict,
-        )
+        # Generate structured output using Trustcall first, then fallback to Langchain if it fails
+        result = self._extract_output_with_trustcall(output_model, config_dict)
+        if result is None:
+            result = self._extract_output_with_langchain(output_model, config_dict)
 
         # OPTIMIZATION NOTE: Simplified processing based on trustcall response structure
         # Handle non-dict responses (shouldn't happen with trustcall, but defensive)
@@ -173,8 +171,9 @@ class StructuredOutputComponent(Component):
 
         # Convert BaseModel to dict (creates the "objects" key)
         first_response = responses[0]
-        structured_data = first_response.model_dump() if isinstance(first_response, BaseModel) else first_response
-
+        structured_data = first_response
+        if isinstance(first_response, BaseModel):
+            structured_data = first_response.model_dump()
         # Extract the objects array (guaranteed to exist due to our Pydantic model structure)
         return structured_data.get("objects", structured_data)
 
@@ -204,3 +203,42 @@ class StructuredOutputComponent(Component):
             # Multiple outputs - convert to DataFrame directly
             return DataFrame(output)
         return DataFrame()
+
+    def _extract_output_with_trustcall(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = create_extractor(self.llm, tools=[schema], tool_choice=schema.__name__)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.warning(
+                f"Trustcall extraction failed, falling back to Langchain: {e} "
+                "(Note: This may not be an error—some models or configurations do not support tool calling. "
+                "Falling back is normal in such cases.)"
+            )
+            return None
+        return result or None  # langchain fallback is used if error occurs or the result is empty
+
+    def _extract_output_with_langchain(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = self.llm.with_structured_output(schema)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+            if isinstance(result, BaseModel):
+                result = result.model_dump()
+                result = result.get("objects", result)
+        except Exception as fallback_error:
+            msg = (
+                f"Model does not support tool calling (trustcall failed) "
+                f"and fallback with_structured_output also failed: {fallback_error}"
+            )
+            raise ValueError(msg) from fallback_error
+
+        return result or None

lfx/components/logic/__init__.py

@@ -1,5 +1,12 @@
+"""Logic module - backwards compatibility alias for flow_controls.
+
+This module provides backwards compatibility by forwarding imports
+to flow_controls where the actual logic components are located.
+"""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
@@ -36,12 +43,131 @@ __all__ = [
     "SubFlowComponent",
 ]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.logic.listen
+_redirected_submodules = {
+    "lfx.components.logic.listen": "lfx.components.flow_controls.listen",
+    "lfx.components.logic.loop": "lfx.components.flow_controls.loop",
+    "lfx.components.logic.notify": "lfx.components.flow_controls.notify",
+    "lfx.components.logic.pass_message": "lfx.components.flow_controls.pass_message",
+    "lfx.components.logic.conditional_router": "lfx.components.flow_controls.conditional_router",
+    "lfx.components.logic.data_conditional_router": "lfx.components.flow_controls.data_conditional_router",
+    "lfx.components.logic.flow_tool": "lfx.components.flow_controls.flow_tool",
+    "lfx.components.logic.run_flow": "lfx.components.flow_controls.run_flow",
+    "lfx.components.logic.sub_flow": "lfx.components.flow_controls.sub_flow",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
     """Lazily import logic components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "listen":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.listen")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "loop":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.loop")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "notify":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.notify")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "pass_message":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.pass_message")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "conditional_router":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.conditional_router")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "data_conditional_router":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.data_conditional_router")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "flow_tool":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.flow_tool")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "run_flow":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.run_flow")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "sub_flow":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.sub_flow")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # Most logic components were moved to flow_controls
+    # Forward them to flow_controls for backwards compatibility
+    if attr_name in (
+        "ConditionalRouterComponent",
+        "DataConditionalRouterComponent",
+        "FlowToolComponent",
+        "LoopComponent",
+        "PassMessageComponent",
+        "RunFlowComponent",
+        "SubFlowComponent",
+    ):
+        from lfx.components import flow_controls
+
+        result = getattr(flow_controls, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # SmartRouterComponent was moved to llm_operations
+    if attr_name == "SmartRouterComponent":
+        from lfx.components import llm_operations
+
+        result = getattr(llm_operations, attr_name)
+        globals()[attr_name] = result
+        return result
+
     try:
         result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:

lfx/components/mem0/mem0_chat_memory.py

@@ -7,6 +7,11 @@ from lfx.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDi
 from lfx.io import Output
 from lfx.log.logger import logger
 from lfx.schema.data import Data
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Mem0 chat memory is not supported in Astra cloud environment. Please use local storage mode or mem0 cloud."
+)
 
 
 class Mem0MemoryComponent(LCChatMemoryComponent):
@@ -80,6 +85,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def build_mem0(self) -> Memory:
         """Initializes a Mem0 memory instance based on provided configuration and API keys."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         if self.openai_api_key:
             os.environ["OPENAI_API_KEY"] = self.openai_api_key
 
@@ -95,6 +102,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def ingest_data(self) -> Memory:
         """Ingests a new message into Mem0 memory and returns the updated memory instance."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         mem0_memory = self.existing_memory or self.build_mem0()
 
         if not self.ingest_message or not self.user_id:
@@ -115,6 +124,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def build_search_results(self) -> Data:
         """Searches the Mem0 memory for related messages based on the search query and returns the results."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         mem0_memory = self.ingest_data()
         search_query = self.search_query
         user_id = self.user_id

lfx/components/mistral/mistral_embeddings.py

@@ -1,4 +1,4 @@
-from langchain_mistralai.embeddings import MistralAIEmbeddings
+from langchain_mistralai import MistralAIEmbeddings
 from pydantic.v1 import SecretStr
 
 from lfx.base.models.model import LCModelComponent