lfx-nightly 0.1.12.dev14__py3-none-any.whl → 0.1.12.dev16__py3-none-any.whl

lfx/components/amazon/amazon_bedrock_converse.py

@@ -0,0 +1,196 @@
+from langflow.base.models.aws_constants import AWS_REGIONS, AWS_MODEL_IDs
+from langflow.base.models.model import LCModelComponent
+from langflow.field_typing import LanguageModel
+from langflow.inputs.inputs import BoolInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.io import DictInput, DropdownInput
+
+
+class AmazonBedrockConverseComponent(LCModelComponent):
+    display_name: str = "Amazon Bedrock Converse"
+    description: str = (
+        "Generate text using Amazon Bedrock LLMs with the modern Converse API "
+        "for improved conversation handling. We recommend the Converse API for users "
+        "who do not need to use custom models. It can be accessed using ChatBedrockConverse."
+    )
+    icon = "Amazon"
+    name = "AmazonBedrockConverseModel"
+    beta = True
+
+    inputs = [
+        *LCModelComponent._base_inputs,
+        DropdownInput(
+            name="model_id",
+            display_name="Model ID",
+            options=AWS_MODEL_IDs,
+            value="anthropic.claude-3-5-sonnet-20241022-v2:0",
+            info="List of available model IDs to choose from.",
+        ),
+        SecretStrInput(
+            name="aws_access_key_id",
+            display_name="AWS Access Key ID",
+            info="The access key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_ACCESS_KEY_ID'.",
+            value="AWS_ACCESS_KEY_ID",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_secret_access_key",
+            display_name="AWS Secret Access Key",
+            info="The secret key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_SECRET_ACCESS_KEY'.",
+            value="AWS_SECRET_ACCESS_KEY",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_session_token",
+            display_name="AWS Session Token",
+            advanced=True,
+            info="The session key for your AWS account. "
+            "Only needed for temporary credentials. "
+            "Usually set in Python code as the environment variable 'AWS_SESSION_TOKEN'.",
+            load_from_db=False,
+        ),
+        SecretStrInput(
+            name="credentials_profile_name",
+            display_name="Credentials Profile Name",
+            advanced=True,
+            info="The name of the profile to use from your "
+            "~/.aws/credentials file. "
+            "If not provided, the default profile will be used.",
+            load_from_db=False,
+        ),
+        DropdownInput(
+            name="region_name",
+            display_name="Region Name",
+            value="us-east-1",
+            options=AWS_REGIONS,
+            info="The AWS region where your Bedrock resources are located.",
+        ),
+        MessageTextInput(
+            name="endpoint_url",
+            display_name="Endpoint URL",
+            advanced=True,
+            info="The URL of the Bedrock endpoint to use.",
+        ),
+        # Model-specific parameters for fine control
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.7,
+            info="Controls randomness in output. Higher values make output more random.",
+            advanced=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            value=4096,
+            info="Maximum number of tokens to generate.",
+            advanced=True,
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            value=0.9,
+            info="Nucleus sampling parameter. Controls diversity of output.",
+            advanced=True,
+        ),
+        IntInput(
+            name="top_k",
+            display_name="Top K",
+            value=250,
+            info="Limits the number of highest probability vocabulary tokens to consider. "
+            "Note: Not all models support top_k. Use 'Additional Model Fields' for manual configuration if needed.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="disable_streaming",
+            display_name="Disable Streaming",
+            value=False,
+            info="If True, disables streaming responses. Useful for batch processing.",
+            advanced=True,
+        ),
+        DictInput(
+            name="additional_model_fields",
+            display_name="Additional Model Fields",
+            advanced=True,
+            is_list=True,
+            info="Additional model-specific parameters for fine-tuning behavior.",
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_aws.chat_models.bedrock_converse import ChatBedrockConverse
+        except ImportError as e:
+            msg = "langchain_aws is not installed. Please install it with `pip install langchain_aws`."
+            raise ImportError(msg) from e
+
+        # Prepare initialization parameters
+        init_params = {
+            "model": self.model_id,
+            "region_name": self.region_name,
+        }
+
+        # Add AWS credentials if provided
+        if self.aws_access_key_id:
+            init_params["aws_access_key_id"] = self.aws_access_key_id
+        if self.aws_secret_access_key:
+            init_params["aws_secret_access_key"] = self.aws_secret_access_key
+        if self.aws_session_token:
+            init_params["aws_session_token"] = self.aws_session_token
+        if self.credentials_profile_name:
+            init_params["credentials_profile_name"] = self.credentials_profile_name
+        if self.endpoint_url:
+            init_params["endpoint_url"] = self.endpoint_url
+
+        # Add model parameters directly as supported by ChatBedrockConverse
+        if hasattr(self, "temperature") and self.temperature is not None:
+            init_params["temperature"] = self.temperature
+        if hasattr(self, "max_tokens") and self.max_tokens is not None:
+            init_params["max_tokens"] = self.max_tokens
+        if hasattr(self, "top_p") and self.top_p is not None:
+            init_params["top_p"] = self.top_p
+
+        # Handle streaming - only disable if explicitly requested
+        if hasattr(self, "disable_streaming") and self.disable_streaming:
+            init_params["disable_streaming"] = True
+
+        # Handle additional model request fields carefully
+        # Based on the error, inferenceConfig should not be passed as additional fields for some models
+        additional_model_request_fields = {}
+
+        # Only add top_k if user explicitly provided additional fields or if needed for specific models
+        if hasattr(self, "additional_model_fields") and self.additional_model_fields:
+            for field in self.additional_model_fields:
+                if isinstance(field, dict):
+                    additional_model_request_fields.update(field)
+
+        # For now, don't automatically add inferenceConfig for top_k to avoid validation errors
+        # Users can manually add it via additional_model_fields if their model supports it
+
+        # Only add if we have actual additional fields
+        if additional_model_request_fields:
+            init_params["additional_model_request_fields"] = additional_model_request_fields
+
+        try:
+            output = ChatBedrockConverse(**init_params)
+        except Exception as e:
+            # Provide helpful error message with fallback suggestions
+            error_details = str(e)
+            if "validation error" in error_details.lower():
+                msg = (
+                    f"ChatBedrockConverse validation error: {error_details}. "
+                    f"This may be due to incompatible parameters for model '{self.model_id}'. "
+                    f"Consider adjusting the model parameters or trying the legacy Amazon Bedrock component."
+                )
+            elif "converse api" in error_details.lower():
+                msg = (
+                    f"Converse API error: {error_details}. "
+                    f"The model '{self.model_id}' may not support the Converse API. "
+                    f"Try using the legacy Amazon Bedrock component instead."
+                )
+            else:
+                msg = f"Could not initialize ChatBedrockConverse: {error_details}"
+            raise ValueError(msg) from e
+
+        return output

lfx/components/amazon/amazon_bedrock_model.py

@@ -7,7 +7,11 @@ from lfx.io import DictInput, DropdownInput
 
 class AmazonBedrockComponent(LCModelComponent):
     display_name: str = "Amazon Bedrock"
-    description: str = "Generate text using Amazon Bedrock LLMs."
+    description: str = (
+        "Generate text using Amazon Bedrock LLMs with the legacy ChatBedrock API. "
+        "For better compatibility, newer features, and improved conversation handling, "
+        "we recommend using Amazon Bedrock Converse instead."
+    )
     icon = "Amazon"
     name = "AmazonBedrockModel"
 

lfx/components/azure/azure_openai.py

@@ -39,7 +39,7 @@ class AzureChatOpenAIComponent(LCModelComponent):
             required=True,
         ),
         MessageTextInput(name="azure_deployment", display_name="Deployment Name", required=True),
