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

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

@@ -20,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"
 

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/models/__init__.py

@@ -1,28 +1,82 @@
+"""Models module - backwards compatibility alias for models_and_agents.
+
+This module provides backwards compatibility by forwarding model-related imports
+to models_and_agents where the actual model components are located.
+"""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+import sys
+from typing import Any
 
 from lfx.components._importing import import_mod
 
-if TYPE_CHECKING:
-    from lfx.components.models.embedding_model import EmbeddingModelComponent
-    from lfx.components.models.language_model import LanguageModelComponent
-
+# Forward model components from models_and_agents
 _dynamic_imports = {
-    "EmbeddingModelComponent": "embedding_model",
     "LanguageModelComponent": "language_model",
+    "EmbeddingModelComponent": "embedding_model",
+}
+
+__all__ = [
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+]
+
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.models.embedding_model
+_redirected_submodules = {
+    "lfx.components.models.embedding_model": "lfx.components.models_and_agents.embedding_model",
+    "lfx.components.models.language_model": "lfx.components.models_and_agents.language_model",
 }
 
-__all__ = ["EmbeddingModelComponent", "LanguageModelComponent"]
+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 model components on attribute access."""
+    """Forward attribute access to models_and_agents components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "embedding_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.embedding_model")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "language_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.language_model")
+        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)
+
+    # Import from models_and_agents using the correct package path
+    package = "lfx.components.models_and_agents"
     try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:
         msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
         raise AttributeError(msg) from e
@@ -31,4 +85,5 @@ def __getattr__(attr_name: str) -> Any:
 
 
 def __dir__() -> list[str]:
+    """Return directory of available components."""
     return list(__all__)

lfx/components/models_and_agents/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.models_and_agents.agent import AgentComponent
+    from lfx.components.models_and_agents.embedding_model import EmbeddingModelComponent
+    from lfx.components.models_and_agents.language_model import LanguageModelComponent
+    from lfx.components.models_and_agents.mcp_component import MCPToolsComponent
+    from lfx.components.models_and_agents.memory import MemoryComponent
+    from lfx.components.models_and_agents.prompt import PromptComponent
+
+_dynamic_imports = {
+    "AgentComponent": "agent",
+    "EmbeddingModelComponent": "embedding_model",
+    "LanguageModelComponent": "language_model",
+    "MCPToolsComponent": "mcp_component",
+    "MemoryComponent": "memory",
+    "PromptComponent": "prompt",
+}
+
+__all__ = [
+    "AgentComponent",
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+    "MCPToolsComponent",
+    "MemoryComponent",
+    "PromptComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import model and agent 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/{agents → models_and_agents}/agent.py

@@ -14,9 +14,9 @@ from lfx.base.models.model_input_constants import (
     MODELS_METADATA,
 )
 from lfx.base.models.model_utils import get_model_name
-from lfx.components.helpers.current_date import CurrentDateComponent
-from lfx.components.helpers.memory import MemoryComponent
+from lfx.components.helpers import CurrentDateComponent
 from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComponent
+from lfx.components.models_and_agents.memory import MemoryComponent
 from lfx.custom.custom_component.component import get_component_toolkit
 from lfx.custom.utils import update_component_build_config
 from lfx.helpers.base_model import build_model_from_schema