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

lfx/components/llm_operations/structured_output.py

@@ -0,0 +1,244 @@
+from pydantic import BaseModel, Field, create_model
+from trustcall import create_extractor
+
+from lfx.base.models.chat_result import get_chat_result
+from lfx.custom.custom_component.component import Component
+from lfx.helpers.base_model import build_model_from_schema
+from lfx.io import (
+    HandleInput,
+    MessageTextInput,
+    MultilineInput,
+    Output,
+    TableInput,
+)
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.table import EditMode
+
+
+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/structured-output"
+    name = "StructuredOutput"
+    icon = "braces"
+
+    inputs = [
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            info="The language model to use to generate the structured output.",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        MultilineInput(
+            name="input_value",
+            display_name="Input Message",
+            info="The input message to the language model.",
+            tool_mode=True,
+            required=True,
+        ),
+        MultilineInput(
+            name="system_prompt",
+            display_name="Format Instructions",
+            info="The instructions to the language model for formatting the output.",
+            value=(
+                "You are an AI that extracts structured JSON objects from unstructured text. "
+                "Use a predefined schema with expected types (str, int, float, bool, dict). "
+                "Extract ALL relevant instances that match the schema - if multiple patterns exist, capture them all. "
+                "Fill missing or ambiguous values with defaults: null for missing values. "
+                "Remove exact duplicates but keep variations that have different field values. "
+                "Always return valid JSON in the expected format, never throw errors. "
+                "If multiple objects can be extracted, return them all in the structured format."
+            ),
+            required=True,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="schema_name",
+            display_name="Schema Name",
+            info="Provide a name for the output data schema.",
+            advanced=True,
+        ),
+        TableInput(
+            name="output_schema",
+            display_name="Output Schema",
+            info="Define the structure and data types for the model's output.",
+            required=True,
+            # TODO: remove deault value
+            table_schema=[
+                {
+                    "name": "name",
+                    "display_name": "Name",
+                    "type": "str",
+                    "description": "Specify the name of the output field.",
+                    "default": "field",
+                    "edit_mode": EditMode.INLINE,
+                },
+                {
+                    "name": "description",
+                    "display_name": "Description",
+                    "type": "str",
+                    "description": "Describe the purpose of the output field.",
+                    "default": "description of field",
+                    "edit_mode": EditMode.POPOVER,
+                },
+                {
+                    "name": "type",
+                    "display_name": "Type",
+                    "type": "str",
+                    "edit_mode": EditMode.INLINE,
+                    "description": ("Indicate the data type of the output field (e.g., str, int, float, bool, dict)."),
+                    "options": ["str", "int", "float", "bool", "dict"],
+                    "default": "str",
+                },
+                {
+                    "name": "multiple",
+                    "display_name": "As List",
+                    "type": "boolean",
+                    "description": "Set to True if this output field should be a list of the specified type.",
+                    "default": "False",
+                    "edit_mode": EditMode.INLINE,
+                },
+            ],
+            value=[
+                {
+                    "name": "field",
+                    "description": "description of field",
+                    "type": "str",
+                    "multiple": "False",
+                }
+            ],
+        ),
+    ]
+
+    outputs = [
+        Output(
+            name="structured_output",
+            display_name="Structured Output",
+            method="build_structured_output",
+        ),
+        Output(
+            name="dataframe_output",
+            display_name="Structured Output",
+            method="build_structured_dataframe",
+        ),
+    ]
+
+    def build_structured_output_base(self):
+        schema_name = self.schema_name or "OutputModel"
+
+        if not hasattr(self.llm, "with_structured_output"):
+            msg = "Language model does not support structured output."
+            raise TypeError(msg)
+        if not self.output_schema:
+            msg = "Output schema cannot be empty"
+            raise ValueError(msg)
+
+        output_model_ = build_model_from_schema(self.output_schema)
+        output_model = create_model(
+            schema_name,
+            __doc__=f"A list of {schema_name}.",
+            objects=(
+                list[output_model_],
+                Field(
+                    description=f"A list of {schema_name}.",  # type: ignore[valid-type]
+                    min_length=1,  # help ensure non-empty output
+                ),
+            ),
+        )
+        # Tracing config
+        config_dict = {
+            "run_name": self.display_name,
+            "project_name": self.get_project_name(),
+            "callbacks": self.get_langchain_callbacks(),
+        }
+        # Generate structured output using Trustcall first, then fallback to Langchain if it fails
+        result = self._extract_output_with_trustcall(output_model, config_dict)
+        if result is None:
+            result = self._extract_output_with_langchain(output_model, config_dict)
+
+        # OPTIMIZATION NOTE: Simplified processing based on trustcall response structure
+        # Handle non-dict responses (shouldn't happen with trustcall, but defensive)
+        if not isinstance(result, dict):
+            return result
+
+        # Extract first response and convert BaseModel to dict
+        responses = result.get("responses", [])
+        if not responses:
+            return result
+
+        # Convert BaseModel to dict (creates the "objects" key)
+        first_response = responses[0]
+        structured_data = first_response
+        if isinstance(first_response, BaseModel):
+            structured_data = first_response.model_dump()
+        # Extract the objects array (guaranteed to exist due to our Pydantic model structure)
+        return structured_data.get("objects", structured_data)
+
+    def build_structured_output(self) -> Data:
+        output = self.build_structured_output_base()
+        if not isinstance(output, list) or not output:
+            # handle empty or unexpected type case
+            msg = "No structured output returned"
+            raise ValueError(msg)
+        if len(output) == 1:
+            return Data(data=output[0])
+        if len(output) > 1:
+            # Multiple outputs - wrap them in a results container
+            return Data(data={"results": output})
+        return Data()
+
+    def build_structured_dataframe(self) -> DataFrame:
+        output = self.build_structured_output_base()
+        if not isinstance(output, list) or not output:
+            # handle empty or unexpected type case
+            msg = "No structured output returned"
+            raise ValueError(msg)
+        if len(output) == 1:
+            # For single dictionary, wrap in a list to create DataFrame with one row
+            return DataFrame([output[0]])
+        if len(output) > 1:
+            # Multiple outputs - convert to DataFrame directly
+            return DataFrame(output)
+        return DataFrame()
+
+    def _extract_output_with_trustcall(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = create_extractor(self.llm, tools=[schema], tool_choice=schema.__name__)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.warning(
+                f"Trustcall extraction failed, falling back to Langchain: {e} "
+                "(Note: This may not be an error—some models or configurations do not support tool calling. "
+                "Falling back is normal in such cases.)"
+            )
+            return None
+        return result or None  # langchain fallback is used if error occurs or the result is empty
+
+    def _extract_output_with_langchain(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = self.llm.with_structured_output(schema)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+            if isinstance(result, BaseModel):
+                result = result.model_dump()
+                result = result.get("objects", result)
+        except Exception as fallback_error:
+            msg = (
+                f"Model does not support tool calling (trustcall failed) "
+                f"and fallback with_structured_output also failed: {fallback_error}"
+            )
+            raise ValueError(msg) from fallback_error
+
+        return result or None

lfx/components/lmstudio/__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.lmstudio.lmstudioembeddings import LMStudioEmbeddingsComponent
+    from lfx.components.lmstudio.lmstudiomodel import LMStudioModelComponent
+
+_dynamic_imports = {
+    "LMStudioEmbeddingsComponent": "lmstudioembeddings",
+    "LMStudioModelComponent": "lmstudiomodel",
+}
+
+__all__ = ["LMStudioEmbeddingsComponent", "LMStudioModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import lmstudio 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/lmstudio/lmstudioembeddings.py

@@ -0,0 +1,89 @@
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.inputs.inputs import DropdownInput, SecretStrInput
+from lfx.io import FloatInput, MessageTextInput
+
+
+class LMStudioEmbeddingsComponent(LCEmbeddingsModel):
+    display_name: str = "LM Studio Embeddings"
+    description: str = "Generate embeddings using LM Studio."
+    icon = "LMStudio"
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):  # noqa: ARG002
+        if field_name == "model":
+            base_url_dict = build_config.get("base_url", {})
+            base_url_load_from_db = base_url_dict.get("load_from_db", False)
+            base_url_value = base_url_dict.get("value")
+            if base_url_load_from_db:
+                base_url_value = await self.get_variables(base_url_value, field_name)
+            elif not base_url_value:
+                base_url_value = "http://localhost:1234/v1"
+            build_config["model"]["options"] = await self.get_model(base_url_value)
+
+        return build_config
+
+    @staticmethod
+    async def get_model(base_url_value: str) -> list[str]:
+        try:
+            url = urljoin(base_url_value, "/v1/models")
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()
+                data = response.json()
+
+                return [model["id"] for model in data.get("data", [])]
+        except Exception as e:
+            msg = "Could not retrieve models. Please, make sure the LM Studio server is running."
+            raise ValueError(msg) from e
+
+    inputs = [
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            advanced=False,
+            refresh_button=True,
+            required=True,
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="LM Studio Base URL",
+            refresh_button=True,
+            value="http://localhost:1234/v1",
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="LM Studio API Key",
+            advanced=True,
+            value="LMSTUDIO_API_KEY",
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Model Temperature",
+            value=0.1,
+            advanced=True,
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
+        except ImportError as e:
+            msg = "Please install langchain-nvidia-ai-endpoints to use LM Studio Embeddings."
+            raise ImportError(msg) from e
+        try:
+            output = NVIDIAEmbeddings(
+                model=self.model,
+                base_url=self.base_url,
+                temperature=self.temperature,
+                nvidia_api_key=self.api_key,
+            )
+        except Exception as e:
+            msg = f"Could not connect to LM Studio API. Error: {e}"
+            raise ValueError(msg) from e
+        return output

lfx/components/lmstudio/lmstudiomodel.py

@@ -0,0 +1,133 @@
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+from langchain_openai import ChatOpenAI
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import DictInput, DropdownInput, FloatInput, IntInput, SecretStrInput, StrInput
+
+
+class LMStudioModelComponent(LCModelComponent):
+    display_name = "LM Studio"
+    description = "Generate text using LM Studio Local LLMs."
+    icon = "LMStudio"
+    name = "LMStudioModel"
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):  # noqa: ARG002
+        if field_name == "model_name":
+            base_url_dict = build_config.get("base_url", {})
+            base_url_load_from_db = base_url_dict.get("load_from_db", False)
+            base_url_value = base_url_dict.get("value")
+            if base_url_load_from_db:
+                base_url_value = await self.get_variables(base_url_value, field_name)
+            try:
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(urljoin(base_url_value, "/v1/models"), timeout=2.0)
+                    response.raise_for_status()
+            except httpx.HTTPError:
+                msg = "Could not access the default LM Studio URL. Please, specify the 'Base URL' field."
+                self.log(msg)
+                return build_config
+            build_config["model_name"]["options"] = await self.get_model(base_url_value)
+
+        return build_config
+
+    @staticmethod
+    async def get_model(base_url_value: str) -> list[str]:
+        try:
+            url = urljoin(base_url_value, "/v1/models")
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()
+                data = response.json()
+
+                return [model["id"] for model in data.get("data", [])]
+        except Exception as e:
+            msg = "Could not retrieve models. Please, make sure the LM Studio server is running."
+            raise ValueError(msg) from e
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(name="model_kwargs", display_name="Model Kwargs", advanced=True),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            refresh_button=True,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Base URL",
+            advanced=False,
+            info="Endpoint of the LM Studio API. Defaults to 'http://localhost:1234/v1' if not specified.",
+            value="http://localhost:1234/v1",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="LM Studio API Key",
+            info="The LM Studio API Key to use for LM Studio.",
+            advanced=True,
+            value="LMSTUDIO_API_KEY",
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        lmstudio_api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        model_kwargs = self.model_kwargs or {}
+        base_url = self.base_url or "http://localhost:1234/v1"
+        seed = self.seed
+
+        return ChatOpenAI(
+            max_tokens=max_tokens or None,
+            model_kwargs=model_kwargs,
+            model=model_name,
+            base_url=base_url,
+            api_key=lmstudio_api_key,
+            temperature=temperature if temperature is not None else 0.1,
+            seed=seed,
+        )
+
+    def _get_exception_message(self, e: Exception):
+        """Get a message from an LM Studio exception.
+
+        Args:
+            e (Exception): The exception to get the message from.
+
+        Returns:
+            str: The message from the exception.
+        """
+        try:
+            from openai import BadRequestError
+        except ImportError:
+            return None
+        if isinstance(e, BadRequestError):
+            message = e.body.get("message")
+            if message:
+                return message
+        return None

lfx/components/logic/__init__.py

@@ -0,0 +1,181 @@
+"""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
+
+if TYPE_CHECKING:
+    from lfx.components.logic.conditional_router import ConditionalRouterComponent
+    from lfx.components.logic.data_conditional_router import DataConditionalRouterComponent
+    from lfx.components.logic.flow_tool import FlowToolComponent
+    from lfx.components.logic.llm_conditional_router import SmartRouterComponent
+    from lfx.components.logic.loop import LoopComponent
+    from lfx.components.logic.pass_message import PassMessageComponent
+    from lfx.components.logic.run_flow import RunFlowComponent
+    from lfx.components.logic.sub_flow import SubFlowComponent
+
+_dynamic_imports = {
+    "ConditionalRouterComponent": "conditional_router",
+    "DataConditionalRouterComponent": "data_conditional_router",
+    "FlowToolComponent": "flow_tool",
+    "LoopComponent": "loop",
+    "PassMessageComponent": "pass_message",
+    "RunFlowComponent": "run_flow",
+    "SmartRouterComponent": "llm_conditional_router",
+    "SubFlowComponent": "sub_flow",
+}
+
+__all__ = [
+    "ConditionalRouterComponent",
+    "DataConditionalRouterComponent",
+    "FlowToolComponent",
+    "LoopComponent",
+    "PassMessageComponent",
+    "RunFlowComponent",
+    "SmartRouterComponent",
+    "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:
+        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__)