lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

lfx/components/datastax/create_assistant.py

@@ -10,6 +10,7 @@ class AssistantsCreateAssistant(ComponentWithCache):
     icon = "AstraDB"
     display_name = "Create Assistant"
     description = "Creates an Assistant and returns it's id"
+    legacy = True
 
     inputs = [
         StrInput(

lfx/components/datastax/create_thread.py

@@ -9,6 +9,7 @@ class AssistantsCreateThread(ComponentWithCache):
     display_name = "Create Assistant Thread"
     description = "Creates a thread and returns the thread id"
     icon = "AstraDB"
+    legacy = True
     inputs = [
         MultilineInput(
             name="env_set",

lfx/components/datastax/dotenv.py

@@ -12,6 +12,7 @@ class Dotenv(Component):
     display_name = "Dotenv"
     description = "Load .env file into env vars"
     icon = "AstraDB"
+    legacy = True
     inputs = [
         MultilineSecretInput(
             name="dotenv_file_content",

lfx/components/datastax/get_assistant.py

@@ -9,6 +9,7 @@ class AssistantsGetAssistantName(ComponentWithCache):
     display_name = "Get Assistant name"
     description = "Assistant by id"
     icon = "AstraDB"
+    legacy = True
     inputs = [
         StrInput(
             name="assistant_id",

lfx/components/datastax/getenvvar.py

@@ -10,6 +10,7 @@ class GetEnvVar(Component):
     display_name = "Get Environment Variable"
     description = "Gets the value of an environment variable from the system."
     icon = "AstraDB"
+    legacy = True
 
     inputs = [
         StrInput(

lfx/components/datastax/graph_rag.py

@@ -44,7 +44,7 @@ class GraphRAGComponent(LCVectorStoreComponent):
 
     display_name: str = "Graph RAG"
     description: str = "Graph RAG traversal for vector store."
-    name = "Graph RAG"
+    name = "GraphRAG"
     icon: str = "AstraDB"
 
     inputs = [

lfx/components/datastax/list_assistants.py

@@ -8,6 +8,7 @@ class AssistantsListAssistants(ComponentWithCache):
     display_name = "List Assistants"
     description = "Returns a list of assistant id's"
     icon = "AstraDB"
+    legacy = True
     outputs = [
         Output(display_name="Assistants", name="assistants", method="process_inputs"),
     ]

lfx/components/datastax/run.py

@@ -14,6 +14,7 @@ class AssistantsRun(ComponentWithCache):
     display_name = "Run Assistant"
     description = "Executes an Assistant Run against a thread"
     icon = "AstraDB"
+    legacy = True
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)

lfx/components/docling/__init__.py

@@ -8,6 +8,7 @@ if TYPE_CHECKING:
     from .chunk_docling_document import ChunkDoclingDocumentComponent
     from .docling_inline import DoclingInlineComponent
     from .docling_remote import DoclingRemoteComponent
+    from .docling_remote_vlm import DoclingRemoteVLMComponent
     from .export_docling_document import ExportDoclingDocumentComponent
 
 _dynamic_imports = {
@@ -15,12 +16,14 @@ _dynamic_imports = {
     "DoclingInlineComponent": "docling_inline",
     "DoclingRemoteComponent": "docling_remote",
     "ExportDoclingDocumentComponent": "export_docling_document",
+    "DoclingRemoteVLMComponent": "docling_remote_vlm",
 }
 
 __all__ = [
     "ChunkDoclingDocumentComponent",
     "DoclingInlineComponent",
     "DoclingRemoteComponent",
+    "DoclingRemoteVLMComponent",
     "ExportDoclingDocumentComponent",
 ]
 

lfx/components/docling/docling_remote_vlm.py

@@ -0,0 +1,284 @@
+from typing import Any
+
+import requests
+from docling.datamodel.base_models import ConversionStatus, InputFormat
+from docling.datamodel.pipeline_options import (
+    ApiVlmOptions,
+    ResponseFormat,
+    VlmPipelineOptions,
+)
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.pipeline.vlm_pipeline import VlmPipeline
+from langflow.base.data import BaseFileComponent
+from langflow.inputs import DropdownInput, SecretStrInput, StrInput
+from langflow.schema import Data
+from langflow.schema.dotdict import dotdict
+
+from lfx.components.ibm.watsonx import WatsonxAIComponent
+from lfx.log.logger import logger
+
+
+class DoclingRemoteVLMComponent(BaseFileComponent):
+    display_name = "Docling Remote VLM"
+    description = (
+        "Uses Docling to process input documents running a VLM pipeline with a remote model"
+        "(OpenAI-compatible API or IBM Cloud)."
+    )
+    documentation = "https://docling-project.github.io/docling/examples/vlm_pipeline_api_model/"
+    trace_type = "tool"
+    icon = "Docling"
+    name = "DoclingRemoteVLM"
+
+    # https://docling-project.github.io/docling/usage/supported_formats/
+    VALID_EXTENSIONS = [
+        "adoc",
+        "asciidoc",
+        "asc",
+        "bmp",
+        "csv",
+        "dotx",
+        "dotm",
+        "docm",
+        "docx",
+        "htm",
+        "html",
+        "jpeg",
+        "json",
+        "md",
+        "pdf",
+        "png",
+        "potx",
+        "ppsx",
+        "pptm",
+        "potm",
+        "ppsm",
+        "pptx",
+        "tiff",
+        "txt",
+        "xls",
+        "xlsx",
+        "xhtml",
+        "xml",
+        "webp",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        DropdownInput(
+            name="provider",
+            display_name="Provider",
+            info="Select which remote VLM provider to use.",
+            options=["IBM Cloud", "OpenAI-Compatible"],
+            value="IBM Cloud",
+            real_time_refresh=True,
+        ),
+        # IBM Cloud inputs
+        SecretStrInput(
+            name="watsonx_api_key",
+            display_name="Watsonx API Key",
+            info="IBM Cloud API key used for authentication (leave blank to load from .env).",
+            required=False,
+        ),
+        StrInput(
+            name="watsonx_project_id",
+            display_name="Watsonx Project ID",
+            required=False,
+            info="The Watsonx project ID or deployment space ID associated with the model.",
+            value="",
+        ),
+        DropdownInput(
+            name="url",
+            display_name="Watsonx API Endpoint",
+            info="The base URL of the Watsonx API.",
+            options=[
+                "https://us-south.ml.cloud.ibm.com",
+                "https://eu-de.ml.cloud.ibm.com",
+                "https://eu-gb.ml.cloud.ibm.com",
+                "https://au-syd.ml.cloud.ibm.com",
+                "https://jp-tok.ml.cloud.ibm.com",
+                "https://ca-tor.ml.cloud.ibm.com",
+            ],
+            real_time_refresh=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=[],
+            value=None,
+            dynamic=True,
+            required=False,
+        ),
+        # OpenAI inputs
+        StrInput(
+            name="openai_base_url",
+            display_name="OpenAI-Compatible API Base URL",
+            info="Example: https://openrouter.ai/api/",
+            required=False,
+            show=False,
+        ),
+        SecretStrInput(
+            name="openai_api_key",
+            display_name="API Key",
+            info="API key for OpenAI-compatible endpoints (leave blank if not required).",
+            required=False,
+            show=False,
+        ),
+        StrInput(
+            name="openai_model",
+            display_name="OpenAI Model Name",
+            info="Model ID for OpenAI-compatible provider (e.g. gpt-4o-mini).",
+            required=False,
+            show=False,
+        ),
+        StrInput(name="vlm_prompt", display_name="Prompt", info="Prompt for VLM.", required=False),
+    ]
+
+    outputs = [*BaseFileComponent.get_base_outputs()]
+
+    @staticmethod
+    def fetch_models(base_url: str) -> list[str]:
+        """Fetch available models from the Watsonx.ai API."""
+        try:
+            endpoint = f"{base_url}/ml/v1/foundation_model_specs"
+            params = {"version": "2024-09-16", "filters": "function_text_chat,!lifecycle_withdrawn"}
+            response = requests.get(endpoint, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            models = [model["model_id"] for model in data.get("resources", [])]
+            return sorted(models)
+        except (requests.RequestException, requests.HTTPError, requests.Timeout, ConnectionError, ValueError):
+            logger.exception("Error fetching models. Using default models.")
+            return WatsonxAIComponent._default_models  # noqa: SLF001
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        """Update shown fields based on chosen provider."""
+        logger.info(f"update_build_config called: field_name={field_name}, field_value={field_value}")
+
+        if field_name == "provider":
+            provider_choice = field_value
+
+            if provider_choice == "IBM Cloud":
+                build_config.model_name.show = True
+                build_config.watsonx_api_key.show = True
+                build_config.watsonx_project_id.show = True
+                build_config.url.show = True
+
+                build_config.openai_base_url.show = False
+                build_config.openai_api_key.show = False
+                build_config.openai_model.show = False
+
+            elif provider_choice == "OpenAI-Compatible":
+                build_config.model_name.show = False
+                build_config.watsonx_api_key.show = False
+                build_config.watsonx_project_id.show = False
+                build_config.url.show = False
+
+                build_config.openai_base_url.show = True
+                build_config.openai_api_key.show = True
+                build_config.openai_model.show = True
+
+        if field_name == "url":
+            provider_value = build_config.provider.value if hasattr(build_config, "provider") else None
+            if provider_value == "IBM Cloud" and field_value:
+                models = self.fetch_models(base_url=field_value)
+                build_config.model_name.options = models
+                if models:
+                    build_config.model_name.value = models[0]
+                logger.info(f"Updated Watsonx model list: {len(models)} models found.")
+
+    def watsonx_vlm_options(self, model: str, prompt: str):
+        """Creates Docling ApiVlmOptions for a watsonx VLM."""
+        api_key = getattr(self, "watsonx_api_key", "")
+        project_id = getattr(self, "watsonx_project_id", "")
+        base_url = getattr(self, "url", "https://us-south.ml.cloud.ibm.com")
+
+        def _get_iam_access_token(api_key: str) -> str:
+            res = requests.post(
+                url="https://iam.cloud.ibm.com/identity/token",
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                data=f"grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey={api_key}",
+                timeout=90,
+            )
+            res.raise_for_status()
+            return res.json()["access_token"]
+
+        access_token = _get_iam_access_token(api_key)
+        return ApiVlmOptions(
+            url=f"{base_url}/ml/v1/text/chat?version=2023-05-29",
+            params={"model_id": model, "project_id": project_id, "parameters": {"max_new_tokens": 400}},
+            headers={"Authorization": f"Bearer {access_token}"},
+            prompt=prompt,
+            timeout=60,
+            response_format=ResponseFormat.MARKDOWN,
+        )
+
+    def openai_compatible_vlm_options(
+        self,
+        model: str,
+        prompt: str,
+        response_format: ResponseFormat,
+        url: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        api_key: str = "",
+        *,
+        skip_special_tokens: bool = False,
+    ):
+        """Create OpenAI-compatible Docling ApiVlmOptions options (e.g., LM Studio, vLLM, Ollama)."""
+        api_key = getattr(self, "openai_api_key", api_key)
+        model_override = getattr(self, "openai_model", model)
+
+        headers = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        return ApiVlmOptions(
+            url=f"{url}/v1/chat/completions",
+            params={"model": model_override, "max_tokens": max_tokens, "skip_special_tokens": skip_special_tokens},
+            headers=headers,
+            prompt=prompt,
+            timeout=90,
+            scale=2.0,
+            temperature=temperature,
+            response_format=response_format,
+        )
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        file_paths = [file.path for file in file_list if file.path]
+        if not file_paths:
+            logger.warning("No files to process.")
+            return file_list
+
+        provider = getattr(self, "provider", "IBM Cloud")
+        prompt = getattr(self, "vlm_prompt", "")
+
+        if provider == "IBM Cloud":
+            model = getattr(self, "model_name", "")
+            vlm_opts = self.watsonx_vlm_options(model=model, prompt=prompt)
+        else:
+            model = getattr(self, "openai_model", "") or getattr(self, "model_name", "")
+            base_url = getattr(self, "openai_base_url", "")
+            vlm_opts = self.openai_compatible_vlm_options(
+                model=model,
+                prompt=prompt,
+                response_format=ResponseFormat.MARKDOWN,
+                url=base_url,
+            )
+
+        pipeline_options = VlmPipelineOptions(enable_remote_services=True)
+        pipeline_options.vlm_options = vlm_opts
+
+        converter = DocumentConverter(
+            format_options={
+                InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options, pipeline_cls=VlmPipeline)
+            }
+        )
+
+        results = converter.convert_all(file_paths)
+        processed_data = [
+            Data(data={"doc": res.document, "file_path": str(res.input.file)})
+            if res.status == ConversionStatus.SUCCESS
+            else None
+            for res in results
+        ]
+        return self.rollup_data(file_list, processed_data)

lfx/components/ibm/watsonx.py

@@ -21,23 +21,24 @@ class WatsonxAIComponent(LCModelComponent):
     beta = False
 
     _default_models = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
-
+    _urls = [
+        "https://us-south.ml.cloud.ibm.com",
+        "https://eu-de.ml.cloud.ibm.com",
+        "https://eu-gb.ml.cloud.ibm.com",
+        "https://au-syd.ml.cloud.ibm.com",
+        "https://jp-tok.ml.cloud.ibm.com",
+        "https://ca-tor.ml.cloud.ibm.com",
+    ]
     inputs = [
         *LCModelComponent.get_base_inputs(),
         DropdownInput(
-            name="url",
+            name="base_url",
             display_name="watsonx API Endpoint",
             info="The base URL of the API.",
-            value=None,
-            options=[
-                "https://us-south.ml.cloud.ibm.com",
-                "https://eu-de.ml.cloud.ibm.com",
-                "https://eu-gb.ml.cloud.ibm.com",
-                "https://au-syd.ml.cloud.ibm.com",
-                "https://jp-tok.ml.cloud.ibm.com",
-                "https://ca-tor.ml.cloud.ibm.com",
-            ],
+            value=[],
+            options=_urls,
             real_time_refresh=True,
+            required=True,
         ),
         StrInput(
             name="project_id",
@@ -56,8 +57,9 @@ class WatsonxAIComponent(LCModelComponent):
             display_name="Model Name",
             options=[],
             value=None,
-            dynamic=True,
+            real_time_refresh=True,
             required=True,
+            refresh_button=True,
         ),
         IntInput(
             name="max_tokens",
@@ -155,18 +157,20 @@ class WatsonxAIComponent(LCModelComponent):
 
     def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
         """Update model options when URL or API key changes."""
-        logger.info("Updating build config. Field name: %s, Field value: %s", field_name, field_value)
-
-        if field_name == "url" and field_value:
+        if field_name == "base_url" and field_value:
             try:
-                models = self.fetch_models(base_url=build_config.url.value)
-                build_config.model_name.options = models
-                if build_config.model_name.value:
-                    build_config.model_name.value = models[0]
-                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
+                models = self.fetch_models(base_url=field_value)
+                build_config["model_name"]["options"] = models
+                if build_config["model_name"]["value"]:
+                    build_config["model_name"]["value"] = models[0]
+                info_message = f"Updated model options: {len(models)} models found in {field_value}"
                 logger.info(info_message)
             except Exception:  # noqa: BLE001
                 logger.exception("Error updating model options.")
+        if field_name == "model_name" and field_value and field_value in WatsonxAIComponent._urls:
+            build_config["model_name"]["options"] = self.fetch_models(base_url=field_value)
+            build_config["model_name"]["value"] = ""
+        return build_config
 
     def build_model(self) -> LanguageModel:
         # Parse logit_bias from JSON string if provided
@@ -195,7 +199,7 @@ class WatsonxAIComponent(LCModelComponent):
 
         return ChatWatsonx(
             apikey=SecretStr(self.api_key).get_secret_value(),
-            url=self.url,
+            url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,
             params=chat_params,

lfx/components/input_output/chat.py

@@ -60,6 +60,13 @@ class ChatInput(ChatComponent):
             info="The session ID of the chat. If empty, the current session ID parameter will be used.",
             advanced=True,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         FileInput(
             name="files",
             display_name="Files",
@@ -87,6 +94,7 @@ class ChatInput(ChatComponent):
             sender=self.sender,
             sender_name=self.sender_name,
             session_id=self.session_id,
+            context_id=self.context_id,
             files=files,
         )
         if self.session_id and isinstance(message, Message) and self.should_store_message:

lfx/components/input_output/chat_output.py

@@ -63,6 +63,13 @@ class ChatOutput(ChatComponent):
             info="The session ID of the chat. If empty, the current session ID parameter will be used.",
             advanced=True,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         MessageTextInput(
             name="data_template",
             display_name="Data Template",
@@ -121,6 +128,7 @@ class ChatOutput(ChatComponent):
         message.sender = self.sender
         message.sender_name = self.sender_name
         message.session_id = self.session_id
+        message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)
 

lfx/components/knowledge_bases/ingestion.py

@@ -48,12 +48,20 @@ HUGGINGFACE_MODEL_NAMES = [
 ]
 COHERE_MODEL_NAMES = ["embed-english-v3.0", "embed-multilingual-v3.0"]
 
-settings = get_settings_service().settings
-knowledge_directory = settings.knowledge_bases_dir
-if not knowledge_directory:
-    msg = "Knowledge bases directory is not set in the settings."
-    raise ValueError(msg)
-KNOWLEDGE_BASES_ROOT_PATH = Path(knowledge_directory).expanduser()
+_KNOWLEDGE_BASES_ROOT_PATH: Path | None = None
+
+
+def _get_knowledge_bases_root_path() -> Path:
+    """Lazy load the knowledge bases root path from settings."""
+    global _KNOWLEDGE_BASES_ROOT_PATH  # noqa: PLW0603
+    if _KNOWLEDGE_BASES_ROOT_PATH is None:
+        settings = get_settings_service().settings
+        knowledge_directory = settings.knowledge_bases_dir
+        if not knowledge_directory:
+            msg = "Knowledge bases directory is not set in the settings."
+            raise ValueError(msg)
+        _KNOWLEDGE_BASES_ROOT_PATH = Path(knowledge_directory).expanduser()
+    return _KNOWLEDGE_BASES_ROOT_PATH
 
 
 class KnowledgeIngestionComponent(Component):
@@ -203,7 +211,7 @@ class KnowledgeIngestionComponent(Component):
     # ------ Internal helpers ---------------------------------------------
     def _get_kb_root(self) -> Path:
         """Return the root directory for knowledge bases."""
-        return KNOWLEDGE_BASES_ROOT_PATH
+        return _get_knowledge_bases_root_path()
 
     def _validate_column_config(self, df_source: pd.DataFrame) -> list[dict[str, Any]]:
         """Validate column configuration using Structured Output patterns."""
@@ -662,7 +670,7 @@ class KnowledgeIngestionComponent(Component):
                     raise ValueError(msg) from e
 
                 # Create the new knowledge base directory
-                kb_path = KNOWLEDGE_BASES_ROOT_PATH / kb_user / field_value["01_new_kb_name"]
+                kb_path = _get_knowledge_bases_root_path() / kb_user / field_value["01_new_kb_name"]
                 kb_path.mkdir(parents=True, exist_ok=True)
 
                 # Save the embedding metadata
@@ -675,7 +683,7 @@ class KnowledgeIngestionComponent(Component):
 
             # Update the knowledge base options dynamically
             build_config["knowledge_base"]["options"] = await get_knowledge_bases(
-                KNOWLEDGE_BASES_ROOT_PATH,
+                _get_knowledge_bases_root_path(),
                 user_id=self.user_id,
             )
 

lfx/components/knowledge_bases/retrieval.py

@@ -16,12 +16,20 @@ from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.services.deps import get_settings_service, session_scope
 
-settings = get_settings_service().settings
-knowledge_directory = settings.knowledge_bases_dir
-if not knowledge_directory:
-    msg = "Knowledge bases directory is not set in the settings."
-    raise ValueError(msg)
-KNOWLEDGE_BASES_ROOT_PATH = Path(knowledge_directory).expanduser()
+_KNOWLEDGE_BASES_ROOT_PATH: Path | None = None
+
+
+def _get_knowledge_bases_root_path() -> Path:
+    """Lazy load the knowledge bases root path from settings."""
+    global _KNOWLEDGE_BASES_ROOT_PATH  # noqa: PLW0603
+    if _KNOWLEDGE_BASES_ROOT_PATH is None:
+        settings = get_settings_service().settings
+        knowledge_directory = settings.knowledge_bases_dir
+        if not knowledge_directory:
+            msg = "Knowledge bases directory is not set in the settings."
+            raise ValueError(msg)
+        _KNOWLEDGE_BASES_ROOT_PATH = Path(knowledge_directory).expanduser()
+    return _KNOWLEDGE_BASES_ROOT_PATH
 
 
 class KnowledgeRetrievalComponent(Component):
@@ -90,7 +98,7 @@ class KnowledgeRetrievalComponent(Component):
         if field_name == "knowledge_base":
             # Update the knowledge base options dynamically
             build_config["knowledge_base"]["options"] = await get_knowledge_bases(
-                KNOWLEDGE_BASES_ROOT_PATH,
+                _get_knowledge_bases_root_path(),
                 user_id=self.user_id,  # Use the user_id from the component context
             )
 
@@ -186,7 +194,7 @@ class KnowledgeRetrievalComponent(Component):
                 msg = f"User with ID {self.user_id} not found."
                 raise ValueError(msg)
             kb_user = current_user.username
-        kb_path = KNOWLEDGE_BASES_ROOT_PATH / kb_user / self.knowledge_base
+        kb_path = _get_knowledge_bases_root_path() / kb_user / self.knowledge_base
 
         metadata = self._get_kb_metadata(kb_path)
         if not metadata:

lfx/components/logic/loop.py

@@ -89,6 +89,10 @@ class LoopComponent(Component):
         item_dependency_id = self.get_incoming_edge_by_target_param("item")
         if item_dependency_id not in self.graph.run_manager.run_predecessors[self._id]:
             self.graph.run_manager.run_predecessors[self._id].append(item_dependency_id)
+            # CRITICAL: Also update run_map so remove_from_predecessors() works correctly
+            # run_map[predecessor] = list of vertices that depend on predecessor
+            if self._id not in self.graph.run_manager.run_map[item_dependency_id]:
+                self.graph.run_manager.run_map[item_dependency_id].append(self._id)
 
     def done_output(self) -> DataFrame:
         """Trigger the done output when iteration is complete."""

lfx/components/mistral/mistral_embeddings.py

@@ -1,4 +1,4 @@
-from langchain_mistralai.embeddings import MistralAIEmbeddings
+from langchain_mistralai import MistralAIEmbeddings
 from pydantic.v1 import SecretStr
 
 from lfx.base.models.model import LCModelComponent