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

lfx/base/datastax/astradb_base.py

@@ -187,34 +187,38 @@ class AstraDBBaseComponent(Component):
     @classmethod
     def map_cloud_providers(cls, token: str, environment: str | None = None) -> dict[str, dict[str, Any]]:
         """Fetch all available cloud providers and regions."""
-        # Get the admin object
-        client = DataAPIClient(environment=cls.get_environment(environment))
-        admin_client = client.get_admin(token=token)
-
-        # Get the list of available regions
-        available_regions = admin_client.find_available_regions(only_org_enabled_regions=True)
+        try:
+            # Get the admin object
+            client = DataAPIClient(environment=cls.get_environment(environment))
+            admin_client = client.get_admin(token=token)
 
-        provider_mapping: dict[str, dict[str, str]] = {
-            "AWS": {"name": "Amazon Web Services", "id": "aws"},
-            "GCP": {"name": "Google Cloud Platform", "id": "gcp"},
-            "Azure": {"name": "Microsoft Azure", "id": "azure"},
-        }
+            # Get the list of available regions
+            available_regions = admin_client.find_available_regions(only_org_enabled_regions=True)
 
-        result: dict[str, dict[str, Any]] = {}
-        for region_info in available_regions:
-            cloud_provider = region_info.cloud_provider
-            region = region_info.name
+            provider_mapping: dict[str, dict[str, str]] = {
+                "AWS": {"name": "Amazon Web Services", "id": "aws"},
+                "GCP": {"name": "Google Cloud Platform", "id": "gcp"},
+                "Azure": {"name": "Microsoft Azure", "id": "azure"},
+            }
 
-            if cloud_provider in provider_mapping:
-                provider_name = provider_mapping[cloud_provider]["name"]
-                provider_id = provider_mapping[cloud_provider]["id"]
+            result: dict[str, dict[str, Any]] = {}
+            for region_info in available_regions:
+                cloud_provider = region_info.cloud_provider
+                region = region_info.name
 
-                if provider_name not in result:
-                    result[provider_name] = {"id": provider_id, "regions": []}
+                if cloud_provider in provider_mapping:
+                    provider_name = provider_mapping[cloud_provider]["name"]
+                    provider_id = provider_mapping[cloud_provider]["id"]
 
-                result[provider_name]["regions"].append(region)
+                    if provider_name not in result:
+                        result[provider_name] = {"id": provider_id, "regions": []}
 
-        return result
+                    result[provider_name]["regions"].append(region)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error fetching cloud providers: %s", e)
+            return {}
+        else:
+            return result
 
     @classmethod
     def get_vectorize_providers(cls, token: str, environment: str | None = None, api_endpoint: str | None = None):
@@ -327,48 +331,52 @@ class AstraDBBaseComponent(Component):
 
     @classmethod
     def get_database_list_static(cls, token: str, environment: str | None = None):
-        environment = cls.get_environment(environment)
-        client = DataAPIClient(environment=environment)
-
-        # Get the admin object
-        admin_client = client.get_admin(token=token)
+        try:
+            environment = cls.get_environment(environment)
+            client = DataAPIClient(environment=environment)
 
-        # Get the list of databases
-        db_list = admin_client.list_databases()
+            # Get the admin object
+            admin_client = client.get_admin(token=token)
 
-        # Generate the api endpoint for each database
-        db_info_dict = {}
-        for db in db_list:
-            try:
-                # Get the API endpoint for the database
-                api_endpoints = [db_reg.api_endpoint for db_reg in db.regions]
+            # Get the list of databases
+            db_list = admin_client.list_databases()
 
-                # Get the number of collections
+            # Generate the api endpoint for each database
+            db_info_dict = {}
+            for db in db_list:
                 try:
