lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/base/models/model_input_constants.py

@@ -0,0 +1,378 @@
+from typing_extensions import TypedDict
+
+from lfx.base.models.model import LCModelComponent
+from lfx.inputs.inputs import InputTypes, SecretStrInput
+from lfx.template.field.base import Input
+
+
+class ModelProvidersDict(TypedDict):
+    fields: dict
+    inputs: list[InputTypes]
+    prefix: str
+    component_class: LCModelComponent
+    icon: str
+    is_active: bool
+
+
+def get_filtered_inputs(component_class, provider_name: str | None = None):
+    base_input_names = {field.name for field in LCModelComponent.get_base_inputs()}
+    component_instance = component_class()
+
+    return [
+        process_inputs(input_, provider_name)
+        for input_ in component_instance.inputs
+        if input_.name not in base_input_names
+    ]
+
+
+def process_inputs(component_data: Input, provider_name: str | None = None):
+    """Processes and modifies an input configuration based on its type or name.
+
+    Adjusts properties such as value, advanced status, real-time refresh, and additional information for specific
+    input types or names to ensure correct behavior in the UI and provider integration.
+
+    Args:
+        component_data: The input configuration to process.
+        provider_name: The name of the provider to process the inputs for.
+
+    Returns:
+        The modified input configuration.
+    """
+    if isinstance(component_data, SecretStrInput):
+        component_data.value = ""
+        component_data.load_from_db = False
+        component_data.real_time_refresh = True
+        if component_data.name == "api_key":
+            component_data.required = False
+    elif component_data.name == "tool_model_enabled":
+        component_data.advanced = True
+        component_data.value = True
+    elif component_data.name in {"temperature", "base_url"}:
+        if provider_name not in ["IBM watsonx.ai", "Ollama"]:
+            component_data = set_advanced_true(component_data)
+    elif component_data.name == "model_name":
+        if provider_name not in ["IBM watsonx.ai"]:
+            component_data = set_real_time_refresh_false(component_data)
+        component_data = add_combobox_true(component_data)
+        component_data = add_info(
+            component_data,
+            "To see the model names, first choose a provider. Then, enter your API key and click the refresh button "
+            "next to the model name.",
+        )
+    return component_data
+
+
+def set_advanced_true(component_input):
+    component_input.advanced = True
+    return component_input
+
+
+def set_real_time_refresh_false(component_input):
+    component_input.real_time_refresh = False
+    return component_input
+
+
+def add_info(component_input, info_str: str):
+    component_input.info = info_str
+    return component_input
+
+
+def add_combobox_true(component_input):
+    component_input.combobox = True
+    return component_input
+
+
+def create_input_fields_dict(inputs: list[Input], prefix: str) -> dict[str, Input]:
+    return {f"{prefix}{input_.name}": input_.to_dict() for input_ in inputs}
+
+
+def _get_ollama_inputs_and_fields():
+    try:
+        from lfx.components.ollama.ollama import ChatOllamaComponent
+
+        ollama_inputs = get_filtered_inputs(ChatOllamaComponent, provider_name="Ollama")
+    except ImportError as e:
+        msg = "Ollama is not installed. Please install it with `pip install langchain-ollama`."
+        raise ImportError(msg) from e
+    return ollama_inputs, create_input_fields_dict(ollama_inputs, "")
+
+
+def _get_watsonx_inputs_and_fields():
+    try:
+        from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+        watsonx_inputs = get_filtered_inputs(WatsonxAIComponent, provider_name="IBM watsonx.ai")
+    except ImportError as e:
+        msg = "IBM watsonx.ai is not installed. Please install it with `pip install langchain-ibm-watsonx`."
+        raise ImportError(msg) from e
+    return watsonx_inputs, create_input_fields_dict(watsonx_inputs, "")
+
+
+def _get_google_generative_ai_inputs_and_fields():
+    try:
+        from lfx.components.google.google_generative_ai import GoogleGenerativeAIComponent
+
+        google_generative_ai_inputs = get_filtered_inputs(GoogleGenerativeAIComponent)
+    except ImportError as e:
+        msg = (
+            "Google Generative AI is not installed. Please install it with "
+            "`pip install langchain-google-generative-ai`."
+        )
+        raise ImportError(msg) from e
+    return google_generative_ai_inputs, create_input_fields_dict(google_generative_ai_inputs, "")
+
+
+def _get_openai_inputs_and_fields():
+    try:
+        from lfx.components.openai.openai_chat_model import OpenAIModelComponent
+
+        openai_inputs = get_filtered_inputs(OpenAIModelComponent)
+    except ImportError as e:
+        msg = "OpenAI is not installed. Please install it with `pip install langchain-openai`."
+        raise ImportError(msg) from e
+    return openai_inputs, create_input_fields_dict(openai_inputs, "")
+
+
+def _get_azure_inputs_and_fields():
+    try:
+        from lfx.components.azure.azure_openai import AzureChatOpenAIComponent
+
+        azure_inputs = get_filtered_inputs(AzureChatOpenAIComponent)
+    except ImportError as e:
+        msg = "Azure OpenAI is not installed. Please install it with `pip install langchain-azure-openai`."
+        raise ImportError(msg) from e
+    return azure_inputs, create_input_fields_dict(azure_inputs, "")
+
+
+def _get_groq_inputs_and_fields():
+    try:
+        from lfx.components.groq.groq import GroqModel
+
+        groq_inputs = get_filtered_inputs(GroqModel)
+    except ImportError as e:
+        msg = "Groq is not installed. Please install it with `pip install langchain-groq`."
+        raise ImportError(msg) from e
+    return groq_inputs, create_input_fields_dict(groq_inputs, "")
+
+
+def _get_anthropic_inputs_and_fields():
+    try:
+        from lfx.components.anthropic.anthropic import AnthropicModelComponent
+
+        anthropic_inputs = get_filtered_inputs(AnthropicModelComponent)
+    except ImportError as e:
+        msg = "Anthropic is not installed. Please install it with `pip install langchain-anthropic`."
+        raise ImportError(msg) from e
+    return anthropic_inputs, create_input_fields_dict(anthropic_inputs, "")
+
+
+def _get_nvidia_inputs_and_fields():
+    try:
+        from lfx.components.nvidia.nvidia import NVIDIAModelComponent
+
+        nvidia_inputs = get_filtered_inputs(NVIDIAModelComponent)
+    except ImportError as e:
+        msg = "NVIDIA is not installed. Please install it with `pip install langchain-nvidia`."
+        raise ImportError(msg) from e
+    return nvidia_inputs, create_input_fields_dict(nvidia_inputs, "")
+
+
+def _get_amazon_bedrock_inputs_and_fields():
+    try:
+        from lfx.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
+
+        amazon_bedrock_inputs = get_filtered_inputs(AmazonBedrockComponent)
+    except ImportError as e:
+        msg = "Amazon Bedrock is not installed. Please install it with `pip install langchain-amazon-bedrock`."
+        raise ImportError(msg) from e
+    return amazon_bedrock_inputs, create_input_fields_dict(amazon_bedrock_inputs, "")
+
+
+def _get_sambanova_inputs_and_fields():
+    try:
+        from lfx.components.sambanova.sambanova import SambaNovaComponent
+
+        sambanova_inputs = get_filtered_inputs(SambaNovaComponent)
+    except ImportError as e:
+        msg = "SambaNova is not installed. Please install it with `pip install langchain-sambanova`."
+        raise ImportError(msg) from e
+    return sambanova_inputs, create_input_fields_dict(sambanova_inputs, "")
+
+
+MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {}
+
+# Try to add each provider
+try:
+    from lfx.components.openai.openai_chat_model import OpenAIModelComponent
+
+    openai_inputs, openai_fields = _get_openai_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["OpenAI"] = {
+        "fields": openai_fields,
+        "inputs": openai_inputs,
+        "prefix": "",
+        "component_class": OpenAIModelComponent(),
+        "icon": OpenAIModelComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.azure.azure_openai import AzureChatOpenAIComponent
+
+    azure_inputs, azure_fields = _get_azure_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Azure OpenAI"] = {
+        "fields": azure_fields,
+        "inputs": azure_inputs,
+        "prefix": "",
+        "component_class": AzureChatOpenAIComponent(),
+        "icon": AzureChatOpenAIComponent.icon,
+        "is_active": False,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.groq.groq import GroqModel
+
+    groq_inputs, groq_fields = _get_groq_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Groq"] = {
+        "fields": groq_fields,
+        "inputs": groq_inputs,
+        "prefix": "",
+        "component_class": GroqModel(),
+        "icon": GroqModel.icon,
+        "is_active": False,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.anthropic.anthropic import AnthropicModelComponent
+
+    anthropic_inputs, anthropic_fields = _get_anthropic_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Anthropic"] = {
+        "fields": anthropic_fields,
+        "inputs": anthropic_inputs,
+        "prefix": "",
+        "component_class": AnthropicModelComponent(),
+        "icon": AnthropicModelComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.nvidia.nvidia import NVIDIAModelComponent
+
+    nvidia_inputs, nvidia_fields = _get_nvidia_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["NVIDIA"] = {
+        "fields": nvidia_fields,
+        "inputs": nvidia_inputs,
+        "prefix": "",
+        "component_class": NVIDIAModelComponent(),
+        "icon": NVIDIAModelComponent.icon,
+        "is_active": False,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
+
+    bedrock_inputs, bedrock_fields = _get_amazon_bedrock_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Amazon Bedrock"] = {
+        "fields": bedrock_fields,
+        "inputs": bedrock_inputs,
+        "prefix": "",
+        "component_class": AmazonBedrockComponent(),
+        "icon": AmazonBedrockComponent.icon,
+        "is_active": False,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.google.google_generative_ai import GoogleGenerativeAIComponent
+
+    google_generative_ai_inputs, google_generative_ai_fields = _get_google_generative_ai_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Google Generative AI"] = {
+        "fields": google_generative_ai_fields,
+        "inputs": google_generative_ai_inputs,
+        "prefix": "",
+        "component_class": GoogleGenerativeAIComponent(),
+        "icon": GoogleGenerativeAIComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.sambanova.sambanova import SambaNovaComponent
+
+    sambanova_inputs, sambanova_fields = _get_sambanova_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["SambaNova"] = {
+        "fields": sambanova_fields,
+        "inputs": sambanova_inputs,
+        "prefix": "",
+        "component_class": SambaNovaComponent(),
+        "icon": SambaNovaComponent.icon,
+        "is_active": False,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+    watsonx_inputs, watsonx_fields = _get_watsonx_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["IBM watsonx.ai"] = {
+        "fields": watsonx_fields,
+        "inputs": watsonx_inputs,
+        "prefix": "",
+        "component_class": WatsonxAIComponent(),
+        "icon": WatsonxAIComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.ollama.ollama import ChatOllamaComponent
+
+    ollama_inputs, ollama_fields = _get_ollama_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Ollama"] = {
+        "fields": ollama_fields,
+        "inputs": ollama_inputs,
+        "prefix": "",
+        "component_class": ChatOllamaComponent(),
+        "icon": ChatOllamaComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+# Expose only active providers ----------------------------------------------
+ACTIVE_MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {
+    name: prov for name, prov in MODEL_PROVIDERS_DICT.items() if prov.get("is_active", True)
+}
+
+MODEL_PROVIDERS: list[str] = list(ACTIVE_MODEL_PROVIDERS_DICT.keys())
+
+ALL_PROVIDER_FIELDS: list[str] = [field for prov in ACTIVE_MODEL_PROVIDERS_DICT.values() for field in prov["fields"]]
+
+MODEL_DYNAMIC_UPDATE_FIELDS = [
+    "api_key",
+    "model",
+    "tool_model_enabled",
+    "base_url",
+    "model_name",
+    "watsonx_endpoint",
+    "url",
+]
+
+MODELS_METADATA = {name: {"icon": prov["icon"]} for name, prov in ACTIVE_MODEL_PROVIDERS_DICT.items()}
+
+MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI", "IBM watsonx.ai", "Ollama"]
+
+MODEL_OPTIONS_METADATA = [MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA]

lfx/base/models/model_metadata.py

@@ -0,0 +1,41 @@
+from typing import TypedDict
+
+
+class ModelMetadata(TypedDict, total=False):
+    """Simple model metadata structure."""
+
+    provider: str  # Provider name (e.g., "anthropic", "groq", "openai")
+    name: str  # Model name/ID
+    icon: str  # Icon name for UI
+    tool_calling: bool  # Whether model supports tool calling (defaults to False)
+    reasoning: bool  # Reasoning models (defaults to False)
+    search: bool  # Search models (defaults to 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)
+
+
+def create_model_metadata(
+    provider: str,
+    name: str,
+    icon: str,
+    *,
+    tool_calling: bool = False,
+    reasoning: bool = False,
+    search: bool = False,
+    preview: bool = False,
+    not_supported: bool = False,
+    deprecated: bool = False,
+) -> ModelMetadata:
+    """Helper function to create ModelMetadata with explicit defaults."""
+    return ModelMetadata(
+        provider=provider,
+        name=name,
+        icon=icon,
+        tool_calling=tool_calling,
+        reasoning=reasoning,
+        search=search,
+        preview=preview,
+        not_supported=not_supported,
+        deprecated=deprecated,
+    )

lfx/base/models/model_utils.py

@@ -0,0 +1,108 @@
+import asyncio
+from urllib.parse import urljoin
+
+import httpx
+
+from lfx.log.logger import logger
+from lfx.utils.util import transform_localhost_url
+
+HTTP_STATUS_OK = 200
+
+
+def get_model_name(llm, display_name: str | None = "Custom"):
+    attributes_to_check = ["model_name", "model", "model_id", "deployment_name"]
+
+    # Use a generator expression with next() to find the first matching attribute
+    model_name = next((getattr(llm, attr) for attr in attributes_to_check if hasattr(llm, attr)), None)
+
+    # If no matching attribute is found, return the class name as a fallback
+    return model_name if model_name is not None else display_name
+
+
+async def is_valid_ollama_url(url: str) -> bool:
+    """Check if the provided URL is a valid Ollama API endpoint."""
+    try:
+        url = transform_localhost_url(url)
+        if not url:
+            return False
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        url = url.rstrip("/").removesuffix("/v1")
+        if not url.endswith("/"):
+            url = url + "/"
+        async with httpx.AsyncClient() as client:
+            return (await client.get(url=urljoin(url, "api/tags"))).status_code == HTTP_STATUS_OK
+    except httpx.RequestError:
+        logger.debug(f"Invalid Ollama URL: {url}")
+        return False
+
+
+async def get_ollama_models(
+    base_url_value: str, desired_capability: str, json_models_key: str, json_name_key: str, json_capabilities_key: str
+) -> list[str]:
+    """Fetch available completion models from the Ollama API.
+
+    Filters out embedding models and only returns models with completion capability.
+
+    Args:
+        base_url_value (str): The base URL of the Ollama API.
+        desired_capability (str): The desired capability of the model.
+        json_models_key (str): The key in the JSON response that contains the models.
+        json_name_key (str): The key in the JSON response that contains the model names.
+        json_capabilities_key (str): The key in the JSON response that contains the model capabilities.
+
+    Returns:
+        list[str]: A sorted list of model names that support completion.
+
+    Raises:
+        ValueError: If there is an issue with the API request or response.
+    """
+    try:
+        # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+        base_url = base_url_value.rstrip("/").removesuffix("/v1")
+        if not base_url.endswith("/"):
+            base_url = base_url + "/"
+        base_url = transform_localhost_url(base_url)
+
+        # Ollama REST API to return models
+        tags_url = urljoin(base_url, "api/tags")
+
+        # Ollama REST API to return model capabilities
+        show_url = urljoin(base_url, "api/show")
+        tags_response = None
+
+        async with httpx.AsyncClient() as client:
+            # Fetch available models
+            tags_response = await client.get(url=tags_url)
+            tags_response.raise_for_status()
+            models = tags_response.json()
+            if asyncio.iscoroutine(models):
+                models = await models
+            await logger.adebug(f"Available models: {models}")
+
+            # Filter models that are NOT embedding models
+            model_ids = []
+            for model in models.get(json_models_key, []):
+                model_name = model.get(json_name_key)
+                if not model_name:
+                    continue
+                await logger.adebug(f"Checking model: {model_name}")
+
+                payload = {"model": model_name}
+                show_response = await client.post(url=show_url, json=payload)
+                show_response.raise_for_status()
+                json_data = show_response.json()
+                if asyncio.iscoroutine(json_data):
+                    json_data = await json_data
+
+                capabilities = json_data.get(json_capabilities_key, [])
+                await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
+
+                if desired_capability in capabilities:
+                    model_ids.append(model_name)
+
+            return sorted(model_ids)
+
+    except (httpx.RequestError, ValueError) as e:
+        msg = "Could not get model names from Ollama."
+        await logger.aexception(msg)
+        raise ValueError(msg) from e

lfx/base/models/novita_constants.py

@@ -0,0 +1,35 @@
+NOVITA_MODELS = [
+    "deepseek/deepseek-r1",
+    "deepseek/deepseek_v3",
+    "meta-llama/llama-3.3-70b-instruct",
+    "meta-llama/llama-3.1-8b-instruct",
+    "meta-llama/llama-3.1-70b-instruct",
+    "mistralai/mistral-nemo",
+    "Sao10K/L3-8B-Stheno-v3.2",
+    "gryphe/mythomax-l2-13b",
+    "qwen/qwen-2.5-72b-instruct",
+    "meta-llama/llama-3-8b-instruct",
+    "microsoft/wizardlm-2-8x22b",
+    "google/gemma-2-9b-it",
+    "mistralai/mistral-7b-instruct",
+    "meta-llama/llama-3-70b-instruct",
+    "openchat/openchat-7b",
+    "nousresearch/hermes-2-pro-llama-3-8b",
+    "sao10k/l3-70b-euryale-v2.1",
+    "cognitivecomputations/dolphin-mixtral-8x22b",
+    "jondurbin/airoboros-l2-70b",
+    "nousresearch/nous-hermes-llama2-13b",
+    "teknium/openhermes-2.5-mistral-7b",
+    "sophosympatheia/midnight-rose-70b",
+    "meta-llama/llama-3.1-8b-instruct-max",
+    "sao10k/l3-8b-lunaris",
+    "qwen/qwen-2-vl-72b-instruct",
+    "meta-llama/llama-3.2-1b-instruct",
+    "meta-llama/llama-3.2-11b-vision-instruct",
+    "meta-llama/llama-3.2-3b-instruct",
+    "meta-llama/llama-3.1-8b-instruct-bf16",
+    "sao10k/l31-70b-euryale-v2.2",
+    "qwen/qwen-2-7b-instruct",
+    "qwen/qwen-2-72b-instruct",
+]
+MODEL_NAMES = NOVITA_MODELS  # reverse compatibility

lfx/base/models/ollama_constants.py

@@ -0,0 +1,52 @@
+# https://ollama.com/search?c=embedding
+OLLAMA_EMBEDDING_MODELS = [
+    "nomic-embed-text",
+    "mxbai-embed-large",
+    "snowflake-arctic-embed",
+    "all-minilm",
+    "bge-m3",
+    "bge-large",
+    "paraphrase-multilingual",
+    "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",
+]
+
+
+URL_LIST = [
+    "http://localhost:11434",
+    "http://host.docker.internal:11434",
+    "http://127.0.0.1:11434",
+    "http://0.0.0.0:11434",
+]
+
+
+DEFAULT_OLLAMA_API_URL = "https://ollama.com"