lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/novita/novita.py

@@ -0,0 +1,130 @@
+import requests
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.novita_constants import MODEL_NAMES
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    SecretStrInput,
+    SliderInput,
+)
+
+
+class NovitaModelComponent(LCModelComponent):
+    display_name = "Novita AI"
+    description = "Generates text using Novita AI LLMs (OpenAI compatible)."
+    icon = "Novita"
+    name = "NovitaModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=MODEL_NAMES,
+            value=MODEL_NAMES[0],
+            refresh_button=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Novita API Key",
+            info="The Novita API Key to use for Novita AI models.",
+            advanced=False,
+            value="NOVITA_API_KEY",
+            real_time_refresh=True,
+        ),
+        SliderInput(name="temperature", display_name="Temperature", value=0.1, range_spec=RangeSpec(min=0, max=1)),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+        HandleInput(
+            name="output_parser",
+            display_name="Output Parser",
+            info="The parser to use to parse the output of the model",
+            advanced=True,
+            input_types=["OutputParser"],
+        ),
+    ]
+
+    def get_models(self) -> list[str]:
+        base_url = "https://api.novita.ai/v3/openai"
+        url = f"{base_url}/models"
+
+        headers = {"Content-Type": "application/json"}
+
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            model_list = response.json()
+            return [model["id"] for model in model_list.get("data", [])]
+        except requests.RequestException as e:
+            self.status = f"Error fetching models: {e}"
+            return MODEL_NAMES
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name in {"api_key", "model_name"}:
+            models = self.get_models()
+            build_config["model_name"]["options"] = models
+        return build_config
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        model_kwargs = self.model_kwargs or {}
+        json_mode = self.json_mode
+        seed = self.seed
+
+        try:
+            output = ChatOpenAI(
+                model=model_name,
+                api_key=(SecretStr(api_key).get_secret_value() if api_key else None),
+                max_tokens=max_tokens or None,
+                temperature=temperature,
+                model_kwargs=model_kwargs,
+                streaming=self.stream,
+                seed=seed,
+                base_url="https://api.novita.ai/v3/openai",
+            )
+        except Exception as e:
+            msg = "Could not connect to Novita API."
+            raise ValueError(msg) from e
+
+        if json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output

lfx/components/nvidia/__init__.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .nvidia import NVIDIAModelComponent
+    from .nvidia_embedding import NVIDIAEmbeddingsComponent
+    from .nvidia_ingest import NvidiaIngestComponent
+    from .nvidia_rerank import NvidiaRerankComponent
+
+    if sys.platform == "win32":
+        from .system_assist import NvidiaSystemAssistComponent
+
+_dynamic_imports = {
+    "NVIDIAModelComponent": "nvidia",
+    "NVIDIAEmbeddingsComponent": "nvidia_embedding",
+    "NvidiaIngestComponent": "nvidia_ingest",
+    "NvidiaRerankComponent": "nvidia_rerank",
+}
+
+if sys.platform == "win32":
+    _dynamic_imports["NvidiaSystemAssistComponent"] = "system_assist"
+    __all__ = [
+        "NVIDIAEmbeddingsComponent",
+        "NVIDIAModelComponent",
+        "NvidiaIngestComponent",
+        "NvidiaRerankComponent",
+        "NvidiaSystemAssistComponent",
+    ]
+else:
+    __all__ = [
+        "NVIDIAEmbeddingsComponent",
+        "NVIDIAModelComponent",
+        "NvidiaIngestComponent",
+        "NvidiaRerankComponent",
+    ]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import nvidia components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/nvidia/nvidia.py