-        SecretStrInput(name="api_key", display_name="API Key", required=True),
+        SecretStrInput(name="api_key", display_name="Azure Chat OpenAI API Key", required=True),
         DropdownInput(
             name="api_version",
             display_name="API Version",

lfx/components/azure/azure_openai_embeddings.py

@@ -50,7 +50,7 @@ class AzureOpenAIEmbeddingsComponent(LCModelComponent):
         ),
         SecretStrInput(
             name="api_key",
-            display_name="API Key",
+            display_name="Azure OpenAI API Key",
             required=True,
         ),
         IntInput(

lfx/components/chroma/chroma.py

@@ -121,7 +121,8 @@ class ChromaVectorStoreComponent(LCVectorStoreComponent):
         )
 
         self._add_documents_to_vector_store(chroma)
-        self.status = chroma_collection_to_data(chroma.get(limit=self.limit))
+        limit = int(self.limit) if self.limit is not None and str(self.limit).strip() else None
+        self.status = chroma_collection_to_data(chroma.get(limit=limit))
         return chroma
 
     def _add_documents_to_vector_store(self, vector_store: "Chroma") -> None:
@@ -138,7 +139,8 @@ class ChromaVectorStoreComponent(LCVectorStoreComponent):
         if self.allow_duplicates:
             stored_data = []
         else:
