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

lfx/components/groq/groq.py

@@ -1,7 +1,7 @@
-import requests
 from pydantic.v1 import SecretStr
 
-from lfx.base.models.groq_constants import GROQ_MODELS, TOOL_CALLING_UNSUPPORTED_GROQ_MODELS, UNSUPPORTED_GROQ_MODELS
+from lfx.base.models.groq_constants import GROQ_MODELS
+from lfx.base.models.groq_model_discovery import get_groq_models
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
@@ -52,7 +52,7 @@ class GroqModel(LCModelComponent):
         DropdownInput(
             name="model_name",
             display_name="Model",
-            info="The name of the model to use.",
+            info="The name of the model to use. Add your Groq API key to access additional available models.",
             options=GROQ_MODELS,
             value=GROQ_MODELS[0],
             refresh_button=True,
@@ -71,35 +71,42 @@ class GroqModel(LCModelComponent):
     ]
 
     def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        """Get available Groq models using the dynamic discovery system.
+
+        This method uses the groq_model_discovery module which:
+        - Fetches models directly from Groq API
+        - Automatically tests tool calling support
+        - Caches results for 24 hours
+        - Falls back to hardcoded list if API fails
+
+        Args:
+            tool_model_enabled: If True, only return models that support tool calling
+
+        Returns:
+            List of available model IDs
+        """
         try:
-            url = f"{self.base_url}/openai/v1/models"
-            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+            # Get models with metadata from dynamic discovery system
+            api_key = self.api_key if hasattr(self, "api_key") and self.api_key else None
+            models_metadata = get_groq_models(api_key=api_key)
 
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            model_list = response.json()
+            # Filter out non-LLM models (audio, TTS, guards)
             model_ids = [
-                model["id"] for model in model_list.get("data", []) if model["id"] not in UNSUPPORTED_GROQ_MODELS
+                model_id for model_id, metadata in models_metadata.items() if not metadata.get("not_supported", False)
             ]
-        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+
+            # Filter by tool calling support if requested
+            if tool_model_enabled:
+                model_ids = [model_id for model_id in model_ids if models_metadata[model_id].get("tool_calling", False)]
+                logger.info(f"Loaded {len(model_ids)} Groq models with tool calling support")
+            else:
+                logger.info(f"Loaded {len(model_ids)} Groq models")
+        except (ValueError, KeyError, TypeError, ImportError) as e:
             logger.exception(f"Error getting model names: {e}")
-            model_ids = GROQ_MODELS
-        if tool_model_enabled:
-            try:
-                from langchain_groq import ChatGroq
-            except ImportError as e:
-                msg = "langchain_groq is not installed. Please install it with `pip install langchain_groq`."
-                raise ImportError(msg) from e
-            for model in model_ids:
-                model_with_tool = ChatGroq(
-                    model=model,
-                    api_key=self.api_key,
-                    base_url=self.base_url,
-                )
-                if not self.supports_tool_calling(model_with_tool) or model in TOOL_CALLING_UNSUPPORTED_GROQ_MODELS:
-                    model_ids.remove(model)
+            # Fallback to hardcoded list from groq_constants.py
+            return GROQ_MODELS
+        else:
             return model_ids
-        return model_ids
 
     def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
         if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
@@ -107,13 +114,13 @@ class GroqModel(LCModelComponent):
                 if len(self.api_key) != 0:
                     try:
                         ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+                    except (ValueError, KeyError, TypeError, ImportError) as e:
                         logger.exception(f"Error getting model names: {e}")
                         ids = GROQ_MODELS
                     build_config.setdefault("model_name", {})
                     build_config["model_name"]["options"] = ids
                     build_config["model_name"].setdefault("value", ids[0])
-            except Exception as e:
+            except (ValueError, KeyError, TypeError, AttributeError) as e:
                 msg = f"Error getting model names: {e}"
                 raise ValueError(msg) from e
         return build_config

lfx/components/helpers/__init__.py

@@ -1,5 +1,8 @@
+"""Helpers module - backwards compatibility for moved components."""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
@@ -33,12 +36,111 @@ __all__ = [
     "OutputParserComponent",
 ]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.helpers.current_date
