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

lfx/components/notdiamond/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.notdiamond.notdiamond import NotDiamondComponent
+
+_dynamic_imports = {
+    "NotDiamondComponent": "notdiamond",
+}
+
+__all__ = [
+    "NotDiamondComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import notdiamond 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/notdiamond/notdiamond.py

@@ -0,0 +1,228 @@
+import warnings
+
+import requests
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.chat_result import get_chat_result
+from lfx.base.models.model_utils import get_model_name
+from lfx.custom.custom_component.component import Component
+from lfx.io import (
+    BoolInput,
+    DropdownInput,
+    HandleInput,
+    MessageInput,
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+    StrInput,
+)
+from lfx.schema.message import Message
+
+ND_MODEL_MAPPING = {
+    "gpt-4o": {"provider": "openai", "model": "gpt-4o"},
+    "gpt-4o-mini": {"provider": "openai", "model": "gpt-4o-mini"},
+    "gpt-4-turbo": {"provider": "openai", "model": "gpt-4-turbo-2024-04-09"},
+    "claude-3-5-haiku-20241022": {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
+    "claude-3-5-sonnet-20241022": {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022"},
+    "anthropic.claude-3-5-sonnet-20241022-v2:0": {"provider": "anthropic", "model": "claude-3-5-sonnet-20241022"},
+    "anthropic.claude-3-5-haiku-20241022-v1:0": {"provider": "anthropic", "model": "claude-3-5-haiku-20241022"},
+    "gemini-1.5-pro": {"provider": "google", "model": "gemini-1.5-pro-latest"},
+    "gemini-1.5-flash": {"provider": "google", "model": "gemini-1.5-flash-latest"},
+    "llama-3.1-sonar-large-128k-online": {"provider": "perplexity", "model": "llama-3.1-sonar-large-128k-online"},
+    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
+        "provider": "togetherai",
+        "model": "Meta-Llama-3.1-70B-Instruct-Turbo",
+    },
+    "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo": {
+        "provider": "togetherai",
+        "model": "Meta-Llama-3.1-405B-Instruct-Turbo",
+    },
+    "mistral-large-latest": {"provider": "mistral", "model": "mistral-large-2407"},
+}
+
+
+class NotDiamondComponent(Component):
+    display_name = "Not Diamond Router"
+    description = "Call the right model at the right time with the world's most powerful AI model router."
+    documentation: str = "https://docs.notdiamond.ai/"
+    icon = "NotDiamond"
+    name = "NotDiamond"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._selected_model_name = None
+
+    inputs = [
+        MessageInput(name="input_value", display_name="Input", required=True),
+        MessageTextInput(
+            name="system_message",
+            display_name="System Message",
+            info="System message to pass to the model.",
+            advanced=False,
+        ),
+        HandleInput(
+            name="models",
+            display_name="Language Models",
+            input_types=["LanguageModel"],
+            required=True,
+            is_list=True,
+            info="Link the models you want to route between.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Not Diamond API Key",
+            info="The Not Diamond API Key to use for routing.",
+            advanced=False,
+            value="NOTDIAMOND_API_KEY",
+            required=True,
+        ),
+        StrInput(
+            name="preference_id",
+            display_name="Preference ID",
+            info="The ID of the router preference that was configured via the Dashboard.",
+            advanced=False,
+        ),
+        DropdownInput(
+            name="tradeoff",
+            display_name="Tradeoff",
+            info="The tradeoff between cost and latency for the router to determine the best LLM for a given query.",
+            advanced=False,
+            options=["quality", "cost", "latency"],
+            value="quality",
+        ),
+        BoolInput(
+            name="hash_content",
+            display_name="Hash Content",
+            info="Whether to hash the content before being sent to the NotDiamond API.",
+            advanced=False,
+            value=False,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Output", name="output", method="model_select"),
+        Output(
+            display_name="Selected Model",
+            name="selected_model",
+            method="get_selected_model",
+            required_inputs=["output"],
+        ),
+    ]
+
+    def get_selected_model(self) -> str:
+        return self._selected_model_name
+
+    def model_select(self) -> Message:
+        api_key = SecretStr(self.api_key).get_secret_value() if self.api_key else None
+        input_value = self.input_value
+        system_message = self.system_message
+        messages = self._format_input(input_value, system_message)
+
+        selected_models = []
+        mapped_selected_models = []
+        for model in self.models:
+            model_name = get_model_name(model)
+
+            if model_name in ND_MODEL_MAPPING:
+                selected_models.append(model)
+                mapped_selected_models.append(ND_MODEL_MAPPING[model_name])
+
+        payload = {
+            "messages": messages,
+            "llm_providers": mapped_selected_models,
+            "hash_content": self.hash_content,
+        }
+
+        if self.tradeoff != "quality":
+            payload["tradeoff"] = self.tradeoff
+
+        if self.preference_id and self.preference_id != "":
+            payload["preference_id"] = self.preference_id
+
+        header = {
+            "Authorization": f"Bearer {api_key}",
+            "accept": "application/json",
+            "content-type": "application/json",
+        }
+
+        response = requests.post(
+            "https://api.notdiamond.ai/v2/modelRouter/modelSelect",
+            json=payload,
+            headers=header,
+            timeout=10,
+        )
+
+        result = response.json()
+        chosen_model = self.models[0]  # By default there is a fallback model
+        self._selected_model_name = get_model_name(chosen_model)
+
+        if "providers" not in result:
+            # No provider returned by NotDiamond API, likely failed. Fallback to first model.
+            return self._call_get_chat_result(chosen_model, input_value, system_message)
+
+        providers = result["providers"]
+
+        if len(providers) == 0:
+            # No provider returned by NotDiamond API, likely failed. Fallback to first model.
+            return self._call_get_chat_result(chosen_model, input_value, system_message)
+
+        nd_result = providers[0]
+
+        for nd_model, selected_model in zip(mapped_selected_models, selected_models, strict=False):
+            if nd_model["provider"] == nd_result["provider"] and nd_model["model"] == nd_result["model"]:
+                chosen_model = selected_model
+                self._selected_model_name = get_model_name(chosen_model)
+                break
+
+        return self._call_get_chat_result(chosen_model, input_value, system_message)
+
+    def _call_get_chat_result(self, chosen_model, input_value, system_message):
+        return get_chat_result(
+            runnable=chosen_model,
+            input_value=input_value,
+            system_message=system_message,
+        )
+
+    def _format_input(
+        self,
+        input_value: str | Message,
+        system_message: str | None = None,
+    ):
+        messages: list[BaseMessage] = []
+        if not input_value and not system_message:
+            msg = "The message you want to send to the router is empty."
+            raise ValueError(msg)
+        system_message_added = False
+        if input_value:
+            if isinstance(input_value, Message):
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    if "prompt" in input_value:
+                        prompt = input_value.load_lc_prompt()
+                        if system_message:
+                            prompt.messages = [
+                                SystemMessage(content=system_message),
+                                *prompt.messages,  # type: ignore[has-type]
+                            ]
+                            system_message_added = True
+                        messages.extend(prompt.messages)
+                    else:
+                        messages.append(input_value.to_lc_message())
+            else:
+                messages.append(HumanMessage(content=input_value))
+
+        if system_message and not system_message_added:
+            messages.insert(0, SystemMessage(content=system_message))
+
+        # Convert Langchain messages to OpenAI format
+        openai_messages = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                openai_messages.append({"role": "user", "content": msg.content})
+            elif isinstance(msg, AIMessage):
+                openai_messages.append({"role": "assistant", "content": msg.content})
+            elif isinstance(msg, SystemMessage):
+                openai_messages.append({"role": "system", "content": msg.content})
+
+        return openai_messages

lfx/components/novita/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.novita.novita import NovitaModelComponent
+
+_dynamic_imports = {
+    "NovitaModelComponent": "novita",
+}
+
+__all__ = ["NovitaModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import novita 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/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,151 @@
+from typing import Any
+
+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 Exception as e:  # noqa: BLE001
+        logger.warning(f"Failed to fetch NVIDIA models during initialization: {e}. Model list will be unavailable.")
+        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=sorted(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 sorted(m.id for m in tool_models)
+        return sorted(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,
+        )