langflow-base-nightly 0.5.0.dev36__py3-none-any.whl → 0.5.0.dev38__py3-none-any.whl

langflow/components/ollama/ollama.py

@@ -245,11 +245,13 @@ class ChatOllamaComponent(LCModelComponent):
         if field_name in {"model_name", "base_url", "tool_model_enabled"}:
             if await self.is_valid_ollama_url(self.base_url):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
-                build_config["model_name"]["options"] = await self.get_models(self.base_url, tool_model_enabled)
+                build_config["model_name"]["options"] = await self.get_models(
+                    self.base_url, tool_model_enabled=tool_model_enabled
+                )
             elif await self.is_valid_ollama_url(build_config["base_url"].get("value", "")):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
                 build_config["model_name"]["options"] = await self.get_models(
-                    build_config["base_url"].get("value", ""), tool_model_enabled
+                    build_config["base_url"].get("value", ""), tool_model_enabled=tool_model_enabled
                 )
             else:
                 build_config["model_name"]["options"] = []
@@ -265,7 +267,7 @@ class ChatOllamaComponent(LCModelComponent):
 
         return build_config
 
-    async def get_models(self, base_url_value: str, tool_model_enabled: bool | None = None) -> list[str]:
+    async def get_models(self, base_url_value: str, *, tool_model_enabled: bool | None = None) -> list[str]:
         """Fetches a list of models from the Ollama API that do not have the "embedding" capability.
 
         Args:
@@ -298,13 +300,13 @@ class ChatOllamaComponent(LCModelComponent):
                 models = tags_response.json()
                 if asyncio.iscoroutine(models):
                     models = await models
-                logger.debug(f"Available models: {models}")
+                await logger.adebug(f"Available models: {models}")
 
                 # Filter models that are NOT embedding models
                 model_ids = []
                 for model in models[self.JSON_MODELS_KEY]:
                     model_name = model[self.JSON_NAME_KEY]
-                    logger.debug(f"Checking model: {model_name}")
+                    await logger.adebug(f"Checking model: {model_name}")
 
                     payload = {"model": model_name}
                     show_response = await client.post(show_url, json=payload)
@@ -313,7 +315,7 @@ class ChatOllamaComponent(LCModelComponent):
                     if asyncio.iscoroutine(json_data):
                         json_data = await json_data
                     capabilities = json_data.get(self.JSON_CAPABILITIES_KEY, [])
-                    logger.debug(f"Model: {model_name}, Capabilities: {capabilities}")
+                    await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
 
                     if self.DESIRED_CAPABILITY in capabilities and (
                         not tool_model_enabled or self.TOOL_CALLING_CAPABILITY in capabilities

langflow/components/processing/batch_run.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 if TYPE_CHECKING:
@@ -144,11 +144,11 @@ class BatchRunComponent(Component):
                 user_texts = df[col_name].astype(str).tolist()
             else:
                 user_texts = [
-                    self._format_row_as_toml(cast(dict[str, Any], row)) for row in df.to_dict(orient="records")
+                    self._format_row_as_toml(cast("dict[str, Any]", row)) for row in df.to_dict(orient="records")
                 ]
 
             total_rows = len(user_texts)
-            logger.info(f"Processing {total_rows} rows with batch run")
+            await logger.ainfo(f"Processing {total_rows} rows with batch run")
 
             # Prepare the batch of conversations
             conversations = [
@@ -185,21 +185,21 @@ class BatchRunComponent(Component):
             ):
                 response_text = response[1].content if hasattr(response[1], "content") else str(response[1])
                 row = self._create_base_row(
-                    cast(dict[str, Any], original_row), model_response=response_text, batch_index=idx
+                    cast("dict[str, Any]", original_row), model_response=response_text, batch_index=idx
                 )
                 self._add_metadata(row, success=True, system_msg=system_msg)
                 rows.append(row)
 
                 # Log progress
                 if (idx + 1) % max(1, total_rows // 10) == 0:
-                    logger.info(f"Processed {idx + 1}/{total_rows} rows")
+                    await logger.ainfo(f"Processed {idx + 1}/{total_rows} rows")
 
-            logger.info("Batch processing completed successfully")
+            await logger.ainfo("Batch processing completed successfully")
             return DataFrame(rows)
 
         except (KeyError, AttributeError) as e:
             # Handle data structure and attribute access errors
-            logger.error(f"Data processing error: {e!s}")
-            error_row = self._create_base_row({col: "" for col in df.columns}, model_response="", batch_index=-1)
+            await logger.aerror(f"Data processing error: {e!s}")
+            error_row = self._create_base_row(dict.fromkeys(df.columns, ""), model_response="", batch_index=-1)
             self._add_metadata(error_row, success=False, error=str(e))
             return DataFrame([error_row])

langflow/components/processing/data_operations.py

@@ -181,7 +181,7 @@ class DataOperationsComponent(Component):
         raise ValueError(msg)
 
     # Data transformation operations
-    def select_keys(self, evaluate: bool | None = None) -> Data:
+    def select_keys(self, *, evaluate: bool | None = None) -> Data:
         """Select specific keys from the data dictionary."""
         self.validate_single_data("Select Keys")
         data_dict = self.get_normalized_data()
@@ -266,7 +266,7 @@ class DataOperationsComponent(Component):
         logger.info("evaluating data")
         return Data(**self.recursive_eval(self.get_data_dict()))
 
-    def combine_data(self, evaluate: bool | None = None) -> Data:
+    def combine_data(self, *, evaluate: bool | None = None) -> Data:
         """Combine multiple data objects into one."""
         logger.info("combining data")
         if not self.data_is_list():

langflow/components/processing/merge_data.py

@@ -1,10 +1,9 @@
 from enum import Enum
 from typing import cast
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import DataInput, DropdownInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 

langflow/components/processing/message_to_data.py

@@ -1,7 +1,6 @@
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import MessageInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 
@@ -32,6 +31,6 @@ class MessageToDataComponent(Component):
             return Data(data=self.message.data)
 
         msg = "Error converting Message to Data: Input must be a Message object"
-        logger.opt(exception=True).debug(msg)
+        logger.debug(msg, exc_info=True)
         self.status = msg
         return Data(data={"error": msg})

langflow/components/processing/parse_json_data.py

@@ -3,11 +3,11 @@ from json import JSONDecodeError
 
 import jq
 from json_repair import repair_json
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import HandleInput, MessageTextInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/components/processing/save_file.py

@@ -1,7 +1,6 @@
 import json
 from collections.abc import AsyncIterator, Iterator
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import orjson
 import pandas as pd
@@ -10,16 +9,12 @@ from fastapi.encoders import jsonable_encoder
 
 from langflow.api.v2.files import upload_user_file
 from langflow.custom import Component
-from langflow.io import DropdownInput, HandleInput, SecretStrInput, StrInput
+from langflow.io import DropdownInput, HandleInput, StrInput
 from langflow.schema import Data, DataFrame, Message
-from langflow.services.auth.utils import create_user_longterm_token, get_current_user
 from langflow.services.database.models.user.crud import get_user_by_id
-from langflow.services.deps import get_session, get_settings_service, get_storage_service
+from langflow.services.deps import get_settings_service, get_storage_service, session_scope
 from langflow.template.field.base import Output
 
-if TYPE_CHECKING:
-    from langflow.services.database.models.user.model import User
-
 
 class SaveToFileComponent(Component):
     display_name = "Save File"
@@ -55,13 +50,6 @@ class SaveToFileComponent(Component):
             value="",
             advanced=True,
         ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Langflow API Key",
-            info="Langflow API key for authentication when saving the file.",
-            required=False,
-            advanced=True,
-        ),
     ]
 
     outputs = [Output(display_name="File Path", name="message", method="save_to_file")]
@@ -148,25 +136,11 @@ class SaveToFileComponent(Component):
             raise FileNotFoundError(msg)
 
         with file_path.open("rb") as f:
-            async for db in get_session():
-                # TODO: In 1.6, this may need to be removed or adjusted
-                # Try to get the super user token, if possible
-                current_user: User | None = None
-                if self.api_key:
-                    current_user = await get_current_user(
-                        token="",
-                        query_param=self.api_key,
-                        header_param="",
-                        db=db,
-                    )
-                else:
-                    user_id, _ = await create_user_longterm_token(db)
-                    current_user = await get_user_by_id(db, user_id)
-
-                # Fail if the user is not found
-                if not current_user:
-                    msg = "User not found. Please provide a valid API key or ensure the user exists."
+            async with session_scope() as db:
+                if not self.user_id:
+                    msg = "User ID is required for file saving."
                     raise ValueError(msg)
+                current_user = await get_user_by_id(db, self.user_id)
 
                 await upload_user_file(
                     file=UploadFile(filename=file_path.name, file=f, size=file_path.stat().st_size),

langflow/components/prototypes/python_function.py

@@ -1,10 +1,9 @@
 from collections.abc import Callable
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.custom.utils import get_function
 from langflow.io import CodeInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 from langflow.schema.message import Message
@@ -58,7 +57,7 @@ class PythonFunctionComponent(Component):
             func = get_function(function_code)
             return func()
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error executing function")
+            logger.debug("Error executing function", exc_info=True)
             return f"Error executing function: {e}"
 
     def execute_function_data(self) -> list[Data]:

langflow/components/serpapi/serp.py

@@ -2,12 +2,12 @@ from typing import Any
 
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/components/tavily/tavily_extract.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom import Component
 from langflow.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema import Data
 from langflow.schema.dataframe import DataFrame
 

langflow/components/tavily/tavily_search.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output

langflow/components/tools/calculator.py

@@ -3,12 +3,12 @@ import operator
 
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -87,7 +87,7 @@ class CalculatorToolComponent(LCToolComponent):
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error evaluating expression")
+            logger.debug("Error evaluating expression", exc_info=True)
             error_message = f"Error: {e}"
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]

langflow/components/tools/python_code_structured_tool.py

@@ -4,21 +4,14 @@ from typing import Any
 
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 from pydantic.v1.fields import Undefined
 from typing_extensions import override
 
 from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.inputs.inputs import (
-    BoolInput,
-    DropdownInput,
-    FieldTypes,
-    HandleInput,
-    MessageTextInput,
-    MultilineInput,
-)
+from langflow.inputs.inputs import BoolInput, DropdownInput, FieldTypes, HandleInput, MessageTextInput, MultilineInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 
@@ -139,7 +132,7 @@ class PythonCodeStructuredTool(LCToolComponent):
             build_config["tool_function"]["options"] = names
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["tool_function"]["options"] = ["Failed to parse", str(e)]
         return build_config
 

langflow/components/tools/python_repl.py

@@ -3,12 +3,12 @@ import importlib
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
 from langchain_experimental.utilities import PythonREPL
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import StrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -78,7 +78,7 @@ class PythonREPLToolComponent(LCToolComponent):
             try:
                 return python_repl.run(code)
             except Exception as e:
-                logger.opt(exception=True).debug("Error running Python code")
+                logger.debug("Error running Python code", exc_info=True)
                 raise ToolException(str(e)) from e
 
         tool = StructuredTool.from_function(

langflow/components/tools/searxng.py

@@ -5,12 +5,12 @@ from typing import Any
 import requests
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput, MultiselectInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -76,7 +76,7 @@ class SearXNGToolComponent(LCToolComponent):
             build_config["language"]["options"] = languages.copy()
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["categories"]["options"] = ["Failed to parse", str(e)]
         return build_config
 
@@ -112,7 +112,7 @@ class SearXNGToolComponent(LCToolComponent):
                     num_results = min(SearxSearch._max_results, len(response["results"]))
                     return [response["results"][i] for i in range(num_results)]
                 except Exception as e:  # noqa: BLE001
-                    logger.opt(exception=True).debug("Error running SearXNG Search")
+                    logger.debug("Error running SearXNG Search", exc_info=True)
                     return [f"Failed to search: {e}"]
 
         SearxSearch._url = self.url

langflow/components/tools/serp_api.py

@@ -3,12 +3,12 @@ from typing import Any
 from langchain.tools import StructuredTool
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -111,7 +111,7 @@ class SerpAPIComponent(LCToolComponent):
             data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
 
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error running SerpAPI")
+            logger.debug("Error running SerpAPI", exc_info=True)
             self.status = f"Error: {e}"
             return [Data(data={"error": str(e)}, text=str(e))]
 

langflow/components/tools/tavily_search_tool.py

@@ -3,12 +3,12 @@ from enum import Enum
 import httpx
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 # Add at the top with other constants
@@ -338,7 +338,7 @@ Note: Check 'Advanced' for all options.
             raise ToolException(error_message) from e
         except Exception as e:
             error_message = f"Unexpected error: {e}"
-            logger.opt(exception=True).debug("Error running Tavily Search")
+            logger.debug("Error running Tavily Search", exc_info=True)
             self.status = error_message
             raise ToolException(error_message) from e
         return data_results

langflow/components/tools/yahoo_finance.py

@@ -5,12 +5,12 @@ from enum import Enum
 import yfinance as yf
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 

langflow/components/twelvelabs/video_embeddings.py

@@ -29,9 +29,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
             # First try to use video embedding, then fall back to clip embedding if available
             if result["video_embedding"] is not None:
-                embeddings.append(cast(list[float], result["video_embedding"]))
+                embeddings.append(cast("list[float]", result["video_embedding"]))
             elif result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-                embeddings.append(cast(list[float], result["clip_embeddings"][0]))
+                embeddings.append(cast("list[float]", result["clip_embeddings"][0]))
             else:
                 # If neither is available, raise an error
                 error_msg = "No embeddings were generated for the video"
@@ -45,9 +45,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
         # First try to use video embedding, then fall back to clip embedding if available
         if result["video_embedding"] is not None:
-            return cast(list[float], result["video_embedding"])
+            return cast("list[float]", result["video_embedding"])
         if result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-            return cast(list[float], result["clip_embeddings"][0])
+            return cast("list[float]", result["clip_embeddings"][0])
         # If neither is available, raise an error
         error_msg = "No embeddings were generated for the video"
         raise ValueError(error_msg)

langflow/components/vectorstores/astradb.py

@@ -161,11 +161,11 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             dialog_inputs=asdict(NewDatabaseInput()),
             combobox=True,
         ),
-        StrInput(
+        DropdownInput(
             name="api_endpoint",
             display_name="Astra DB API Endpoint",
             info="The API Endpoint for the Astra DB instance. Supercedes database selection.",
-            show=False,
+            advanced=True,
         ),
         DropdownInput(
             name="keyspace",
@@ -224,7 +224,6 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             separator=" ",
             show=False,
             value="",
-            advanced=True,
         ),
         IntInput(
             name="number_of_results",
@@ -448,14 +447,14 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
         for db in db_list:
             try:
                 # Get the API endpoint for the database
-                api_endpoint = db.regions[0].api_endpoint
+                api_endpoints = [db_reg.api_endpoint for db_reg in db.regions]
 
                 # Get the number of collections
                 try:
                     # Get the number of collections in the database
                     num_collections = len(
                         client.get_database(
-                            api_endpoint,
+                            api_endpoints[0],
                             token=token,
                         ).list_collection_names()
                     )
@@ -466,7 +465,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
 
                 # Add the database to the dictionary
                 db_info_dict[db.name] = {
-                    "api_endpoint": api_endpoint,
+                    "api_endpoints": api_endpoints,
                     "keyspaces": db.keyspaces,
                     "collections": num_collections,
                     "status": db.status if db.status != "ACTIVE" else None,
@@ -509,7 +508,8 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             return None
 
         # Otherwise, get the URL from the database list
-        return db.get("api_endpoint")
+        endpoints = db.get("api_endpoints") or []
+        return endpoints[0] if endpoints else None
 
     def get_api_endpoint(self):
         return self.get_api_endpoint_static(
@@ -577,7 +577,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
                     "name": name,
                     "status": info["status"],
                     "collections": info["collections"],
-                    "api_endpoint": info["api_endpoint"],
+                    "api_endpoints": info["api_endpoints"],
                     "keyspaces": info["keyspaces"],
                     "org_id": info["org_id"],
                 }
@@ -773,6 +773,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
         # Reset selections if value not in options
         if database_config["value"] not in database_config["options"]:
             database_config["value"] = ""
+            build_config["api_endpoint"]["options"] = []
             build_config["api_endpoint"]["value"] = ""
             build_config["collection_name"]["show"] = False
 
@@ -786,6 +787,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
         # Reset database configuration
         database_config = build_config["database_name"]
         database_config.update({"options": [], "options_metadata": [], "value": "", "show": False})
+        build_config["api_endpoint"]["options"] = []
         build_config["api_endpoint"]["value"] = ""
 
         # Reset collection configuration
@@ -828,13 +830,6 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             build_config["search_method"]["options"] = ["Vector Search"]
             build_config["search_method"]["value"] = "Vector Search"
 
-        # Set reranker and lexical terms options based on search method
-        build_config["reranker"]["toggle_value"] = True
-        build_config["reranker"]["show"] = build_config["search_method"]["value"] == "Hybrid Search"
-        build_config["reranker"]["toggle_disable"] = build_config["search_method"]["value"] == "Hybrid Search"
-        if build_config["reranker"]["show"]:
-            build_config["search_type"]["value"] = "Similarity"
-
         return build_config
 
     async def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
@@ -892,6 +887,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             build_config["lexical_terms"]["value"] = "" if is_vector_search else build_config["lexical_terms"]["value"]
 
             # Disable reranker disabling if hybrid search is selected
+            build_config["reranker"]["show"] = not is_vector_search
             build_config["reranker"]["toggle_disable"] = not is_vector_search
             build_config["reranker"]["toggle_value"] = True
             build_config["reranker"]["value"] = build_config["reranker"]["options"][0]
@@ -926,7 +922,7 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
             {
                 "status": "PENDING",
                 "collections": 0,
-                "api_endpoint": None,
+                "api_endpoints": [],
                 "keyspaces": [self.get_keyspace()],
                 "org_id": None,
             }
@@ -999,7 +995,12 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
 
         # Get the api endpoint for the selected database
         index = build_config["database_name"]["options"].index(field_value)
-        build_config["api_endpoint"]["value"] = build_config["database_name"]["options_metadata"][index]["api_endpoint"]
+        build_config["api_endpoint"]["options"] = build_config["database_name"]["options_metadata"][index][
+            "api_endpoints"
+        ]
+        build_config["api_endpoint"]["value"] = build_config["database_name"]["options_metadata"][index][
+            "api_endpoints"
+        ][0]
 
         # Get the org_id for the selected database
         org_id = build_config["database_name"]["options_metadata"][index]["org_id"]
@@ -1077,8 +1078,18 @@ class AstraDBVectorStoreComponent(LCVectorStoreComponent):
         lex_enabled = col_options.lexical and col_options.lexical.enabled
         user_hyb_enabled = build_config["search_method"]["value"] == "Hybrid Search"
 
-        # Show lexical terms if the collection is hybrid enabled
-        build_config["lexical_terms"]["show"] = hyb_enabled and lex_enabled and user_hyb_enabled
+        # Reranker visible when both the collection supports it and the user selected Hybrid
+        hybrid_active = bool(hyb_enabled and user_hyb_enabled)
+        build_config["reranker"]["show"] = hybrid_active
+        build_config["reranker"]["toggle_value"] = hybrid_active
+        build_config["reranker"]["toggle_disable"] = False  # allow user to toggle if visible
+
+        # If hybrid is active, lock search_type to "Similarity"
+        if hybrid_active:
+            build_config["search_type"]["value"] = "Similarity"
+
+        # Show the lexical terms option only if the collection enables lexical search
+        build_config["lexical_terms"]["show"] = bool(lex_enabled)
 
         return build_config