-                    # Get the number of collections in the database
-                    num_collections = len(
-                        client.get_database(
-                            api_endpoints[0],
-                            token=token,
-                        ).list_collection_names()
-                    )
-                except Exception:  # noqa: BLE001
-                    if db.status != "PENDING":
-                        continue
-                    num_collections = 0
-
-                # Add the database to the dictionary
-                db_info_dict[db.name] = {
-                    "api_endpoints": api_endpoints,
-                    "keyspaces": db.keyspaces,
-                    "collections": num_collections,
-                    "status": db.status if db.status != "ACTIVE" else None,
-                    "org_id": db.org_id if db.org_id else None,
-                }
-            except Exception as e:  # noqa: BLE001
-                logger.debug("Failed to get metadata for database %s: %s", db.name, e)
-
-        return db_info_dict
+                    # Get the API endpoint for the database
+                    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_endpoints[0],
+                                token=token,
+                            ).list_collection_names()
+                        )
+                    except Exception:  # noqa: BLE001
+                        if db.status != "PENDING":
+                            continue
+                        num_collections = 0
+
+                    # Add the database to the dictionary
+                    db_info_dict[db.name] = {
+                        "api_endpoints": api_endpoints,
+                        "keyspaces": db.keyspaces,
+                        "collections": num_collections,
+                        "status": db.status if db.status != "ACTIVE" else None,
+                        "org_id": db.org_id if db.org_id else None,
+                    }
+                except Exception as e:  # noqa: BLE001
+                    logger.debug("Failed to get metadata for database %s: %s", db.name, e)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error fetching database list: %s", e)
+            return {}
+        else:
+            return db_info_dict
 
     def get_database_list(self):
         return self.get_database_list_static(
@@ -467,6 +475,9 @@ class AstraDBBaseComponent(Component):
 
     def _initialize_database_options(self):
         try:
+            db_list = self.get_database_list()
+            if not db_list:
+                return []
             return [
                 {
                     "name": name,
@@ -476,11 +487,11 @@ class AstraDBBaseComponent(Component):
                     "keyspaces": info["keyspaces"],
                     "org_id": info["org_id"],
                 }
-                for name, info in self.get_database_list().items()
+                for name, info in db_list.items()
             ]
-        except Exception as e:
-            msg = f"Error fetching database options: {e}"
-            raise ValueError(msg) from e
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error fetching database options: %s", e)
+            return []
 
     @classmethod
     def get_provider_icon(cls, collection=None, provider_name: str | None = None) -> str:

lfx/base/embeddings/embeddings_class.py

@@ -0,0 +1,113 @@
+"""Extended embeddings class with available models metadata."""
+
+from langchain_core.embeddings import Embeddings
+
+
+class EmbeddingsWithModels(Embeddings):
+    """Extended Embeddings class that includes available models with dedicated instances.
+
+    This class inherits from LangChain Embeddings and provides a mapping of model names
+    to their dedicated embedding instances, enabling multi-model support without the need
+    for dynamic model switching.
+
+    Attributes:
+        embeddings: The primary LangChain Embeddings instance (used as fallback).
+        available_models: Dict mapping model names to their dedicated Embeddings instances.
+                         Each model has its own pre-configured instance with specific parameters.
+    """
+
+    def __init__(
+        self,
+        embeddings: Embeddings,
+        available_models: dict[str, Embeddings] | None = None,
+    ):
+        """Initialize the EmbeddingsWithModels wrapper.
+
+        Args:
+            embeddings: The primary LangChain Embeddings instance (used as default/fallback).
+            available_models: Dict mapping model names to dedicated Embeddings instances.
+                            Each value should be a fully configured Embeddings object ready to use.
+                            Defaults to empty dict if not provided.
+        """
+        super().__init__()
+        self.embeddings = embeddings
+        self.available_models = available_models if available_models is not None else {}
+
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Embed search docs by delegating to the underlying embeddings instance.
+
+        Args:
+            texts: List of text to embed.
+
+        Returns:
+            List of embeddings.
+        """
+        return self.embeddings.embed_documents(texts)
+
+    def embed_query(self, text: str) -> list[float]:
+        """Embed query text by delegating to the underlying embeddings instance.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            Embedding.
+        """
+        return self.embeddings.embed_query(text)
+
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Asynchronously embed search docs.
+
+        Args:
+            texts: List of text to embed.
+
+        Returns:
+            List of embeddings.
+        """
+        return await self.embeddings.aembed_documents(texts)
+
+    async def aembed_query(self, text: str) -> list[float]:
+        """Asynchronously embed query text.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            Embedding.
+        """
+        return await self.embeddings.aembed_query(text)
+
+    def __call__(self, *args, **kwargs):
+        """Make the class callable by delegating to the underlying embeddings instance.
+
+        This handles cases where the embeddings object is used as a callable.
+
+        Args:
+            *args: Positional arguments to pass to the underlying embeddings instance.
+            **kwargs: Keyword arguments to pass to the underlying embeddings instance.
+
+        Returns:
+            The result of calling the underlying embeddings instance.
+        """
+        if callable(self.embeddings):
+            return self.embeddings(*args, **kwargs)
+        msg = f"'{type(self.embeddings).__name__}' object is not callable"
+        raise TypeError(msg)
+
+    def __getattr__(self, name: str):
+        """Delegate attribute access to the underlying embeddings instance.
+
+        This ensures full compatibility with any additional methods or attributes
+        that the underlying embeddings instance might have.
+
+        Args:
+            name: The attribute name to access.
+
+        Returns:
+            The attribute from the underlying embeddings instance.
+        """
+        return getattr(self.embeddings, name)
+
+    def __repr__(self) -> str:
+        """Return string representation of the wrapper."""
+        return f"EmbeddingsWithModels(embeddings={self.embeddings!r}, available_models={self.available_models!r})"

lfx/base/models/__init__.py

@@ -1,3 +1,13 @@
 from .model import LCModelComponent
+from .unified_models import (
+    get_model_provider_variable_mapping,
+    get_model_providers,
+    get_unified_models_detailed,
+)
 
-__all__ = ["LCModelComponent"]
+__all__ = [
+    "LCModelComponent",
+    "get_model_provider_variable_mapping",
+    "get_model_providers",
+    "get_unified_models_detailed",
+]

lfx/base/models/google_generative_ai_constants.py

@@ -2,29 +2,53 @@ from .model_metadata import create_model_metadata
 
 # Unified model metadata - single source of truth
 GOOGLE_GENERATIVE_AI_MODELS_DETAILED = [
-    # GEMINI 1.5
+    # GEMINI 1.5 (stable)
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-1.5-pro", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-1.5-pro",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
     ),
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-1.5-flash", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-1.5-flash",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
     ),
     create_model_metadata(
         provider="Google Generative AI", name="gemini-1.5-flash-8b", icon="GoogleGenerativeAI", tool_calling=True
     ),