@@ -0,0 +1,157 @@
+from typing import Any
+
+from requests.exceptions import ConnectionError  # noqa: A004
+from urllib3.exceptions import MaxRetryError, NameResolutionError
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+
+
+class NVIDIAModelComponent(LCModelComponent):
+    display_name = "NVIDIA"
+    description = "Generates text using NVIDIA LLMs."
+    icon = "NVIDIA"
+
+    try:
+        import warnings
+
+        # Suppresses repeated warnings about NIM key in langchain_nvidia_ai_endpoints==0.3.8
+        warnings.filterwarnings("ignore", category=UserWarning, module="langchain_nvidia_ai_endpoints._common")
+        from langchain_nvidia_ai_endpoints import ChatNVIDIA
+
+        all_models = ChatNVIDIA().get_available_models()
+    except ImportError as e:
+        msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
+        raise ImportError(msg) from e
+    except (ConnectionError, MaxRetryError, NameResolutionError):
+        logger.warning(
+            "Failed to connect to NVIDIA API. Model list may be unavailable."
+            " Please check your internet connection and API credentials."
+        )
+        all_models = []
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            info="The name of the NVIDIA model to use.",
+            advanced=False,
+            value=None,
+            options=[model.id for model in all_models],
+            combobox=True,
+            refresh_button=True,
+        ),
+        BoolInput(
+            name="detailed_thinking",
+            display_name="Detailed Thinking",
+            info="If true, the model will return a detailed thought process. Only supported by reasoning models.",
+            value=False,
+            show=False,
+        ),
+        BoolInput(
+            name="tool_model_enabled",
+            display_name="Enable Tool Models",
+            info="If enabled, only show models that support tool-calling.",
+            advanced=False,
+            value=False,
+            real_time_refresh=True,
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="NVIDIA Base URL",
+            value="https://integrate.api.nvidia.com/v1",
+            info="The base URL of the NVIDIA API. Defaults to https://integrate.api.nvidia.com/v1.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="NVIDIA API Key",
+            info="The NVIDIA API Key.",
+            advanced=False,
+            value="NVIDIA_API_KEY",
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Run inference with this temperature.",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+    ]
+
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        try:
+            from langchain_nvidia_ai_endpoints import ChatNVIDIA
+        except ImportError as e:
+            msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
+            raise ImportError(msg) from e
+
+        # Note: don't include the previous model, as it may not exist in available models from the new base url
+        model = ChatNVIDIA(base_url=self.base_url, api_key=self.api_key)
+        if tool_model_enabled:
+            tool_models = [m for m in model.get_available_models() if m.supports_tools]
+            return [m.id for m in tool_models]
+        return [m.id for m in model.available_models]
+
+    def update_build_config(self, build_config: dotdict, _field_value: Any, field_name: str | None = None):
+        if field_name in {"model_name", "tool_model_enabled", "base_url", "api_key"}:
+            try:
+                ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
+                build_config["model_name"]["options"] = ids
+
+                if "value" not in build_config["model_name"] or build_config["model_name"]["value"] is None:
+                    build_config["model_name"]["value"] = ids[0]
+                elif build_config["model_name"]["value"] not in ids:
+                    build_config["model_name"]["value"] = None
+
+                # TODO: use api to determine if model supports detailed thinking
+                if build_config["model_name"]["value"] == "nemotron":
+                    build_config["detailed_thinking"]["show"] = True
+                else:
+                    build_config["detailed_thinking"]["value"] = False
+                    build_config["detailed_thinking"]["show"] = False
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                build_config["model_name"]["value"] = None
+                build_config["model_name"]["options"] = []
+                raise ValueError(msg) from e
+
+        return build_config
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_nvidia_ai_endpoints import ChatNVIDIA
+        except ImportError as e:
+            msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
+            raise ImportError(msg) from e
+        api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        seed = self.seed
+        return ChatNVIDIA(
+            max_tokens=max_tokens or None,
+            model=model_name,
+            base_url=self.base_url,
+            api_key=api_key,
+            temperature=temperature or 0.1,
+            seed=seed,
+        )

lfx/components/nvidia/nvidia_embedding.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.inputs.inputs import DropdownInput, SecretStrInput
+from lfx.io import FloatInput, MessageTextInput
+from lfx.schema.dotdict import dotdict
+
+
+class NVIDIAEmbeddingsComponent(LCEmbeddingsModel):
+    display_name: str = "NVIDIA Embeddings"
+    description: str = "Generate embeddings using NVIDIA models."
+    icon = "NVIDIA"
+
+    inputs = [
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            options=[
+                "nvidia/nv-embed-v1",
+                "snowflake/arctic-embed-I",
+            ],
+            value="nvidia/nv-embed-v1",
+            required=True,
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="NVIDIA Base URL",
+            refresh_button=True,
+            value="https://integrate.api.nvidia.com/v1",
+            required=True,
+        ),
+        SecretStrInput(
+            name="nvidia_api_key",
+            display_name="NVIDIA API Key",
+            info="The NVIDIA API Key.",
+            advanced=False,
+            value="NVIDIA_API_KEY",
+            required=True,
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Model Temperature",
+            value=0.1,
+            advanced=True,
+        ),
+    ]
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name == "base_url" and field_value:
+            try:
+                build_model = self.build_embeddings()
+                ids = [model.id for model in build_model.available_models]
+                build_config["model"]["options"] = ids
+                build_config["model"]["value"] = ids[0]
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                raise ValueError(msg) from e
+        return build_config
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
+        except ImportError as e:
+            msg = "Please install langchain-nvidia-ai-endpoints to use the Nvidia model."
+            raise ImportError(msg) from e
+        try:
+            output = NVIDIAEmbeddings(
+                model=self.model,
+                base_url=self.base_url,
+                temperature=self.temperature,
+                nvidia_api_key=self.nvidia_api_key,
+            )
+        except Exception as e:
+            msg = f"Could not connect to NVIDIA API. Error: {e}"
+            raise ValueError(msg) from e
+        return output