+_redirected_submodules = {
+    "lfx.components.helpers.current_date": "lfx.components.utilities.current_date",
+    "lfx.components.helpers.calculator_core": "lfx.components.utilities.calculator_core",
+    "lfx.components.helpers.id_generator": "lfx.components.utilities.id_generator",
+    "lfx.components.helpers.memory": "lfx.components.models_and_agents.memory",
+}
+
+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 helper components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    # e.g., lfx.components.helpers.id_generator -> lfx.components.utilities.id_generator
+    if attr_name == "id_generator":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.id_generator")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "calculator_core":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.calculator_core")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "current_date":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.current_date")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "memory":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.memory")
+        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)
+
+    # CurrentDateComponent, CalculatorComponent, and IDGeneratorComponent were moved to utilities
+    # Forward them to utilities for backwards compatibility
+    if attr_name in ("CurrentDateComponent", "CalculatorComponent", "IDGeneratorComponent"):
+        from lfx.components import utilities
+
+        result = getattr(utilities, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # MemoryComponent was moved to models_and_agents
+    # Forward it to models_and_agents for backwards compatibility
+    if attr_name == "MemoryComponent":
+        from lfx.components import models_and_agents
+
+        result = getattr(models_and_agents, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # CreateListComponent, MessageStoreComponent, and OutputParserComponent were moved to processing
+    # Forward them to processing for backwards compatibility
+    if attr_name == "CreateListComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+    if attr_name == "MessageStoreComponent":
+        from lfx.components import processing
+
+        result = processing.MessageStoreComponent
+        globals()[attr_name] = result
+        return result
+    if attr_name == "OutputParserComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, 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/ibm/watsonx.py

@@ -21,23 +21,24 @@ class WatsonxAIComponent(LCModelComponent):
     beta = False
 
     _default_models = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
-
+    _urls = [
+        "https://us-south.ml.cloud.ibm.com",
+        "https://eu-de.ml.cloud.ibm.com",
+        "https://eu-gb.ml.cloud.ibm.com",
+        "https://au-syd.ml.cloud.ibm.com",
+        "https://jp-tok.ml.cloud.ibm.com",
+        "https://ca-tor.ml.cloud.ibm.com",
+    ]
     inputs = [
         *LCModelComponent.get_base_inputs(),
         DropdownInput(
-            name="url",
+            name="base_url",
             display_name="watsonx API Endpoint",
             info="The base URL of the API.",
-            value=None,
-            options=[
-                "https://us-south.ml.cloud.ibm.com",
-                "https://eu-de.ml.cloud.ibm.com",
-                "https://eu-gb.ml.cloud.ibm.com",
-                "https://au-syd.ml.cloud.ibm.com",
-                "https://jp-tok.ml.cloud.ibm.com",
-                "https://ca-tor.ml.cloud.ibm.com",
-            ],
+            value=[],
+            options=_urls,
             real_time_refresh=True,
+            required=True,
         ),
         StrInput(
             name="project_id",
@@ -56,8 +57,9 @@ class WatsonxAIComponent(LCModelComponent):
             display_name="Model Name",
             options=[],
             value=None,
-            dynamic=True,
+            real_time_refresh=True,
             required=True,
+            refresh_button=True,
         ),
         IntInput(
             name="max_tokens",
@@ -155,18 +157,20 @@ class WatsonxAIComponent(LCModelComponent):
 
     def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
         """Update model options when URL or API key changes."""
-        logger.info("Updating build config. Field name: %s, Field value: %s", field_name, field_value)
-
-        if field_name == "url" and field_value:
+        if field_name == "base_url" and field_value:
             try:
-                models = self.fetch_models(base_url=build_config.url.value)
-                build_config.model_name.options = models
-                if build_config.model_name.value:
-                    build_config.model_name.value = models[0]
-                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
+                models = self.fetch_models(base_url=field_value)
+                build_config["model_name"]["options"] = models
+                if build_config["model_name"]["value"]:
+                    build_config["model_name"]["value"] = models[0]
+                info_message = f"Updated model options: {len(models)} models found in {field_value}"
                 logger.info(info_message)
             except Exception:  # noqa: BLE001
                 logger.exception("Error updating model options.")
+        if field_name == "model_name" and field_value and field_value in WatsonxAIComponent._urls:
+            build_config["model_name"]["options"] = self.fetch_models(base_url=field_value)
+            build_config["model_name"]["value"] = ""
+        return build_config
 
     def build_model(self) -> LanguageModel:
         # Parse logit_bias from JSON string if provided
@@ -195,7 +199,7 @@ class WatsonxAIComponent(LCModelComponent):
 
         return ChatWatsonx(
             apikey=SecretStr(self.api_key).get_secret_value(),
-            url=self.url,
+            url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,
             params=chat_params,

lfx/components/input_output/__init__.py

@@ -9,15 +9,17 @@ if TYPE_CHECKING:
     from lfx.components.input_output.chat_output import ChatOutput
     from lfx.components.input_output.text import TextInputComponent
     from lfx.components.input_output.text_output import TextOutputComponent
+    from lfx.components.input_output.webhook import WebhookComponent
 
 _dynamic_imports = {
     "ChatInput": "chat",
     "ChatOutput": "chat_output",
     "TextInputComponent": "text",
     "TextOutputComponent": "text_output",
+    "WebhookComponent": "webhook",
 }
 
-__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
+__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent", "WebhookComponent"]
 
 
 def __getattr__(attr_name: str) -> Any:

lfx/components/input_output/chat.py

@@ -19,7 +19,7 @@ from lfx.utils.constants import (
 class ChatInput(ChatComponent):
     display_name = "Chat Input"
     description = "Get chat inputs from the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-input"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatInput"
     minimized = True
@@ -60,6 +60,13 @@ class ChatInput(ChatComponent):
             info="The session ID of the chat. If empty, the current session ID parameter will be used.",
             advanced=True,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         FileInput(
             name="files",
             display_name="Files",
@@ -82,14 +89,16 @@ class ChatInput(ChatComponent):
         # Filter out None/empty values
         files = [f for f in files if f is not None and f != ""]
 
+        session_id = self.session_id or self.graph.session_id or ""
         message = await Message.create(
             text=self.input_value,
             sender=self.sender,
             sender_name=self.sender_name,
-            session_id=self.session_id,
+            session_id=session_id,
+            context_id=self.context_id,
             files=files,
         )
-        if self.session_id and isinstance(message, Message) and self.should_store_message:
+        if session_id and isinstance(message, Message) and self.should_store_message:
             stored_message = await self.send_message(
                 message,
             )

lfx/components/input_output/chat_output.py

@@ -22,7 +22,7 @@ from lfx.utils.constants import (
 class ChatOutput(ChatComponent):
     display_name = "Chat Output"
     description = "Display a chat message in the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-output"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatOutput"
     minimized = True
@@ -63,6 +63,13 @@ class ChatOutput(ChatComponent):
             info="The session ID of the chat. If empty, the current session ID parameter will be used.",
             advanced=True,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         MessageTextInput(
             name="data_template",
             display_name="Data Template",
@@ -110,7 +117,7 @@ class ChatOutput(ChatComponent):
         source, _, display_name, source_id = self.get_properties_from_source_component()
 
         # Create or use existing Message object
-        if isinstance(self.input_value, Message):
+        if isinstance(self.input_value, Message) and not self.is_connected_to_chat_input():
             message = self.input_value
             # Update message properties
             message.text = text
@@ -120,12 +127,13 @@ class ChatOutput(ChatComponent):
         # Set message properties
         message.sender = self.sender
         message.sender_name = self.sender_name
-        message.session_id = self.session_id
+        message.session_id = self.session_id or self.graph.session_id or ""
+        message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)
 
         # Store message if needed
-        if self.session_id and self.should_store_message:
+        if message.session_id and self.should_store_message:
             stored_message = await self.send_message(message)
             self.message.value = stored_message
             message = stored_message

lfx/components/input_output/text.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextInputComponent(TextComponent):
     display_name = "Text Input"
     description = "Get user text inputs."
-    documentation: str = "https://docs.langflow.org/components-io#text-input"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextInput"
 

lfx/components/input_output/text_output.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextOutputComponent(TextComponent):
     display_name = "Text Output"
     description = "Sends text output via API."
-    documentation: str = "https://docs.langflow.org/components-io#text-output"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextOutput"
 

lfx/components/{data → input_output}/webhook.py

@@ -7,7 +7,7 @@ from lfx.schema.data import Data
 
 class WebhookComponent(Component):
     display_name = "Webhook"
-    documentation: str = "https://docs.langflow.org/components-data#webhook"
+    documentation: str = "https://docs.langflow.org/component-webhook"
     name = "Webhook"
     icon = "webhook"
 

lfx/components/knowledge_bases/__init__.py

@@ -1,12 +1,19 @@
+"""Knowledge bases module - backwards compatibility alias for files_and_knowledge.
+
+This module provides backwards compatibility by forwarding all imports
+to files_and_knowledge where the actual knowledge base components are located.
+"""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from lfx.components.knowledge_bases.ingestion import KnowledgeIngestionComponent
-    from lfx.components.knowledge_bases.retrieval import KnowledgeRetrievalComponent
+    from lfx.components.files_and_knowledge.ingestion import KnowledgeIngestionComponent
+    from lfx.components.files_and_knowledge.retrieval import KnowledgeRetrievalComponent
 
 _dynamic_imports = {
     "KnowledgeIngestionComponent": "ingestion",
@@ -15,14 +22,61 @@ _dynamic_imports = {
 
 __all__ = ["KnowledgeIngestionComponent", "KnowledgeRetrievalComponent"]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.knowledge_bases.ingestion
+_redirected_submodules = {
+    "lfx.components.knowledge_bases.ingestion": "lfx.components.files_and_knowledge.ingestion",
+    "lfx.components.knowledge_bases.retrieval": "lfx.components.files_and_knowledge.retrieval",
+}
+
+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 input/output components on attribute access."""
+    """Forward attribute access to files_and_knowledge components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "ingestion":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.ingestion")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "retrieval":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.retrieval")
+        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 files_and_knowledge using the correct package path
+    package = "lfx.components.files_and_knowledge"
     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/langchain_utilities/character.py

@@ -10,7 +10,7 @@ from lfx.utils.util import unescape_string
 class CharacterTextSplitterComponent(LCTextSplitterComponent):
     display_name = "Character Text Splitter"
     description = "Split text by number of characters."
-    documentation = "https://docs.langflow.org/components/text-splitters#charactertextsplitter"
+    documentation = "https://docs.langflow.org/bundles-langchain"
     name = "CharacterTextSplitter"
     icon = "LangChain"