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

lfx/components/helpers/memory.py

@@ -0,0 +1,251 @@
+from typing import Any, cast
+
+from lfx.custom.custom_component.component import Component
+from lfx.helpers.data import data_to_text
+from lfx.inputs.inputs import DropdownInput, HandleInput, IntInput, MessageTextInput, MultilineInput, TabInput
+from lfx.memory import aget_messages, astore_message
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.dotdict import dotdict
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+from lfx.utils.component_utils import set_current_fields, set_field_display
+from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI, MESSAGE_SENDER_USER
+
+
+class MemoryComponent(Component):
+    display_name = "Message History"
+    description = "Stores or retrieves stored chat messages from Langflow tables or an external memory."
+    documentation: str = "https://docs.langflow.org/components-helpers#message-history"
+    icon = "message-square-more"
+    name = "Memory"
+    default_keys = ["mode", "memory"]
+    mode_config = {
+        "Store": ["message", "memory", "sender", "sender_name", "session_id"],
+        "Retrieve": ["n_messages", "order", "template", "memory"],
+    }
+
+    inputs = [
+        TabInput(
+            name="mode",
+            display_name="Mode",
+            options=["Retrieve", "Store"],
+            value="Retrieve",
+            info="Operation mode: Store messages or Retrieve messages.",
+            real_time_refresh=True,
+        ),
+        MessageTextInput(
+            name="message",
+            display_name="Message",
+            info="The chat message to be stored.",
+            tool_mode=True,
+            dynamic=True,
+            show=False,
+        ),
+        HandleInput(
+            name="memory",
+            display_name="External Memory",
+            input_types=["Memory"],
+            info="Retrieve messages from an external memory. If empty, it will use the Langflow tables.",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="sender_type",
+            display_name="Sender Type",
+            options=[MESSAGE_SENDER_AI, MESSAGE_SENDER_USER, "Machine and User"],
+            value="Machine and User",
+            info="Filter by sender type.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="sender",
+            display_name="Sender",
+            info="The sender of the message. Might be Machine or User. "
+            "If empty, the current sender parameter will be used.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="sender_name",
+            display_name="Sender Name",
+            info="Filter by sender name.",
+            advanced=True,
+            show=False,
+        ),
+        IntInput(
+            name="n_messages",
+            display_name="Number of Messages",
+            value=100,
+            info="Number of messages to retrieve.",
+            advanced=True,
+            show=True,
+        ),
+        MessageTextInput(
+            name="session_id",
+            display_name="Session ID",
+            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
+            value="",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="order",
+            display_name="Order",
+            options=["Ascending", "Descending"],
+            value="Ascending",
+            info="Order of the messages.",
+            advanced=True,
+            tool_mode=True,
+            required=True,
+        ),
+        MultilineInput(
+            name="template",
+            display_name="Template",
+            info="The template to use for formatting the data. "
+            "It can contain the keys {text}, {sender} or any other key in the message data.",
+            value="{sender_name}: {text}",
+            advanced=True,
+            show=False,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Message", name="messages_text", method="retrieve_messages_as_text", dynamic=True),
+        Output(display_name="Dataframe", name="dataframe", method="retrieve_messages_dataframe", dynamic=True),
+    ]
+
+    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
+        """Dynamically show only the relevant output based on the selected output type."""
+        if field_name == "mode":
+            # Start with empty outputs
+            frontend_node["outputs"] = []
+            if field_value == "Store":
+                frontend_node["outputs"] = [
+                    Output(
+                        display_name="Stored Messages",
+                        name="stored_messages",
+                        method="store_message",
+                        hidden=True,
+                        dynamic=True,
+                    )
+                ]
+            if field_value == "Retrieve":
+                frontend_node["outputs"] = [
+                    Output(
+                        display_name="Messages", name="messages_text", method="retrieve_messages_as_text", dynamic=True
+                    ),
+                    Output(
+                        display_name="Dataframe", name="dataframe", method="retrieve_messages_dataframe", dynamic=True
+                    ),
+                ]
+        return frontend_node
+
+    async def store_message(self) -> Message:
+        message = Message(text=self.message) if isinstance(self.message, str) else self.message
+
+        message.session_id = self.session_id or message.session_id
+        message.sender = self.sender or message.sender or MESSAGE_SENDER_AI
+        message.sender_name = self.sender_name or message.sender_name or MESSAGE_SENDER_NAME_AI
+
+        stored_messages: list[Message] = []
+
+        if self.memory:
+            self.memory.session_id = message.session_id
+            lc_message = message.to_lc_message()
+            await self.memory.aadd_messages([lc_message])
+
+            stored_messages = await self.memory.aget_messages() or []
+
+            stored_messages = [Message.from_lc_message(m) for m in stored_messages] if stored_messages else []
+
+            if message.sender:
+                stored_messages = [m for m in stored_messages if m.sender == message.sender]
+        else:
+            await astore_message(message, flow_id=self.graph.flow_id)
+            stored_messages = (
+                await aget_messages(
+                    session_id=message.session_id, sender_name=message.sender_name, sender=message.sender
+                )
+                or []
+            )
+
+        if not stored_messages:
+            msg = "No messages were stored. Please ensure that the session ID and sender are properly set."
+            raise ValueError(msg)
+
+        stored_message = stored_messages[0]
+        self.status = stored_message
+        return stored_message
+
+    async def retrieve_messages(self) -> Data:
+        sender_type = self.sender_type
+        sender_name = self.sender_name
+        session_id = self.session_id
+        n_messages = self.n_messages
+        order = "DESC" if self.order == "Descending" else "ASC"
+
+        if sender_type == "Machine and User":
+            sender_type = None
+
+        if self.memory and not hasattr(self.memory, "aget_messages"):
+            memory_name = type(self.memory).__name__
+            err_msg = f"External Memory object ({memory_name}) must have 'aget_messages' method."
+            raise AttributeError(err_msg)
+        # Check if n_messages is None or 0
+        if n_messages == 0:
+            stored = []
+        elif self.memory:
+            # override session_id
+            self.memory.session_id = session_id
+
+            stored = await self.memory.aget_messages()
+            # langchain memories are supposed to return messages in ascending order
+
+            if order == "DESC":
+                stored = stored[::-1]
+            if n_messages:
+                stored = stored[-n_messages:] if order == "ASC" else stored[:n_messages]
+            stored = [Message.from_lc_message(m) for m in stored]
+            if sender_type:
+                expected_type = MESSAGE_SENDER_AI if sender_type == MESSAGE_SENDER_AI else MESSAGE_SENDER_USER
+                stored = [m for m in stored if m.type == expected_type]
+        else:
+            # For internal memory, we always fetch the last N messages by ordering by DESC
+            stored = await aget_messages(
+                sender=sender_type,
+                sender_name=sender_name,
+                session_id=session_id,
+                limit=10000,
+                order=order,
+            )
+            if n_messages:
+                stored = stored[-n_messages:] if order == "ASC" else stored[:n_messages]
+
+        # self.status = stored
+        return cast("Data", stored)
+
+    async def retrieve_messages_as_text(self) -> Message:
+        stored_text = data_to_text(self.template, await self.retrieve_messages())
+        # self.status = stored_text
+        return Message(text=stored_text)
+
+    async def retrieve_messages_dataframe(self) -> DataFrame:
+        """Convert the retrieved messages into a DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame containing the message data.
+        """
+        messages = await self.retrieve_messages()
+        return DataFrame(messages)
+
+    def update_build_config(
+        self,
+        build_config: dotdict,
+        field_value: Any,  # noqa: ARG002
+        field_name: str | None = None,  # noqa: ARG002
+    ) -> dotdict:
+        return set_current_fields(
+            build_config=build_config,
+            action_fields=self.mode_config,
+            selected_action=build_config["mode"]["value"],
+            default_fields=self.default_keys,
+            func=set_field_display,
+        )

lfx/components/helpers/output_parser.py

@@ -0,0 +1,45 @@
+from langchain_core.output_parsers import CommaSeparatedListOutputParser
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.constants import OutputParser
+from lfx.io import DropdownInput, Output
+from lfx.schema.message import Message
+
+
+class OutputParserComponent(Component):
+    display_name = "Output Parser"
+    description = "Transforms the output of an LLM into a specified format."
+    icon = "type"
+    name = "OutputParser"
+    legacy = True
+
+    inputs = [
+        DropdownInput(
+            name="parser_type",
+            display_name="Parser",
+            options=["CSV"],
+            value="CSV",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Format Instructions",
+            name="format_instructions",
+            info="Pass to a prompt template to include formatting instructions for LLM responses.",
+            method="format_instructions",
+        ),
+        Output(display_name="Output Parser", name="output_parser", method="build_parser"),
+    ]
+
+    def build_parser(self) -> OutputParser:
+        if self.parser_type == "CSV":
+            return CommaSeparatedListOutputParser()
+        msg = "Unsupported or missing parser"
+        raise ValueError(msg)
+
+    def format_instructions(self) -> Message:
+        if self.parser_type == "CSV":
+            return Message(text=CommaSeparatedListOutputParser().get_format_instructions())
+        msg = "Unsupported or missing parser"
+        raise ValueError(msg)

lfx/components/helpers/store_message.py

@@ -0,0 +1,90 @@
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import (
+    HandleInput,
+    MessageTextInput,
+)
+from lfx.memory import aget_messages, astore_message
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI
+
+
+class MessageStoreComponent(Component):
+    display_name = "Message Store"
+    description = "Stores a chat message or text into Langflow tables or an external memory."
+    icon = "message-square-text"
+    name = "StoreMessage"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="message", display_name="Message", info="The chat message to be stored.", required=True, tool_mode=True
+        ),
+        HandleInput(
+            name="memory",
+            display_name="External Memory",
+            input_types=["Memory"],
+            info="The external memory to store the message. If empty, it will use the Langflow tables.",
+        ),
+        MessageTextInput(
+            name="sender",
+            display_name="Sender",
+            info="The sender of the message. Might be Machine or User. "
+            "If empty, the current sender parameter will be used.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="sender_name",
+            display_name="Sender Name",
+            info="The name of the sender. Might be AI or User. If empty, the current sender parameter will be used.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="session_id",
+            display_name="Session ID",
+            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
+            value="",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Stored Messages", name="stored_messages", method="store_message", hidden=True),
+    ]
+
+    async def store_message(self) -> Message:
+        message = Message(text=self.message) if isinstance(self.message, str) else self.message
+
+        message.session_id = self.session_id or message.session_id
+        message.sender = self.sender or message.sender or MESSAGE_SENDER_AI
+        message.sender_name = self.sender_name or message.sender_name or MESSAGE_SENDER_NAME_AI
+
+        stored_messages: list[Message] = []
+
+        if self.memory:
+            self.memory.session_id = message.session_id
+            lc_message = message.to_lc_message()
+            await self.memory.aadd_messages([lc_message])
+
+            stored_messages = await self.memory.aget_messages() or []
+
+            stored_messages = [Message.from_lc_message(m) for m in stored_messages] if stored_messages else []
+
+            if message.sender:
+                stored_messages = [m for m in stored_messages if m.sender == message.sender]
+        else:
+            await astore_message(message, flow_id=self.graph.flow_id)
+            stored_messages = (
+                await aget_messages(
+                    session_id=message.session_id, sender_name=message.sender_name, sender=message.sender
+                )
+                or []
+            )
+
+        if not stored_messages:
+            msg = "No messages were stored. Please ensure that the session ID and sender are properly set."
+            raise ValueError(msg)
+
+        stored_message = stored_messages[0]
+        self.status = stored_message
+        return stored_message