-    # GEMINI 2.5
+    # GEMINI 2.0 (stable)
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-2.5-pro", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-2.0-flash-lite",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
     ),
+    # GEMINI 2.5 (future/not yet released)
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-2.5-flash", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-2.5-pro",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
+        preview=True,
+        not_supported=True,
     ),
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-2.5-flash-lite", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-2.5-flash",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
+        preview=True,
+        not_supported=True,
     ),
-    # GEMINI 2.0
     create_model_metadata(
-        provider="Google Generative AI", name="gemini-2.0-flash-lite", icon="GoogleGenerativeAI", tool_calling=True
+        provider="Google Generative AI",
+        name="gemini-2.5-flash-lite",
+        icon="GoogleGenerativeAI",
+        tool_calling=True,
+        preview=True,
+        not_supported=True,
     ),
     # PREVIEW
     create_model_metadata(

lfx/base/models/model_metadata.py

@@ -13,6 +13,8 @@ class ModelMetadata(TypedDict, total=False):
     preview: bool  # Whether model is in preview/beta (defaults to False)
     not_supported: bool  # Whether model is not supported or deprecated (defaults to False)
     deprecated: bool  # Whether model is deprecated (defaults to False)
+    default: bool  # Whether model is a default/recommended option (defaults to False)
+    model_type: str  # Type of model (defaults to "llm" or "embeddings")
 
 
 def create_model_metadata(
@@ -26,6 +28,8 @@ def create_model_metadata(
     preview: bool = False,
     not_supported: bool = False,
     deprecated: bool = False,
+    default: bool = False,
+    model_type: str = "llm",
 ) -> ModelMetadata:
     """Helper function to create ModelMetadata with explicit defaults."""
     return ModelMetadata(
@@ -38,4 +42,6 @@ def create_model_metadata(
         preview=preview,
         not_supported=not_supported,
         deprecated=deprecated,
+        default=default,
+        model_type=model_type,
     )

lfx/base/models/ollama_constants.py

@@ -1,3 +1,186 @@
+from .model_metadata import create_model_metadata
+
+# Unified model metadata - single source of truth
+OLLAMA_MODELS_DETAILED = [
+    # Tool Calling Models
+    create_model_metadata(
+        provider="Ollama",
+        name="llama3.3",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="qwq",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="llama3.2",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="llama3.1",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="mistral",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="qwen2",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="qwen2.5",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="qwen2.5-coder",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="mistral-nemo",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="mixtral",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="command-r",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="command-r-plus",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="mistral-large",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="smollm2",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="hermes3",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="athene-v2",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="mistral-small",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="nemotron-mini",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="nemotron",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="llama3-groq-tool-use",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="granite3-dense",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="granite3.1-dense",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="aya-expanse",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="granite3-moe",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="firefunction-v2",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="cogito",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="gpt-oss:20b",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+    create_model_metadata(
+        provider="Ollama",
+        name="qwen3-vl:4b",
+        icon="Ollama",
+        tool_calling=True,
+    ),
+]
+
+# Filter lists based on metadata properties
+OLLAMA_TOOL_MODELS_BASE = [
+    metadata["name"]
+    for metadata in OLLAMA_MODELS_DETAILED
+    if metadata.get("tool_calling", False) and not metadata.get("not_supported", False)
+]
+
+# Embedding models - following OpenAI's pattern of keeping these as a simple list
 # https://ollama.com/search?c=embedding
 OLLAMA_EMBEDDING_MODELS = [
     "nomic-embed-text",
@@ -10,37 +193,19 @@ OLLAMA_EMBEDDING_MODELS = [
     "granite-embedding",
     "jina-embeddings-v2-base-en",
 ]
-# https://ollama.com/search?c=tools
-OLLAMA_TOOL_MODELS_BASE = [
-    "llama3.3",
-    "qwq",
-    "llama3.2",
-    "llama3.1",
-    "mistral",
-    "qwen2",
-    "qwen2.5",
-    "qwen2.5-coder",
-    "mistral-nemo",
-    "mixtral",
-    "command-r",
-    "command-r-plus",
-    "mistral-large",
-    "smollm2",
-    "hermes3",
-    "athene-v2",
-    "mistral-small",
-    "nemotron-mini",
-    "nemotron",
-    "llama3-groq-tool-use",
-    "granite3-dense",
-    "granite3.1-dense",
-    "aya-expanse",
-    "granite3-moe",
-    "firefunction-v2",
-    "cogito",
-]
 
+# Embedding models as detailed metadata
+OLLAMA_EMBEDDING_MODELS_DETAILED = [
+    create_model_metadata(
+        provider="Ollama",
+        name=name,
+        icon="Ollama",
+        model_type="embeddings",
+    )
+    for name in OLLAMA_EMBEDDING_MODELS
+]
 
+# Connection URLs
 URL_LIST = [
     "http://localhost:11434",
     "http://host.docker.internal:11434",
@@ -48,5 +213,6 @@ URL_LIST = [
     "http://0.0.0.0:11434",
 ]
 
-
+# Backwards compatibility
+OLLAMA_MODEL_NAMES = OLLAMA_TOOL_MODELS_BASE
 DEFAULT_OLLAMA_API_URL = "https://ollama.com"