-            stored_data = chroma_collection_to_data(vector_store.get(limit=self.limit))
+            limit = int(self.limit) if self.limit is not None and str(self.limit).strip() else None
+            stored_data = chroma_collection_to_data(vector_store.get(limit=limit))
             for value in deepcopy(stored_data):
                 del value.id
                 stored_documents_without_id.append(value)

lfx/components/clickhouse/clickhouse.py

@@ -26,7 +26,7 @@ class ClickhouseVectorStoreComponent(LCVectorStoreComponent):
         StrInput(name="database", display_name="database", required=True),
         StrInput(name="table", display_name="Table name", required=True),
         StrInput(name="username", display_name="The ClickHouse user name.", required=True),
-        SecretStrInput(name="password", display_name="The password for username.", required=True),
+        SecretStrInput(name="password", display_name="Clickhouse Password", required=True),
         DropdownInput(
             name="index_type",
             display_name="index_type",

lfx/components/confluence/confluence.py

@@ -29,7 +29,7 @@ class ConfluenceComponent(Component):
         ),
         SecretStrInput(
             name="api_key",
-            display_name="API Key",
+            display_name="Confluence API Key",
             required=True,
             info="Atlassian Key. Create at: https://id.atlassian.com/manage-profile/security/api-tokens",
         ),

lfx/components/crewai/crewai.py

