lfx-nightly 0.2.0.dev25__py3-none-any.whl

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}")

lfx/components/huggingface/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .huggingface import HuggingFaceEndpointsComponent
+    from .huggingface_inference_api import HuggingFaceInferenceAPIEmbeddingsComponent
+
+_dynamic_imports = {
+    "HuggingFaceEndpointsComponent": "huggingface",
+    "HuggingFaceInferenceAPIEmbeddingsComponent": "huggingface_inference_api",
+}
+
+__all__ = [
+    "HuggingFaceEndpointsComponent",
+    "HuggingFaceInferenceAPIEmbeddingsComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import huggingface 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/huggingface/huggingface.py

@@ -0,0 +1,199 @@
+from typing import Any
+
+from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint
+from tenacity import retry, stop_after_attempt, wait_fixed
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import DictInput, DropdownInput, FloatInput, IntInput, SecretStrInput, SliderInput, StrInput
+
+# TODO: langchain_community.llms.huggingface_endpoint is depreciated.
+#  Need to update to langchain_huggingface, but have dependency with langchain_core 0.3.0
+
+# Constants
+DEFAULT_MODEL = "meta-llama/Llama-3.3-70B-Instruct"
+
+
+class HuggingFaceEndpointsComponent(LCModelComponent):
+    display_name: str = "Hugging Face"
+    description: str = "Generate text using Hugging Face Inference APIs."
+    icon = "HuggingFace"
+    name = "HuggingFaceModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        DropdownInput(
+            name="model_id",
+            display_name="Model ID",
+            info="Select a model from Hugging Face Hub",
+            options=[
+                DEFAULT_MODEL,
+                "mistralai/Mixtral-8x7B-Instruct-v0.1",
+                "mistralai/Mistral-7B-Instruct-v0.3",
+                "meta-llama/Llama-3.1-8B-Instruct",
+                "Qwen/Qwen2.5-Coder-32B-Instruct",
+                "Qwen/QwQ-32B-Preview",
+                "openai-community/gpt2",
+                "custom",
+            ],
+            value=DEFAULT_MODEL,
+            required=True,
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="custom_model",
+            display_name="Custom Model ID",
+            info="Enter a custom model ID from Hugging Face Hub",
+            value="",
+            show=False,
+            required=True,
+        ),
+        IntInput(
+            name="max_new_tokens", display_name="Max New Tokens", value=512, info="Maximum number of generated tokens"
+        ),
+        IntInput(
+            name="top_k",
+            display_name="Top K",
+            advanced=True,
+            info="The number of highest probability vocabulary tokens to keep for top-k-filtering",
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            value=0.95,
+            advanced=True,
+            info=(
+                "If set to < 1, only the smallest set of most probable tokens with "
+                "probabilities that add up to `top_p` or higher are kept for generation"
+            ),
+        ),
+        FloatInput(
+            name="typical_p",
+            display_name="Typical P",
+            value=0.95,
+            advanced=True,
+            info="Typical Decoding mass.",
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.8,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            info="The value used to module the logits distribution",
+            advanced=True,
+        ),
+        FloatInput(
+            name="repetition_penalty",
+            display_name="Repetition Penalty",
+            info="The parameter for repetition penalty. 1.0 means no penalty.",
+            advanced=True,
+        ),
+        StrInput(
+            name="inference_endpoint",
+            display_name="Inference Endpoint",
+            value="https://api-inference.huggingface.co/models/",
+            info="Custom inference endpoint URL.",
+            required=True,
+        ),
+        DropdownInput(
+            name="task",
+            display_name="Task",
+            options=["text2text-generation", "text-generation", "summarization", "translation"],
+            value="text-generation",
+            advanced=True,
+            info="The task to call the model with. Should be a task that returns `generated_text` or `summary_text`.",
+        ),
+        SecretStrInput(
+            name="huggingfacehub_api_token", display_name="HuggingFace HubAPI Token", password=True, required=True
+        ),
+        DictInput(name="model_kwargs", display_name="Model Keyword Arguments", advanced=True),
+        IntInput(name="retry_attempts", display_name="Retry Attempts", value=1, advanced=True),
+    ]
+
+    def get_api_url(self) -> str:
+        if "huggingface" in self.inference_endpoint.lower():
+            if self.model_id == "custom":
+                if not self.custom_model:
+                    error_msg = "Custom model ID is required when 'custom' is selected"
+                    raise ValueError(error_msg)
+                return f"{self.inference_endpoint}{self.custom_model}"
+            return f"{self.inference_endpoint}{self.model_id}"
+        return self.inference_endpoint
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        """Update build configuration based on field updates."""
+        try:
+            if field_name is None or field_name == "model_id":
+                # If model_id is custom, show custom model field
+                if field_value == "custom":
+                    build_config["custom_model"]["show"] = True
+                    build_config["custom_model"]["required"] = True
+                else:
+                    build_config["custom_model"]["show"] = False
+                    build_config["custom_model"]["value"] = ""
+
+        except (KeyError, AttributeError) as e:
+            self.log(f"Error updating build config: {e!s}")
+        return build_config
+
+    def create_huggingface_endpoint(
+        self,
+        task: str | None,
+        huggingfacehub_api_token: str | None,
+        model_kwargs: dict[str, Any],
+        max_new_tokens: int,
+        top_k: int | None,
+        top_p: float,
+        typical_p: float | None,
+        temperature: float | None,
+        repetition_penalty: float | None,
+    ) -> HuggingFaceEndpoint:
+        retry_attempts = self.retry_attempts
+        endpoint_url = self.get_api_url()
+
+        @retry(stop=stop_after_attempt(retry_attempts), wait=wait_fixed(2))
+        def _attempt_create():
+            return HuggingFaceEndpoint(
+                endpoint_url=endpoint_url,
+                task=task,
+                huggingfacehub_api_token=huggingfacehub_api_token,
+                model_kwargs=model_kwargs,
+                max_new_tokens=max_new_tokens,
+                top_k=top_k,
+                top_p=top_p,
+                typical_p=typical_p,
+                temperature=temperature,
+                repetition_penalty=repetition_penalty,
+            )
+
+        return _attempt_create()
+
+    def build_model(self) -> LanguageModel:
+        task = self.task or None
+        huggingfacehub_api_token = self.huggingfacehub_api_token
+        model_kwargs = self.model_kwargs or {}
+        max_new_tokens = self.max_new_tokens
+        top_k = self.top_k or None
+        top_p = self.top_p
+        typical_p = self.typical_p or None
+        temperature = self.temperature or 0.8
+        repetition_penalty = self.repetition_penalty or None
+
+        try:
+            llm = self.create_huggingface_endpoint(
+                task=task,
+                huggingfacehub_api_token=huggingfacehub_api_token,
+                model_kwargs=model_kwargs,
+                max_new_tokens=max_new_tokens,
+                top_k=top_k,
+                top_p=top_p,
+                typical_p=typical_p,
+                temperature=temperature,
+                repetition_penalty=repetition_penalty,
+            )
+        except Exception as e:
+            msg = "Could not connect to Hugging Face Endpoints API."
+            raise ValueError(msg) from e
+
+        return llm

