lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.3.0.dev3__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/component.py

@@ -1565,7 +1565,24 @@ class Component(CustomComponent):
         return has_chat_input(self.graph.get_vertex_neighbors(self._vertex))
 
     def _should_skip_message(self, message: Message) -> bool:
-        """Check if the message should be skipped based on vertex configuration and message type."""
+        """Check if the message should be skipped based on vertex configuration and message type.
+
+        When a message is skipped:
+        - It is NOT stored in the database
+        - It will NOT have an ID (message.get_id() will return None)
+        - It is still returned to the caller, but no events are sent to the frontend
+
+        Messages are skipped when:
+        - The component is not an input or output vertex
+        - The component is not connected to a Chat Output
+        - The message is not an ErrorMessage
+
+        This prevents intermediate components from cluttering the database with messages
+        that aren't meant to be displayed in the chat UI.
+
+        Returns:
+            bool: True if the message should be skipped, False otherwise
+        """
         return (
             self._vertex is not None
             and not (self._vertex.is_output or self._vertex.is_input)
@@ -1603,12 +1620,31 @@ class Component(CustomComponent):
     async def send_message(self, message: Message, id_: str | None = None, *, skip_db_update: bool = False):
         """Send a message with optional database update control.
 
+        This is the central method for sending messages in Langflow. It handles:
+        - Message storage in the database (unless skipped)
+        - Event emission to the frontend
+        - Streaming support
+        - Error handling and cleanup
+
+        Message ID Rules:
+        - Messages only have an ID after being stored in the database
+        - If _should_skip_message() returns True, the message is not stored and will not have an ID
+        - Always use message.get_id() or message.has_id() to safely check for ID existence
+        - Never access message.id directly without checking if it exists first
+
         Args:
             message: The message to send
-            id_: Optional message ID
+            id_: Optional message ID (used for event emission, not database storage)
             skip_db_update: If True, only update in-memory and send event, skip DB write.
                            Useful during streaming to avoid excessive DB round-trips.
-                           Note: This assumes the message already exists in the database with message.id set.
+                           Note: When skip_db_update=True, the message must already have an ID
+                           (i.e., it must have been stored previously).
+
+        Returns:
+            Message: The stored message (with ID if stored in database, without ID if skipped)
+
+        Raises:
+            ValueError: If skip_db_update=True but message doesn't have an ID
         """
         if self._should_skip_message(message):
             return message
@@ -1621,10 +1657,18 @@ class Component(CustomComponent):
 
         # If skip_db_update is True and message already has an ID, skip the DB write
         # This path is used during agent streaming to avoid excessive DB round-trips
-        if skip_db_update and message.id:
+        # When skip_db_update=True, we require the message to already have an ID
+        # because we're updating an existing message, not creating a new one
+        if skip_db_update:
+            if not message.has_id():
+                msg = (
+                    "skip_db_update=True requires the message to already have an ID. "
+                    "The message must have been stored in the database previously."
+                )
+                raise ValueError(msg)
             # Create a fresh Message instance for consistency with normal flow
             stored_message = await Message.create(**message.model_dump())
-            self._stored_message_id = stored_message.id
+            self._stored_message_id = stored_message.get_id()
             # Still send the event to update the client in real-time
             # Note: If this fails, we don't need DB cleanup since we didn't write to DB
             await self._send_message_event(stored_message, id_=id_)
@@ -1632,7 +1676,9 @@ class Component(CustomComponent):
             # Normal flow: store/update in database
             stored_message = await self._store_message(message)
 
-            self._stored_message_id = stored_message.id
+            # After _store_message, the message should always have an ID
+            # but we use get_id() for safety
+            self._stored_message_id = stored_message.get_id()
             try:
                 complete_message = ""
                 if (
@@ -1653,7 +1699,10 @@ class Component(CustomComponent):
                     await self._send_message_event(stored_message, id_=id_)
             except Exception:
                 # remove the message from the database
-                await delete_message(stored_message.id)
+                # Only delete if the message has an ID
+                message_id = stored_message.get_id()
+                if message_id:
+                    await delete_message(id_=message_id)
                 raise
         self.status = stored_message
         return stored_message
@@ -1699,7 +1748,7 @@ class Component(CustomComponent):
         return bool(
             hasattr(self, "_event_manager")
             and self._event_manager
-            and stored_message.id
+            and stored_message.has_id()
             and not isinstance(original_message.text, str)
         )
 
@@ -1726,14 +1775,20 @@ class Component(CustomComponent):
             msg = "The message must be an iterator or an async iterator."
             raise TypeError(msg)
 
+        # Get message ID safely - streaming requires an ID
+        message_id = message.get_id()
+        if not message_id:
+            msg = "Message must have an ID to stream. Messages only have IDs after being stored in the database."
+            raise ValueError(msg)
+
         if isinstance(iterator, AsyncIterator):
-            return await self._handle_async_iterator(iterator, message.id, message)
+            return await self._handle_async_iterator(iterator, message_id, message)
         try:
             complete_message = ""
             first_chunk = True
             for chunk in iterator:
                 complete_message = await self._process_chunk(
-                    chunk.content, complete_message, message.id, message, first_chunk=first_chunk
+                    chunk.content, complete_message, message_id, message, first_chunk=first_chunk
                 )
                 first_chunk = False
         except Exception as e:

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/events/observability/lifecycle_events.py

@@ -0,0 +1,111 @@
+import functools
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from ag_ui.encoder.encoder import EventEncoder
+
+from lfx.log.logger import logger
+
+AsyncMethod = Callable[..., Awaitable[Any]]
+
+encoder: EventEncoder = EventEncoder()
+
+
+def observable(observed_method: AsyncMethod) -> AsyncMethod:
+    """Decorator to make an async method observable by emitting lifecycle events.
+
+    Decorated classes are expected to implement specific methods to emit AGUI events:
+    - `before_callback_event(*args, **kwargs)`: Called before the decorated method executes.
+      It should return a dictionary representing the event payload.
+    - `after_callback_event(result, *args, **kwargs)`: Called after the decorated method
+      successfully completes. It should return a dictionary representing the event payload.
+      The `result` of the decorated method is passed as the first argument.
+    - `error_callback_event(exception, *args, **kwargs)`: (Optional) Called if the decorated
+      method raises an exception. It should return a dictionary representing the error event payload.
+      The `exception` is passed as the first argument.
+
+    If these methods are implemented, the decorator will call them to generate event payloads.
+    If an implementation is missing, the corresponding event publishing will be skipped without error.
+
+    Payloads returned by these methods can include custom metrics by placing them
+    under the 'langflow' key within the 'raw_events' dictionary.
+
+    Example:
+        class MyClass:
+            display_name = "My Observable Class"
+
+            def before_callback_event(self, *args, **kwargs):
+                return {"event_name": "my_method_started", "data": {"input_args": args}}
+
+            async def my_method(self, event_manager: EventManager, data: str):
+                # ... method logic ...
+                return "processed_data"
+
+            def after_callback_event(self, result, *args, **kwargs):
+                return {"event_name": "my_method_completed", "data": {"output": result}}
+
+            def error_callback_event(self, exception, *args, **kwargs):
+                return {"event_name": "my_method_failed", "error": str(exception)}
+
+        @observable
+        async def my_observable_method(self, event_manager: EventManager, data: str):
+            # ... method logic ...
+            pass
+    """
+
+    async def check_event_manager(self, **kwargs):
+        if "event_manager" not in kwargs or kwargs["event_manager"] is None:
+            await logger.awarning(
+                f"EventManager not available/provided, skipping observable event publishing "
+                f"from {self.__class__.__name__}"
+            )
+            return False
+        return True
+
+    async def before_callback(self, *args, **kwargs):
+        if not await check_event_manager(self, **kwargs):
+            return
+
+        if hasattr(self, "before_callback_event"):
+            event_payload = self.before_callback_event(*args, **kwargs)
+            event_payload = encoder.encode(event_payload)
+            # TODO: Publish event per request, would required context based queues
+        else:
+            await logger.awarning(
+                f"before_callback_event not implemented for {self.__class__.__name__}. Skipping event publishing."
+            )
+
+    async def after_callback(self, res: Any | None = None, *args, **kwargs):
+        if not await check_event_manager(self, **kwargs):
+            return
+        if hasattr(self, "after_callback_event"):
+            event_payload = self.after_callback_event(res, *args, **kwargs)
+            event_payload = encoder.encode(event_payload)
+            # TODO: Publish event per request, would required context based queues
+        else:
+            await logger.awarning(
+                f"after_callback_event not implemented for {self.__class__.__name__}. Skipping event publishing."
+            )
+
+    @functools.wraps(observed_method)
+    async def wrapper(self, *args, **kwargs):
+        await before_callback(self, *args, **kwargs)
+        result = None
+        try:
+            result = await observed_method(self, *args, **kwargs)
+            await after_callback(self, result, *args, **kwargs)
+        except Exception as e:
+            await logger.aerror(f"Exception in {self.__class__.__name__}: {e}")
+            if hasattr(self, "error_callback_event"):
+                try:
+                    event_payload = self.error_callback_event(e, *args, **kwargs)
+                    event_payload = encoder.encode(event_payload)
+                    # TODO: Publish event per request, would required context based queues
+                except Exception as callback_e:  # noqa: BLE001
+                    await logger.aerror(
+                        f"Exception during error_callback_event for {self.__class__.__name__}: {callback_e}"
+                    )
+            raise
+        return result
+
+    return wrapper

lfx/field_typing/__init__.py

@@ -1,63 +1,6 @@
 from typing import Any
 
-from .constants import (
-    AgentExecutor,
-    BaseChatMemory,
-    BaseChatModel,
-    BaseDocumentCompressor,
-    BaseLanguageModel,
-    BaseLLM,
-    BaseLoader,
-    BaseMemory,
-    BaseOutputParser,
-    BasePromptTemplate,
-    BaseRetriever,
-    Callable,
-    Chain,
-    ChatPromptTemplate,
-    Code,
-    Data,
-    Document,
-    Embeddings,
-    LanguageModel,
-    NestedDict,
-    Object,
-    PromptTemplate,
-    Retriever,
-    Text,
-    TextSplitter,
-    Tool,
-    VectorStore,
-)
-from .range_spec import RangeSpec
-
-
-def _import_input_class():
-    from lfx.template.field.base import Input
-
-    return Input
-
-
-def _import_output_class():
-    from lfx.template.field.base import Output
-
-    return Output
-
-
-def __getattr__(name: str) -> Any:
-    # This is to avoid circular imports
-    if name == "Input":
-        return _import_input_class()
-    if name == "Output":
-        return _import_output_class()
-    if name == "RangeSpec":
-        return RangeSpec
-    # The other names should work as if they were imported from constants
-    # Import the constants module langflow.field_typing.constants
-    from . import constants
-
-    return getattr(constants, name)
-
+# Lazy imports - nothing imported at module level except __all__
 
 __all__ = [
     "AgentExecutor",
@@ -78,9 +21,11 @@ __all__ = [
     "Data",
     "Document",
     "Embeddings",
+    "Input",
     "LanguageModel",
     "NestedDict",
     "Object",
+    "Output",
     "PromptTemplate",
     "RangeSpec",
     "Retriever",
@@ -89,3 +34,57 @@ __all__ = [
     "Tool",
     "VectorStore",
 ]
+
+# Names that come from constants module
+_CONSTANTS_NAMES = {
+    "AgentExecutor",
+    "BaseChatMemory",
+    "BaseChatModel",
+    "BaseDocumentCompressor",
+    "BaseLLM",
+    "BaseLanguageModel",
+    "BaseLoader",
+    "BaseMemory",
+    "BaseOutputParser",
+    "BasePromptTemplate",
+    "BaseRetriever",
+    "Callable",
+    "Chain",
+    "ChatPromptTemplate",
+    "Code",
+    "Data",
+    "Document",
+    "Embeddings",
+    "LanguageModel",
+    "NestedDict",
+    "Object",
+    "PromptTemplate",
+    "Retriever",
+    "Text",
+    "TextSplitter",
+    "Tool",
+    "VectorStore",
+}
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy import for all field typing constants."""
+    if name == "Input":
+        from lfx.template.field.base import Input
+
+        return Input
+    if name == "Output":
+        from lfx.template.field.base import Output
+
+        return Output
+    if name == "RangeSpec":
+        from .range_spec import RangeSpec
+
+        return RangeSpec
+    if name in _CONSTANTS_NAMES:
+        from . import constants
+
+        return getattr(constants, name)
+
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)