@@ -21,6 +21,7 @@ class CrewAIAgentComponent(Component):
     documentation: str = "https://docs.crewai.com/how-to/LLM-Connections/"
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
 
     inputs = [
         MultilineInput(name="role", display_name="Role", info="The role of the agent."),

lfx/components/crewai/hierarchical_crew.py

@@ -10,6 +10,7 @@ class HierarchicalCrewComponent(BaseCrewComponent):
     documentation: str = "https://docs.crewai.com/how-to/Hierarchical/"
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
 
     inputs = [
         *BaseCrewComponent.get_base_inputs(),

lfx/components/crewai/hierarchical_task.py

@@ -8,6 +8,7 @@ class HierarchicalTaskComponent(Component):
     description: str = "Each task must have a description, an expected output and an agent responsible for execution."
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
     inputs = [
         MultilineInput(
             name="task_description",

lfx/components/crewai/sequential_crew.py

@@ -9,6 +9,7 @@ class SequentialCrewComponent(BaseCrewComponent):
     documentation: str = "https://docs.crewai.com/how-to/Sequential/"
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
 
     inputs = [
         *BaseCrewComponent.get_base_inputs(),

lfx/components/crewai/sequential_task.py

@@ -8,6 +8,7 @@ class SequentialTaskComponent(Component):
     description: str = "Each task must have a description, an expected output and an agent responsible for execution."
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
     inputs = [
         MultilineInput(
             name="task_description",

lfx/components/crewai/sequential_task_agent.py

@@ -9,6 +9,7 @@ class SequentialTaskAgentComponent(Component):
     documentation = "https://docs.crewai.com/how-to/LLM-Connections/"
     icon = "CrewAI"
     legacy = True
+    replacement = "agents.Agent"
 
     inputs = [
         # Agent inputs

lfx/components/data/api_request.py

@@ -188,6 +188,8 @@ class APIRequestComponent(Component):
         """Process the body input into a valid dictionary."""
         if body is None:
             return {}
+        if hasattr(body, "data"):
+            body = body.data
         if isinstance(body, dict):
             return self._process_dict_body(body)
         if isinstance(body, str):
@@ -212,10 +214,18 @@ class APIRequestComponent(Component):
         processed_dict = {}
         try:
             for item in body:
-                if not self._is_valid_key_value_item(item):
+                # Unwrap Data objects
+                current_item = item
+                if hasattr(item, "data"):
+                    unwrapped_data = item.data
+                    # If the unwrapped data is a dict but not key-value format, use it directly
+                    if isinstance(unwrapped_data, dict) and not self._is_valid_key_value_item(unwrapped_data):
+                        return unwrapped_data
+                    current_item = unwrapped_data
+                if not self._is_valid_key_value_item(current_item):
                     continue
-                key = item["key"]
-                value = self._parse_json_value(item["value"])
+                key = current_item["key"]
+                value = self._parse_json_value(current_item["value"])
                 processed_dict[key] = value
         except (KeyError, TypeError, ValueError) as e:
             self.log(f"Failed to process body list: {e}")

lfx/components/data/csv_to_data.py

@@ -13,6 +13,7 @@ class CSVToDataComponent(Component):
     icon = "file-spreadsheet"
     name = "CSVtoData"
     legacy = True
+    replacement = ["data.File"]
 
     inputs = [
         FileInput(

lfx/components/data/file.py

@@ -1,8 +1,7 @@
-"""Enhanced file component with clearer structure and Docling isolation.
+"""Enhanced file component with Docling support and process isolation.
 
 Notes:
 -----
-- Functionality is preserved with minimal behavioral changes.
 - ALL Docling parsing/export runs in a separate OS process to prevent memory
   growth and native library state from impacting the main Langflow process.
 - Standard text/structured parsing continues to use existing BaseFileComponent
@@ -31,28 +30,22 @@ class FileComponent(BaseFileComponent):
     """File component with optional Docling processing (isolated in a subprocess)."""
 
     display_name = "File"
-    description = "Loads content from files with optional advanced document processing and export using Docling."
+    description = "Loads content from one or more files."
     documentation: str = "https://docs.langflow.org/components-data#file"
     icon = "file-text"
     name = "File"
 
     # Docling-supported/compatible extensions; TEXT_FILE_TYPES are supported by the base loader.
     VALID_EXTENSIONS = [
+        *TEXT_FILE_TYPES,
         "adoc",
         "asciidoc",
         "asc",
         "bmp",
-        "csv",
         "dotx",
         "dotm",
         "docm",
-        "docx",
-        "htm",
-        "html",
         "jpeg",
-        "json",
-        "md",
-        "pdf",
         "png",
         "potx",
         "ppsx",
@@ -61,13 +54,10 @@ class FileComponent(BaseFileComponent):
         "ppsm",
         "pptx",
         "tiff",
-        "txt",
         "xls",
         "xlsx",
         "xhtml",
-        "xml",
         "webp",
-        *TEXT_FILE_TYPES,
     ]
 
     # Fixed export settings used when markdown export is requested.
@@ -91,6 +81,7 @@ class FileComponent(BaseFileComponent):
             info=(
                 "Enable advanced document processing and export with Docling for PDFs, images, and office documents. "
                 "Available only for single file processing."
+                "Note that advanced document processing can consume significant resources."
             ),
             show=False,
         ),
@@ -101,13 +92,14 @@ class FileComponent(BaseFileComponent):
             options=["standard", "vlm"],
             value="standard",
             advanced=True,
+            real_time_refresh=True,
         ),
         DropdownInput(
             name="ocr_engine",
             display_name="OCR Engine",
             info="OCR engine to use. Only available when pipeline is set to 'standard'.",
-            options=["", "easyocr"],
-            value="",
+            options=["None", "easyocr"],
+            value="easyocr",
             show=False,
             advanced=True,
         ),
@@ -190,16 +182,25 @@ class FileComponent(BaseFileComponent):
                     if f in build_config:
                         build_config[f]["show"] = False
 
+        # Docling Processing
         elif field_name == "advanced_mode":
             for f in ("pipeline", "ocr_engine", "doc_key", "md_image_placeholder", "md_page_break_placeholder"):
                 if f in build_config:
                     build_config[f]["show"] = bool(field_value)
 
+        elif field_name == "pipeline":
+            if field_value == "standard":
+                build_config["ocr_engine"]["show"] = True
+                build_config["ocr_engine"]["value"] = "easyocr"
+            else:
+                build_config["ocr_engine"]["show"] = False
+                build_config["ocr_engine"]["value"] = "None"
+
         return build_config
 
     def update_outputs(self, frontend_node: dict[str, Any], field_name: str, field_value: Any) -> dict[str, Any]:  # noqa: ARG002
         """Dynamically show outputs based on file count/type and advanced mode."""
-        if field_name not in ["path", "advanced_mode"]:
+        if field_name not in ["path", "advanced_mode", "pipeline"]:
             return frontend_node
 
         template = frontend_node.get("template", {})
@@ -222,10 +223,10 @@ class FileComponent(BaseFileComponent):
             advanced_mode = frontend_node.get("template", {}).get("advanced_mode", {}).get("value", False)
             if advanced_mode:
                 frontend_node["outputs"].append(
-                    Output(display_name="Structured Output", name="advanced", method="load_files_advanced"),
+                    Output(display_name="Structured Output", name="advanced_dataframe", method="load_files_dataframe"),
                 )
                 frontend_node["outputs"].append(
-                    Output(display_name="Markdown", name="markdown", method="load_files_markdown"),
+                    Output(display_name="Markdown", name="advanced_markdown", method="load_files_markdown"),
                 )
                 frontend_node["outputs"].append(
                     Output(display_name="File Path", name="path", method="load_files_path"),
@@ -296,10 +297,15 @@ class FileComponent(BaseFileComponent):
             "md_image_placeholder": str(self.md_image_placeholder),
             "md_page_break_placeholder": str(self.md_page_break_placeholder),
             "pipeline": str(self.pipeline),
-            "ocr_engine": str(self.ocr_engine) if getattr(self, "ocr_engine", "") else None,
+            "ocr_engine": (
+                self.ocr_engine if self.ocr_engine and self.ocr_engine != "None" and self.pipeline != "vlm" else None
+            ),
         }
 
-        # The child is a tiny, self-contained script to keep memory/state isolated.
+        self.log(f"Starting Docling subprocess for file: {file_path}")
+        self.log(args)
+
+        # Child script for isolating the docling processing
         child_script = textwrap.dedent(
             r"""
             import json, sys
@@ -346,11 +352,15 @@ class FileComponent(BaseFileComponent):
                     raise ImportError(f"Docling imports failed: {e}") from e
 
             def create_converter(strategy, input_format, DocumentConverter, pipeline, ocr_engine):
-                if strategy == "latest" and pipeline == "standard":
+                # --- Standard PDF/IMAGE pipeline (your existing behavior), with optional OCR ---
+                if pipeline == "standard":
                     try:
                         from docling.datamodel.pipeline_options import PdfPipelineOptions  # type: ignore
                         from docling.document_converter import PdfFormatOption  # type: ignore
+
                         pipe = PdfPipelineOptions()
+                        pipe.do_ocr = False
+
                         if ocr_engine:
                             try:
                                 from docling.models.factories import get_ocr_factory  # type: ignore
@@ -358,15 +368,39 @@ class FileComponent(BaseFileComponent):
                                 fac = get_ocr_factory(allow_external_plugins=False)
                                 pipe.ocr_options = fac.create_options(kind=ocr_engine)
                             except Exception:
+                                # If OCR setup fails, disable it
                                 pipe.do_ocr = False
+
                         fmt = {}
                         if hasattr(input_format, "PDF"):
                             fmt[getattr(input_format, "PDF")] = PdfFormatOption(pipeline_options=pipe)
                         if hasattr(input_format, "IMAGE"):
                             fmt[getattr(input_format, "IMAGE")] = PdfFormatOption(pipeline_options=pipe)
+
                         return DocumentConverter(format_options=fmt)
                     except Exception:
                         return DocumentConverter()
+
+                # --- Vision-Language Model (VLM) pipeline ---
+                if pipeline == "vlm":
+                    try:
+                        from docling.pipeline.vlm_pipeline import VlmPipeline
+                        from docling.document_converter import PdfFormatOption  # type: ignore
+
+                        vl_pipe = VlmPipelineOptions()
+
+                        # VLM paths generally don't need OCR; keep OCR off by default here.
+                        fmt = {}
+                        if hasattr(input_format, "PDF"):
+                            fmt[getattr(input_format, "PDF")] = PdfFormatOption(pipeline_cls=VlmPipeline)
+                        if hasattr(input_format, "IMAGE"):
+                            fmt[getattr(input_format, "IMAGE")] = PdfFormatOption(pipeline_cls=VlmPipeline)
+
+                        return DocumentConverter(format_options=fmt)
+                    except Exception:
+                        return DocumentConverter()
+
+                # --- Fallback: default converter with no special options ---
                 return DocumentConverter()
 
             def export_markdown(document, ImageRefMode, image_mode, img_ph, pg_ph):
@@ -565,13 +599,25 @@ class FileComponent(BaseFileComponent):
 
     # ------------------------------ Output helpers -----------------------------------
 
-    def load_files_advanced(self) -> DataFrame:
-        """Load files using advanced Docling processing and export to an advanced format."""
+    def load_files_helper(self) -> DataFrame:
+        result = self.load_files()
+
+        # Error condition - raise error if no text and an error is present
+        if not hasattr(result, "text"):
+            if hasattr(result, "error"):
+                raise ValueError(result.error[0])
+            msg = "No content generated."
+            raise ValueError(msg)
+
+        return result
+
+    def load_files_dataframe(self) -> DataFrame:
+        """Load files using advanced Docling processing and export to DataFrame format."""
         self.markdown = False
-        return self.load_files()
+        return self.load_files_helper()
 
     def load_files_markdown(self) -> Message:
         """Load files using advanced Docling processing and export to Markdown format."""
         self.markdown = True
-        result = self.load_files()
+        result = self.load_files_helper()
         return Message(text=str(result.text[0]))

lfx/components/data/json_to_data.py

@@ -16,6 +16,7 @@ class JSONToDataComponent(Component):
     icon = "braces"
     name = "JSONtoData"
     legacy = True
+    replacement = ["data.File"]
 
     inputs = [
         FileInput(

lfx/components/datastax/astra_db.py

@@ -22,7 +22,7 @@ class AstraDBChatMemory(LCChatMemoryComponent):
         ),
         SecretStrInput(
             name="api_endpoint",
-            display_name="API Endpoint",
+            display_name="Astra DB API Endpoint",
             info="API endpoint URL for the Astra DB service.",
             value="ASTRA_DB_API_ENDPOINT",
             required=True,
@@ -49,6 +49,7 @@ class AstraDBChatMemory(LCChatMemoryComponent):
 
     def build_message_history(self) -> Memory:
         try:
+            from astrapy.admin import parse_api_endpoint
             from langchain_astradb.chat_message_histories import AstraDBChatMessageHistory
 
         except ImportError as e:

lfx/components/datastax/astra_vectorize.py

@@ -6,15 +6,13 @@ from lfx.template.field.base import Output
 
 
 class AstraVectorizeComponent(Component):
-    display_name: str = "Astra Vectorize [DEPRECATED]"
-    description: str = (
-        "Configuration options for Astra Vectorize server-side embeddings. "
-        "This component is deprecated. Please use the Astra DB Component directly."
-    )
+    display_name: str = "Astra Vectorize"
+    description: str = "Configuration options for Astra Vectorize server-side embeddings. "
     documentation: str = "https://docs.datastax.com/en/astra-db-serverless/databases/embedding-generation.html"
     legacy = True
     icon = "AstraDB"
     name = "AstraVectorize"
+    replacement = ["datastax.AstraDB"]
 
     VECTORIZE_PROVIDERS_MAPPING = {
         "Azure OpenAI": ["azureOpenAI", ["text-embedding-3-small", "text-embedding-3-large", "text-embedding-ada-002"]],

lfx/components/datastax/astradb_tool.py

@@ -3,7 +3,6 @@ from datetime import datetime, timezone
 from typing import Any
 
 from astrapy import Collection, DataAPIClient, Database
-from astrapy.admin import parse_api_endpoint
 from langchain_core.tools import StructuredTool, Tool
 from pydantic import BaseModel, Field, create_model
 
@@ -192,6 +191,11 @@ class AstraDBToolComponent(LCToolComponent):
     _cached_collection: Collection | None = None
 
     def _build_collection(self):
+        try:
+            from astrapy.admin import parse_api_endpoint
+        except ImportError as e:
+            msg = "Could not import Astra DB integration package. Please install it with `uv pip install astrapy`."
+            raise ImportError(msg) from e
         if self._cached_collection:
             return self._cached_collection