lfx/components/homeassistant/__init__.py

@@ -0,0 +1,7 @@
+from .home_assistant_control import HomeAssistantControl
+from .list_home_assistant_states import ListHomeAssistantStates
+
+__all__ = [
+    "HomeAssistantControl",
+    "ListHomeAssistantStates",
+]

lfx/components/homeassistant/home_assistant_control.py

@@ -0,0 +1,152 @@
+import json
+from typing import Any
+
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class HomeAssistantControl(LCToolComponent):
+    """This tool is used to control Home Assistant devices.
+
+    A very simple tool to control Home Assistant devices.
+    - The agent only needs to provide action (turn_on, turn_off, toggle) + entity_id (e.g., switch.xxx, light.xxx).
+    - The domain (e.g., 'switch', 'light') is automatically extracted from entity_id.
+    """
+
+    display_name: str = "Home Assistant Control"
+    description: str = (
+        "A very simple tool to control Home Assistant devices. "
+        "Only action (turn_on, turn_off, toggle) and entity_id need to be provided."
+    )
+    documentation: str = "https://developers.home-assistant.io/docs/api/rest/"
+    icon: str = "HomeAssistant"
+
+    # --- Input fields for LangFlow UI (token, URL) ---
+    inputs = [
+        SecretStrInput(
+            name="ha_token",
+            display_name="Home Assistant Token",
+            info="Home Assistant Long-Lived Access Token",
+            required=True,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Home Assistant URL",
+            info="e.g., http://192.168.0.10:8123",
+            required=True,
+        ),
+        StrInput(
+            name="default_action",
+            display_name="Default Action (Optional)",
+            info="One of turn_on, turn_off, toggle",
+            required=False,
+        ),
+        StrInput(
+            name="default_entity_id",
+            display_name="Default Entity ID (Optional)",
+            info="Default entity ID to control (e.g., switch.unknown_switch_3)",
+            required=False,
+        ),
+    ]
+
+    # --- Parameters exposed to the agent (Pydantic schema) ---
+    class ToolSchema(BaseModel):
+        """Parameters to be passed by the agent: action, entity_id only."""
+
+        action: str = Field(..., description="Home Assistant service name. (One of turn_on, turn_off, toggle)")
+        entity_id: str = Field(
+            ...,
+            description="Entity ID to control (e.g., switch.xxx, light.xxx, cover.xxx, etc.)."
+            "Do not infer; use the list_homeassistant_states tool to retrieve it.",
+        )
+
+    def run_model(self) -> Data:
+        """Used when the 'Run' button is clicked in LangFlow.
+
+        - Uses default_action and default_entity_id entered in the UI.
+        """
+        action = self.default_action or "turn_off"
+        entity_id = self.default_entity_id or "switch.unknown_switch_3"
+
+        result = self._control_device(
+            ha_token=self.ha_token,
+            base_url=self.base_url,
+            action=action,
+            entity_id=entity_id,
+        )
+        return self._make_data_response(result)
+
+    def build_tool(self) -> Tool:
+        """Returns a tool to be used by the agent (LLM).
+
+        - The agent can only pass action and entity_id as arguments.
+        """
+        return StructuredTool.from_function(
+            name="home_assistant_control",
+            description=(
+                "A tool to control Home Assistant devices easily. "
+                "Parameters: action ('turn_on'/'turn_off'/'toggle'), entity_id ('switch.xxx', etc.)."
+                "Entity ID must be obtained using the list_homeassistant_states tool and not guessed."
+            ),
+            func=self._control_device_for_tool,  # Wrapper function below
+            args_schema=self.ToolSchema,
+        )
+
+    def _control_device_for_tool(self, action: str, entity_id: str) -> dict[str, Any] | str:
+        """Function called by the agent.
+
+        -> Internally calls _control_device.
+        """
+        return self._control_device(
+            ha_token=self.ha_token,
+            base_url=self.base_url,
+            action=action,
+            entity_id=entity_id,
+        )
+
+    def _control_device(
+        self,
+        ha_token: str,
+        base_url: str,
+        action: str,
+        entity_id: str,
+    ) -> dict[str, Any] | str:
+        """Actual logic to call the Home Assistant service.
+
+        The domain is extracted from the beginning of the entity_id.
+        Example: entity_id="switch.unknown_switch_3" -> domain="switch".
+        """
+        try:
+            domain = entity_id.split(".")[0]  # switch, light, cover, etc.
+            url = f"{base_url}/api/services/{domain}/{action}"
+
+            headers = {
+                "Authorization": f"Bearer {ha_token}",
+                "Content-Type": "application/json",
+            }
+            payload = {"entity_id": entity_id}
+
+            response = requests.post(url, headers=headers, json=payload, timeout=10)
+            response.raise_for_status()
+
+            return response.json()  # HA response JSON on success
+        except requests.exceptions.RequestException as e:
+            return f"Error: Failed to call service. {e}"
+        except Exception as e:  # noqa: BLE001
+            return f"An unexpected error occurred: {e}"
+
+    def _make_data_response(self, result: dict[str, Any] | str) -> Data:
+        """Returns a response in the LangFlow Data format."""
+        if isinstance(result, str):
+            # Handle error messages
+            return Data(text=result)
+
+        # Convert dict to JSON string
+        formatted_json = json.dumps(result, indent=2, ensure_ascii=False)
+        return Data(data=result, text=formatted_json)

