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

lfx/components/mistral/mistral.py

@@ -0,0 +1,114 @@
+from langchain_mistralai import ChatMistralAI
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.io import BoolInput, DropdownInput, FloatInput, IntInput, SecretStrInput, StrInput
+
+
+class MistralAIModelComponent(LCModelComponent):
+    display_name = "MistralAI"
+    description = "Generates text using MistralAI LLMs."
+    icon = "MistralAI"
+    name = "MistralModel"
+
+    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",
+            advanced=False,
+            options=[
+                "open-mixtral-8x7b",
+                "open-mixtral-8x22b",
+                "mistral-small-latest",
+                "mistral-medium-latest",
+                "mistral-large-latest",
+                "codestral-latest",
+            ],
+            value="codestral-latest",
+        ),
+        StrInput(
+            name="mistral_api_base",
+            display_name="Mistral API Base",
+            advanced=True,
+            info="The base URL of the Mistral API. Defaults to https://api.mistral.ai/v1. "
+            "You can change this to use other APIs like JinaChat, LocalAI and Prem.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Mistral API Key",
+            info="The Mistral API Key to use for the Mistral model.",
+            advanced=False,
+            required=True,
+            value="MISTRAL_API_KEY",
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            advanced=True,
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            advanced=True,
+            value=5,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            advanced=True,
+            value=60,
+        ),
+        IntInput(
+            name="max_concurrent_requests",
+            display_name="Max Concurrent Requests",
+            advanced=True,
+            value=3,
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            advanced=True,
+            value=1,
+        ),
+        IntInput(
+            name="random_seed",
+            display_name="Random Seed",
+            value=1,
+            advanced=True,
+        ),
+        BoolInput(
+            name="safe_mode",
+            display_name="Safe Mode",
+            advanced=True,
+            value=False,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            return ChatMistralAI(
+                model_name=self.model_name,
+                mistral_api_key=SecretStr(self.api_key).get_secret_value() if self.api_key else None,
+                endpoint=self.mistral_api_base or "https://api.mistral.ai/v1",
+                max_tokens=self.max_tokens or None,
+                temperature=self.temperature,
+                max_retries=self.max_retries,
+                timeout=self.timeout,
+                max_concurrent_requests=self.max_concurrent_requests,
+                top_p=self.top_p,
+                random_seed=self.random_seed,
+                safe_mode=self.safe_mode,
+                streaming=self.stream,
+            )
+        except Exception as e:
+            msg = "Could not connect to MistralAI API."
+            raise ValueError(msg) from e

lfx/components/mistral/mistral_embeddings.py

@@ -0,0 +1,58 @@
+from langchain_mistralai.embeddings import MistralAIEmbeddings
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import DropdownInput, IntInput, MessageTextInput, Output, SecretStrInput
+
+
+class MistralAIEmbeddingsComponent(LCModelComponent):
+    display_name = "MistralAI Embeddings"
+    description = "Generate embeddings using MistralAI models."
+    icon = "MistralAI"
+    name = "MistalAIEmbeddings"
+
+    inputs = [
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            advanced=False,
+            options=["mistral-embed"],
+            value="mistral-embed",
+        ),
+        SecretStrInput(name="mistral_api_key", display_name="Mistral API Key", required=True),
+        IntInput(
+            name="max_concurrent_requests",
+            display_name="Max Concurrent Requests",
+            advanced=True,
+            value=64,
+        ),
+        IntInput(name="max_retries", display_name="Max Retries", advanced=True, value=5),
+        IntInput(name="timeout", display_name="Request Timeout", advanced=True, value=120),
+        MessageTextInput(
+            name="endpoint",
+            display_name="API Endpoint",
+            advanced=True,
+            value="https://api.mistral.ai/v1/",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        if not self.mistral_api_key:
+            msg = "Mistral API Key is required"
+            raise ValueError(msg)
+
+        api_key = SecretStr(self.mistral_api_key).get_secret_value()
+
+        return MistralAIEmbeddings(
+            api_key=api_key,
+            model=self.model,
+            endpoint=self.endpoint,
+            max_concurrent_requests=self.max_concurrent_requests,
+            max_retries=self.max_retries,
+            timeout=self.timeout,
+        )

lfx/components/models/__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.models.embedding_model import EmbeddingModelComponent
+    from lfx.components.models.language_model import LanguageModelComponent
+
+_dynamic_imports = {
+    "EmbeddingModelComponent": "embedding_model",
+    "LanguageModelComponent": "language_model",
+}
+
+__all__ = ["EmbeddingModelComponent", "LanguageModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import model 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/models/embedding_model.py

@@ -0,0 +1,114 @@
+from typing import Any
+
+from langchain_openai import OpenAIEmbeddings
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.field_typing import Embeddings
+from lfx.io import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    FloatInput,
+    IntInput,
+    MessageTextInput,
+    SecretStrInput,
+)
+from lfx.schema.dotdict import dotdict
+
+
+class EmbeddingModelComponent(LCEmbeddingsModel):
+    display_name = "Embedding Model"
+    description = "Generate embeddings using a specified provider."
+    documentation: str = "https://docs.langflow.org/components-embedding-models"
+    icon = "binary"
+    name = "EmbeddingModel"
+    category = "models"
+
+    inputs = [
+        DropdownInput(
+            name="provider",
+            display_name="Model Provider",
+            options=["OpenAI"],
+            value="OpenAI",
+            info="Select the embedding model provider",
+            real_time_refresh=True,
+            options_metadata=[{"icon": "OpenAI"}],
+        ),
+        DropdownInput(
+            name="model",
+            display_name="Model Name",
+            options=OPENAI_EMBEDDING_MODEL_NAMES,
+            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
+            info="Select the embedding model to use",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="OpenAI API Key",
+            info="Model Provider API key",
+            required=True,
+            show=True,
+            real_time_refresh=True,
+        ),
+        MessageTextInput(
+            name="api_base",
+            display_name="API Base URL",
+            info="Base URL for the API. Leave empty for default.",
+            advanced=True,
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", advanced=True, value=3),
+        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        provider = self.provider
+        model = self.model
+        api_key = self.api_key
+        api_base = self.api_base
+        dimensions = self.dimensions
+        chunk_size = self.chunk_size
+        request_timeout = self.request_timeout
+        max_retries = self.max_retries
+        show_progress_bar = self.show_progress_bar
+        model_kwargs = self.model_kwargs or {}
+
+        if provider == "OpenAI":
+            if not api_key:
+                msg = "OpenAI API key is required when using OpenAI provider"
+                raise ValueError(msg)
+            return OpenAIEmbeddings(
+                model=model,
+                dimensions=dimensions or None,
+                base_url=api_base or None,
+                api_key=api_key,
+                chunk_size=chunk_size,
+                max_retries=max_retries,
+                timeout=request_timeout or None,
+                show_progress_bar=show_progress_bar,
+                model_kwargs=model_kwargs,
+            )
+        msg = f"Unknown provider: {provider}"
+        raise ValueError(msg)
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        if field_name == "provider" and field_value == "OpenAI":
+            build_config["model"]["options"] = OPENAI_EMBEDDING_MODEL_NAMES
+            build_config["model"]["value"] = OPENAI_EMBEDDING_MODEL_NAMES[0]
+            build_config["api_key"]["display_name"] = "OpenAI API Key"
+            build_config["api_base"]["display_name"] = "OpenAI API Base URL"
+        return build_config

lfx/components/models/language_model.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from langchain_anthropic import ChatAnthropic
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_openai import ChatOpenAI
+
+from lfx.base.models.anthropic_constants import ANTHROPIC_MODELS
+from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput
+from lfx.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
+from lfx.schema.dotdict import dotdict
+
+
+class LanguageModelComponent(LCModelComponent):
+    display_name = "Language Model"
+    description = "Runs a language model given a specified provider."
+    documentation: str = "https://docs.langflow.org/components-models"
+    icon = "brain-circuit"
+    category = "models"
+    priority = 0  # Set priority to 0 to make it appear first
+
+    inputs = [
+        DropdownInput(
+            name="provider",
+            display_name="Model Provider",
+            options=["OpenAI", "Anthropic", "Google"],
+            value="OpenAI",
+            info="Select the model provider",
+            real_time_refresh=True,
+            options_metadata=[{"icon": "OpenAI"}, {"icon": "Anthropic"}, {"icon": "GoogleGenerativeAI"}],
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
+            value=OPENAI_CHAT_MODEL_NAMES[0],
+            info="Select the model to use",
+            real_time_refresh=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="OpenAI API Key",
+            info="Model Provider API key",
+            required=False,
+            show=True,
+            real_time_refresh=True,
+        ),
+        MessageInput(
+            name="input_value",
+            display_name="Input",
+            info="The input text to send to the model",
+        ),
+        MultilineInput(
+            name="system_message",
+            display_name="System Message",
+            info="A system message that helps set the behavior of the assistant",
+            advanced=False,
+        ),
+        BoolInput(
+            name="stream",
+            display_name="Stream",
+            info="Whether to stream the response",
+            value=False,
+            advanced=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Controls randomness in responses",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:
+        provider = self.provider
+        model_name = self.model_name
+        temperature = self.temperature
+        stream = self.stream
+
+        if provider == "OpenAI":
+            if not self.api_key:
+                msg = "OpenAI API key is required when using OpenAI provider"
+                raise ValueError(msg)
+
+            if model_name in OPENAI_REASONING_MODEL_NAMES:
+                # reasoning models do not support temperature (yet)
+                temperature = None
+
+            return ChatOpenAI(
+                model_name=model_name,
+                temperature=temperature,
+                streaming=stream,
+                openai_api_key=self.api_key,
+            )
+        if provider == "Anthropic":
+            if not self.api_key:
+                msg = "Anthropic API key is required when using Anthropic provider"
+                raise ValueError(msg)
+            return ChatAnthropic(
+                model=model_name,
+                temperature=temperature,
+                streaming=stream,
+                anthropic_api_key=self.api_key,
+            )
+        if provider == "Google":
+            if not self.api_key:
+                msg = "Google API key is required when using Google provider"
+                raise ValueError(msg)
+            return ChatGoogleGenerativeAI(
+                model=model_name,
+                temperature=temperature,
+                streaming=stream,
+                google_api_key=self.api_key,
+            )
+        msg = f"Unknown provider: {provider}"
+        raise ValueError(msg)
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        if field_name == "provider":
+            if field_value == "OpenAI":
+                build_config["model_name"]["options"] = OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES
+                build_config["model_name"]["value"] = OPENAI_CHAT_MODEL_NAMES[0]
+                build_config["api_key"]["display_name"] = "OpenAI API Key"
+            elif field_value == "Anthropic":
+                build_config["model_name"]["options"] = ANTHROPIC_MODELS
+                build_config["model_name"]["value"] = ANTHROPIC_MODELS[0]
+                build_config["api_key"]["display_name"] = "Anthropic API Key"
+            elif field_value == "Google":
+                build_config["model_name"]["options"] = GOOGLE_GENERATIVE_AI_MODELS
+                build_config["model_name"]["value"] = GOOGLE_GENERATIVE_AI_MODELS[0]
+                build_config["api_key"]["display_name"] = "Google API Key"
+        elif field_name == "model_name" and field_value.startswith("o1") and self.provider == "OpenAI":
+            # Hide system_message for o1 models - currently unsupported
+            if "system_message" in build_config:
+                build_config["system_message"]["show"] = False
+        elif field_name == "model_name" and not field_value.startswith("o1") and "system_message" in build_config:
+            build_config["system_message"]["show"] = True
+        return build_config

lfx/components/mongodb/__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 .mongodb_atlas import MongoVectorStoreComponent
+
+_dynamic_imports = {
+    "MongoVectorStoreComponent": "mongodb_atlas",
+}
+
+__all__ = [
+    "MongoVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import MongoDB 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__)