lfx/components/huggingface/huggingface_inference_api.py

@@ -0,0 +1,106 @@
+from urllib.parse import urlparse
+
+import requests
+from langchain_community.embeddings.huggingface import HuggingFaceInferenceAPIEmbeddings
+
+# Next update: use langchain_huggingface
+from pydantic import SecretStr
+from tenacity import retry, stop_after_attempt, wait_fixed
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.io import MessageTextInput, Output, SecretStrInput
+
+
+class HuggingFaceInferenceAPIEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "Hugging Face Embeddings Inference"
+    description = "Generate embeddings using Hugging Face Text Embeddings Inference (TEI)"
+    documentation = "https://huggingface.co/docs/text-embeddings-inference/index"
+    icon = "HuggingFace"
+    name = "HuggingFaceInferenceAPIEmbeddings"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="HuggingFace API Key",
+            advanced=False,
+            info="Required for non-local inference endpoints. Local inference does not require an API Key.",
+        ),
+        MessageTextInput(
+            name="inference_endpoint",
+            display_name="Inference Endpoint",
+            required=True,
+            value="https://api-inference.huggingface.co/models/",
+            info="Custom inference endpoint URL.",
+        ),
+        MessageTextInput(
+            name="model_name",
+            display_name="Model Name",
+            value="BAAI/bge-large-en-v1.5",
+            info="The name of the model to use for text embeddings.",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def validate_inference_endpoint(self, inference_endpoint: str) -> bool:
+        parsed_url = urlparse(inference_endpoint)
+        if not all([parsed_url.scheme, parsed_url.netloc]):
+            msg = (
+                f"Invalid inference endpoint format: '{self.inference_endpoint}'. "
+                "Please ensure the URL includes both a scheme (e.g., 'http://' or 'https://') and a domain name. "
+                "Example: 'http://localhost:8080' or 'https://api.example.com'"
+            )
+            raise ValueError(msg)
+
+        try:
+            response = requests.get(f"{inference_endpoint}/health", timeout=5)
+        except requests.RequestException as e:
+            msg = (
+                f"Inference endpoint '{inference_endpoint}' is not responding. "
+                "Please ensure the URL is correct and the service is running."
+            )
+            raise ValueError(msg) from e
+
+        if response.status_code != requests.codes.ok:
+            msg = f"Hugging Face health check failed: {response.status_code}"
+            raise ValueError(msg)
+        # returning True to solve linting error
+        return True
+
+    def get_api_url(self) -> str:
+        if "huggingface" in self.inference_endpoint.lower():
+            return f"{self.inference_endpoint}"
+        return self.inference_endpoint
+
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
+    def create_huggingface_embeddings(
+        self, api_key: SecretStr, api_url: str, model_name: str
+    ) -> HuggingFaceInferenceAPIEmbeddings:
+        return HuggingFaceInferenceAPIEmbeddings(api_key=api_key, api_url=api_url, model_name=model_name)
+
+    def build_embeddings(self) -> Embeddings:
+        api_url = self.get_api_url()
+
+        is_local_url = (
+            api_url.startswith(("http://localhost", "http://127.0.0.1", "http://0.0.0.0", "http://docker"))
+            or "huggingface.co" not in api_url.lower()
+        )
+
+        if not self.api_key and is_local_url:
+            self.validate_inference_endpoint(api_url)
+            api_key = SecretStr("APIKeyForLocalDeployment")
+        elif not self.api_key:
+            msg = "API Key is required for non-local inference endpoints"
+            raise ValueError(msg)
+        else:
+            api_key = SecretStr(self.api_key).get_secret_value()
+
+        try:
+            return self.create_huggingface_embeddings(api_key, api_url, self.model_name)
+        except Exception as e:
+            msg = "Could not connect to Hugging Face Inference API."
+            raise ValueError(msg) from e

lfx/components/ibm/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.ibm.watsonx import WatsonxAIComponent
+    from lfx.components.ibm.watsonx_embeddings import WatsonxEmbeddingsComponent
+
+_dynamic_imports = {
+    "WatsonxAIComponent": "watsonx",
+    "WatsonxEmbeddingsComponent": "watsonx_embeddings",
+}
+
+__all__ = ["WatsonxAIComponent", "WatsonxEmbeddingsComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import ibm 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__)