lfx/components/homeassistant/list_home_assistant_states.py

@@ -0,0 +1,137 @@
+import json
+from typing import Any
+
+import requests
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class ListHomeAssistantStates(LCToolComponent):
+    display_name: str = "List Home Assistant States"
+    description: str = (
+        "Retrieve states from Home Assistant. "
+        "The agent only needs to specify 'filter_domain' (optional). "
+        "Token and base_url are not exposed to the agent."
+    )
+    documentation: str = "https://developers.home-assistant.io/docs/api/rest/"
+    icon = "HomeAssistant"
+
+    # 1) Define fields to be received in LangFlow UI
+    inputs = [
+        SecretStrInput(
+            name="ha_token",
+            display_name="Home Assistant Token",
+            info="Home Assistant Long-Lived Access Token",
+            required=True,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Home Assistant URL",
+            info="e.g., http://192.168.0.10:8123",
+            required=True,
+        ),
+        StrInput(
+            name="filter_domain",
+            display_name="Default Filter Domain (Optional)",
+            info="light, switch, sensor, etc. (Leave empty to fetch all)",
+            required=False,
+        ),
+    ]
+
+    # 2) Pydantic schema containing only parameters exposed to the agent
+    class ToolSchema(BaseModel):
+        """Parameters to be passed by the agent: filter_domain only."""
+
+        filter_domain: str = Field("", description="Filter domain (e.g., 'light'). If empty, returns all.")
+
+    def run_model(self) -> Data:
+        """Execute the LangFlow component.
+
+        Uses self.ha_token, self.base_url, self.filter_domain as entered in the UI.
+        Triggered when 'Run' is clicked directly without an agent.
+        """
+        filter_domain = self.filter_domain or ""  # Use "" for fetching all states
+        result = self._list_states(
+            ha_token=self.ha_token,
+            base_url=self.base_url,
+            filter_domain=filter_domain,
+        )
+        return self._make_data_response(result)
+
+    def build_tool(self) -> Tool:
+        """Build a tool object to be used by the agent.
+
+        The agent can only pass 'filter_domain' as a parameter.
+        'ha_token' and 'base_url' are not exposed (stored as self attributes).
+        """
+        return StructuredTool.from_function(
+            name="list_homeassistant_states",
+            description=(
+                "Retrieve states from Home Assistant. "
+                "You can provide filter_domain='light', 'switch', etc. to narrow results."
+            ),
+            func=self._list_states_for_tool,  # Wrapper function below
+            args_schema=self.ToolSchema,  # Requires only filter_domain
+        )
+
+    def _list_states_for_tool(self, filter_domain: str = "") -> list[Any] | str:
+        """Execute the tool when called by the agent.
+
+        'ha_token' and 'base_url' are stored in self (not exposed).
+        """
+        return self._list_states(
+            ha_token=self.ha_token,
+            base_url=self.base_url,
+            filter_domain=filter_domain,
+        )
+
+    def _list_states(
+        self,
+        ha_token: str,
+        base_url: str,
+        filter_domain: str = "",
+    ) -> list[Any] | str:
+        """Call the Home Assistant /api/states endpoint."""
+        try:
+            headers = {
+                "Authorization": f"Bearer {ha_token}",
+                "Content-Type": "application/json",
+            }
+            url = f"{base_url}/api/states"
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+
+            all_states = response.json()
+            if filter_domain:
+                return [st for st in all_states if st.get("entity_id", "").startswith(f"{filter_domain}.")]
+
+        except requests.exceptions.RequestException as e:
+            return f"Error: Failed to fetch states. {e}"
+        except (ValueError, TypeError) as e:
+            return f"Error processing response: {e}"
+        return all_states
+
+    def _make_data_response(self, result: list[Any] | str | dict) -> Data:
+        """Format the response into a Data object."""
+        try:
+            if isinstance(result, list):
+                # Wrap list data into a dictionary and convert to text
+                wrapped_result = {"result": result}
+                return Data(data=wrapped_result, text=json.dumps(wrapped_result, indent=2, ensure_ascii=False))
+            if isinstance(result, dict):
+                # Return dictionary as-is
+                return Data(data=result, text=json.dumps(result, indent=2, ensure_ascii=False))
+            if isinstance(result, str):
+                # Return error messages or strings
+                return Data(data={}, text=result)
+
+            # Handle unexpected data types
+            return Data(data={}, text="Error: Unexpected response format.")
+        except (TypeError, ValueError) as e:
+            # Handle specific exceptions during formatting
+            return Data(data={}, text=f"Error: Failed to process response. Details: {e!s}")