lfx-nightly 0.2.0.dev26__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/components/vllm/vllm.py

@@ -0,0 +1,141 @@
+from typing import Any
+
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+
+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 BoolInput, DictInput, IntInput, SecretStrInput, SliderInput, StrInput
+from lfx.log.logger import logger
+
+
+class VllmComponent(LCModelComponent):
+    display_name = "vLLM"
+    description = "Generates text using vLLM models via OpenAI-compatible API."
+    icon = "vLLM"
+    name = "vLLMModel"
+
+    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,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        StrInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            info="The name of the vLLM model to use (e.g., 'ibm-granite/granite-3.3-8b-instruct').",
+            value="ibm-granite/granite-3.3-8b-instruct",
+        ),
+        StrInput(
+            name="api_base",
+            display_name="vLLM API Base",
+            advanced=False,
+            info="The base URL of the vLLM API server. Defaults to http://localhost:8000/v1 for local vLLM server.",
+            value="http://localhost:8000/v1",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="The API Key to use for the vLLM model (optional for local servers).",
+            advanced=False,
+            value="",
+            required=False,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            show=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="Controls the reproducibility of the job. Set to -1 to disable (some providers may not support).",
+            advanced=True,
+            value=-1,
+            required=False,
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            info="Max retries when generating. Set to -1 to disable (some providers may not support).",
+            advanced=True,
+            value=-1,
+            required=False,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="Timeout for requests to vLLM completion API. Set to -1 to disable (some providers may not support).",
+            advanced=True,
+            value=-1,
+            required=False,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        logger.debug(f"Executing request with vLLM model: {self.model_name}")
+        parameters = {
+            "api_key": SecretStr(self.api_key).get_secret_value() if self.api_key else None,
+            "model_name": self.model_name,
+            "max_tokens": self.max_tokens or None,
+            "model_kwargs": self.model_kwargs or {},
+            "base_url": self.api_base or "http://localhost:8000/v1",
+            "temperature": self.temperature if self.temperature is not None else 0.1,
+        }
+
+        # Only add optional parameters if explicitly set (not -1)
+        if self.seed is not None and self.seed != -1:
+            parameters["seed"] = self.seed
+        if self.timeout is not None and self.timeout != -1:
+            parameters["timeout"] = self.timeout
+        if self.max_retries is not None and self.max_retries != -1:
+            parameters["max_retries"] = self.max_retries
+
+        output = ChatOpenAI(**parameters)
+        if self.json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    def _get_exception_message(self, e: Exception):
+        """Get a message from a vLLM 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
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:  # noqa: ARG002
+        # vLLM models support all parameters, so no special handling needed
+        return build_config

lfx/components/vllm/vllm_embeddings.py

@@ -0,0 +1,110 @@
+from langchain_openai import OpenAIEmbeddings
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, DictInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+
+
+class VllmEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "vLLM Embeddings"
+    description = "Generate embeddings using vLLM models via OpenAI-compatible API."
+    icon = "vLLM"
+    name = "vLLMEmbeddings"
+
+    inputs = [
+        MessageTextInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            info="The name of the vLLM embeddings model to use (e.g., 'BAAI/bge-large-en-v1.5').",
+            value="BAAI/bge-large-en-v1.5",
+        ),
+        MessageTextInput(
+            name="api_base",
+            display_name="vLLM API Base",
+            advanced=False,
+            info="The base URL of the vLLM API server. Defaults to http://localhost:8000/v1 for local vLLM server.",
+            value="http://localhost:8000/v1",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="The API Key to use for the vLLM model (optional for local servers).",
+            advanced=False,
+            value="",
+            required=False,
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk Size",
+            advanced=True,
+            value=1000,
+            info="The chunk size to use when processing documents.",
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            value=3,
+            advanced=True,
+            info="Maximum number of retries for failed requests.",
+        ),
+        FloatInput(
+            name="request_timeout",
+            display_name="Request Timeout",
+            advanced=True,
+            info="Timeout for requests to vLLM API in seconds.",
+        ),
+        BoolInput(
+            name="show_progress_bar",
+            display_name="Show Progress Bar",
+            advanced=True,
+            info="Whether to show a progress bar when processing multiple documents.",
+        ),
+        BoolInput(
+            name="skip_empty",
+            display_name="Skip Empty",
+            advanced=True,
+            info="Whether to skip empty documents.",
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        DictInput(
+            name="default_headers",
+            display_name="Default Headers",
+            advanced=True,
+            info="Default headers to use for the API request.",
+        ),
+        DictInput(
+            name="default_query",
+            display_name="Default Query",
+            advanced=True,
+            info="Default query parameters to use for the API request.",
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return OpenAIEmbeddings(
+            model=self.model_name,
+            base_url=self.api_base or "http://localhost:8000/v1",
+            api_key=self.api_key or None,
+            dimensions=self.dimensions or None,
+            chunk_size=self.chunk_size,
+            max_retries=self.max_retries,
+            timeout=self.request_timeout or None,
+            show_progress_bar=self.show_progress_bar,
+            skip_empty=self.skip_empty,
+            model_kwargs=self.model_kwargs,
+            default_headers=self.default_headers or None,
+            default_query=self.default_query or None,
+        )

lfx/custom/custom_component/custom_component.py

@@ -456,24 +456,26 @@ class CustomComponent(BaseComponent):
         """Returns the variable for the current user with the specified name.
 
         Raises:
-            ValueError: If the user id is not set.
+            ValueError: If the user id is not set and variable not found in context.
 
         Returns:
             The variable for the current user with the specified name.
         """
-        if hasattr(self, "_user_id") and not self.user_id:
-            msg = f"User id is not set for {self.__class__.__name__}"
-            raise ValueError(msg)
-
         # Check graph context for request-level variable overrides first
+        # This allows run_flow to work without user_id when variables are passed
         if hasattr(self, "graph") and self.graph and hasattr(self.graph, "context"):
             context = self.graph.context
             if context and "request_variables" in context:
                 request_variables = context["request_variables"]
                 if name in request_variables:
-                    logger.debug(f"Found context override for variable '{name}': {request_variables[name]}")
+                    logger.debug(f"Found context override for variable '{name}'")
                     return request_variables[name]
 
+        # Only check user_id when we need to access the database
+        if hasattr(self, "_user_id") and not self.user_id:
+            msg = f"User id is not set for {self.__class__.__name__}"
+            raise ValueError(msg)
+
         variable_service = get_variable_service()  # Get service instance
         # Retrieve and decrypt the variable by name for the current user
         if isinstance(self.user_id, str):

lfx/custom/directory_reader/directory_reader.py

@@ -72,8 +72,11 @@ class DirectoryReader:
                     if component["error"] if with_errors else not component["error"]:
                         component_tuple = (*build_component(component), component)
                         components.append(component_tuple)
-                except Exception:  # noqa: BLE001
-                    logger.debug(f"Error while loading component {component['name']} from {component['file']}")
+                except Exception as exc:  # noqa: BLE001
+                    logger.debug(
+                        f"Skipping component {component['name']} from {component['file']} (load error)",
+                        exc_info=exc,
+                    )
                     continue
             items.append({"name": menu["name"], "path": menu["path"], "components": components})
         filtered = [menu for menu in items if menu["components"]]

lfx/graph/utils.py

@@ -143,35 +143,81 @@ async def log_vertex_build(
     flow_id: str | UUID,
     vertex_id: str,
     valid: bool,
-    params: Any,  # noqa: ARG001
-    data: dict | Any,  # noqa: ARG001
-    artifacts: dict | None = None,  # noqa: ARG001
+    params: Any,
+    data: dict | Any,
+    artifacts: dict | None = None,
 ) -> None:
     """Asynchronously logs a vertex build record if vertex build storage is enabled.
 
     This is a lightweight implementation that only logs if database service is available.
+    When running within langflow, it will use langflow's database service to persist the build.
+    When running standalone (lfx only), it will only log debug messages.
     """
     try:
-        settings_service = get_settings_service()
-        if not settings_service or not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
-            return
+        # Try to use langflow's services if available (when running within langflow)
+        try:
+            from langflow.services.deps import get_db_service as langflow_get_db_service
+            from langflow.services.deps import get_settings_service as langflow_get_settings_service
 
-        db_service = get_db_service()
-        if db_service is None:
-            logger.debug("Database service not available, skipping vertex build logging")
-            return
+            settings_service = langflow_get_settings_service()
+            if not settings_service:
+                return
+            if not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
+                return
 
-        try:
             if isinstance(flow_id, str):
                 flow_id = UUID(flow_id)
-        except ValueError:
-            logger.debug(f"Invalid flow_id passed to log_vertex_build: {flow_id!r}")
-            return
 
-        # Log basic vertex build info - concrete implementation should be in langflow
-        logger.debug(f"Vertex build logged: vertex={vertex_id}, flow={flow_id}, valid={valid}")
-    except Exception:  # noqa: BLE001
-        logger.debug("Error logging vertex build")
+            from langflow.services.database.models.vertex_builds.crud import (
+                log_vertex_build as crud_log_vertex_build,
+            )
+            from langflow.services.database.models.vertex_builds.model import VertexBuildBase
+
+            # Convert data to dict if it's a pydantic model
+            data_dict = data
+            if hasattr(data, "model_dump"):
+                data_dict = data.model_dump()
+            elif hasattr(data, "dict"):
+                data_dict = data.dict()
+
+            # Convert artifacts to dict if it's a pydantic model
+            artifacts_dict = artifacts
+            if artifacts is not None:
+                if hasattr(artifacts, "model_dump"):
+                    artifacts_dict = artifacts.model_dump()
+                elif hasattr(artifacts, "dict"):
+                    artifacts_dict = artifacts.dict()
+
+            vertex_build = VertexBuildBase(
+                flow_id=flow_id,
+                id=vertex_id,
+                valid=valid,
+                params=str(params) if params else None,
+                data=data_dict,
+                artifacts=artifacts_dict,
+            )
+
+            db_service = langflow_get_db_service()
+            if db_service is None:
+                return
+
+            async with db_service._with_session() as session:  # noqa: SLF001
+                await crud_log_vertex_build(session, vertex_build)
+
+        except ImportError:
+            # Fallback for standalone lfx usage (without langflow)
+            settings_service = get_settings_service()
+            if not settings_service or not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
+                return
+
+            if isinstance(flow_id, str):
+                flow_id = UUID(flow_id)
+
+            # Log basic vertex build info - concrete implementation is in langflow
+            logger.debug(f"Vertex build logged: vertex={vertex_id}, flow={flow_id}, valid={valid}")
+
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(f"Error logging vertex build: {exc}")
 
 
 def rewrite_file_path(file_path: str):

lfx/inputs/__init__.py

@@ -17,6 +17,7 @@ from .inputs import (
     McpInput,
     MessageInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     MultilineSecretInput,
     MultiselectInput,
@@ -52,6 +53,7 @@ __all__ = [
     "McpInput",
     "MessageInput",
     "MessageTextInput",
+    "ModelInput",
     "MultilineInput",
     "MultilineSecretInput",
     "MultiselectInput",

lfx/inputs/input_mixin.py

@@ -37,6 +37,7 @@ class FieldTypes(str, Enum):
     QUERY = "query"
     TOOLS = "tools"
     MCP = "mcp"
+    MODEL = "model"
 
 
 SerializableFieldTypes = Annotated[FieldTypes, PlainSerializer(lambda v: v.value, return_type=str)]
@@ -136,6 +137,59 @@ class BaseInputMixin(CrossModuleModel, validate_assignment=True):  # type: ignor
         return dump
 
 
+class ModelInputMixin(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    """Mixin for model input fields."""
+    model_name: str | None = None
+    """Name of the model to be used in the input."""
+    model_type: str | None = "language"
+    """Type of model: 'language' or 'embedding'. Defaults to 'language'."""
+    model_options: list[dict[str, Any]] | None = Field(
+        default=None,
+        validation_alias="options",
+        serialization_alias="options",
+    )
+    """List of model options with name, icon, category, provider, and metadata."""
+    temperature: float | None = None
+    """Temperature parameter for model generation."""
+    max_tokens: int | None = None
+    """Maximum tokens for model generation."""
+    limit: int | None = None
+    """Limit for the number of options to display."""
+    external_options: dict[str, Any] | None = None
+    """Dictionary of external options to display below the dropdown options (e.g., 'Connect other models')."""
+
+    @field_validator("model_options", mode="before")
+    @classmethod
+    def normalize_model_options(cls, v):
+        """Convert simple list of model names to list of dicts format.
+
+        Allows passing ['gpt-4o', 'gpt-4o-mini'] which gets converted to:
+        [{'name': 'gpt-4o', ...}, {'name': 'gpt-4o-mini', ...}]
+        """
+        if v is None or not isinstance(v, list):
+            return v
+
+        # If already in dict format, return as-is
+        if all(isinstance(item, dict) for item in v):
+            return v
+
+        # If it's a list of strings, convert to dict format
+        if all(isinstance(item, str) for item in v):
+            # Avoid circular import by importing the module directly (not through package __init__)
+            try:
+                from lfx.base.models.unified_models import normalize_model_names_to_dicts
+
+                return normalize_model_names_to_dicts(v)
+            except Exception:  # noqa: BLE001
+                # Fallback if import or normalization fails
+                # This can happen during module initialization or in test environments
+                return [{"name": item} for item in v]
+
+        # Mixed list or unexpected format, return as-is
+        return v
+
+
 class ToolModeMixin(BaseModel):
     tool_mode: bool = False
 

lfx/inputs/inputs.py

@@ -22,6 +22,7 @@ from .input_mixin import (
     LinkMixin,
     ListableInputMixin,
     MetadataTraceMixin,
+    ModelInputMixin,
     MultilineMixin,
     QueryMixin,
     RangeMixin,
@@ -123,6 +124,119 @@ class CodeInput(BaseInputMixin, ListableInputMixin, InputTraceMixin, ToolModeMix
     field_type: SerializableFieldTypes = FieldTypes.CODE
 
 
+class ModelInput(BaseInputMixin, ModelInputMixin, ListableInputMixin, InputTraceMixin, ToolModeMixin):
+    """Represents a model input field with optional LanguageModel connection support.
+
+    By default:
+    - input_types=[] (no handle shown)
+    - external_options with "Connect other models" button
+    - refresh_button=True
+
+    When "Connect other models" is selected (value="connect_other_models"):
+    - input_types is set to ["LanguageModel"] to show the connection handle
+
+    Value format:
+    - Can be a list of dicts: [{'name': 'gpt-4o', 'provider': 'OpenAI', ...}]
+    - Can be a simple list of strings: ['gpt-4o', 'gpt-4o-mini'] (auto-converted)
+    - Can be a single string: 'gpt-4o' (auto-converted to list)
+    - Can be "connect_other_models" string to enable connection mode
+    """
+
+    field_type: SerializableFieldTypes = FieldTypes.MODEL
+    placeholder: str | None = "Setup Provider"
+    input_types: list[str] = Field(default_factory=list)  # Empty by default, no handle shown
+    refresh_button: bool | None = True
+    external_options: dict = Field(
+        default_factory=lambda: {
+            "fields": {
+                "data": {
+                    "node": {
+                        "name": "connect_other_models",
+                        "display_name": "Connect other models",
+                        "icon": "CornerDownLeft",
+                    }
+                }
+            },
+        }
+    )
+
+    @field_validator("value", mode="before")
+    @classmethod
+    def normalize_value(cls, v):
+        """Convert simple string or list of strings to list of dicts format.
+
+        Allows passing:
+        - 'gpt-4o' -> [{'name': 'gpt-4o', ...}]
+        - ['gpt-4o', 'claude-3'] -> [{'name': 'gpt-4o', ...}, {'name': 'claude-3', ...}]
+        - [{'name': 'gpt-4o'}] -> [{'name': 'gpt-4o'}] (unchanged)
+        - 'connect_other_models' -> 'connect_other_models' (special value, keep as string)
+        """
+        # Handle empty or None values
+        if v is None or v == "":
+            return v
+
+        # Special case: keep "connect_other_models" as a string to enable connection mode
+        if v == "connect_other_models":
+            return v
+
+        # If it's not a list or string, return as-is (could be a BaseLanguageModel)
+        if not isinstance(v, list | str):
+            return v
+
+        # If it's a list and already in dict format, return as-is
+        if isinstance(v, list) and all(isinstance(item, dict) for item in v):
+            return v
+
+        # If it's a string or list of strings, convert to dict format
+        if isinstance(v, str) or (isinstance(v, list) and all(isinstance(item, str) for item in v)):
+            # Avoid circular import by importing the module directly (not through package __init__)
+            try:
+                from lfx.base.models.unified_models import normalize_model_names_to_dicts
+
+                return normalize_model_names_to_dicts(v)
+            except Exception:  # noqa: BLE001
+                # Fallback if import or normalization fails
+                # This can happen during module initialization or in test environments
+                if isinstance(v, str):
+                    return [{"name": v}]
+                return [{"name": item} for item in v]
+
+        # Return as-is for all other cases
+        return v
+
+    @model_validator(mode="after")
+    def set_defaults(self):
+        """Handle connection mode and set defaults.
+
+        When value is "connect_other_models", set input_types to ["LanguageModel"]
+        to enable the connection handle. Otherwise, keep input_types empty.
+        """
+        # Check if we're in connection mode (user selected "Connect other models")
+        if self.value == "connect_other_models" and not self.input_types:
+            # Enable connection handle by setting input_types
+            # Use object.__setattr__ to avoid triggering validation recursion
+            object.__setattr__(self, "input_types", ["LanguageModel"])
+
+        # Set external_options if not explicitly provided
+        if self.external_options is None or len(self.external_options) == 0:
+            object.__setattr__(
+                self,
+                "external_options",
+                {
+                    "fields": {
+                        "data": {
+                            "node": {
+                                "name": "connect_other_models",
+                                "display_name": "Connect other models",
+                                "icon": "CornerDownLeft",
+                            }
+                        }
+                    },
+                },
+            )
+        return self
+
+
 # Applying mixins to a specific input type
 class StrInput(
     BaseInputMixin,
@@ -687,6 +801,7 @@ InputTypes: TypeAlias = (
     | HandleInput
     | IntInput
     | McpInput
+    | ModelInput
     | MultilineInput
     | MultilineSecretInput
     | NestedDictInput