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

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

@@ -0,0 +1,52 @@
+from langchain_community.chat_models import ChatMaritalk
+
+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 DropdownInput, FloatInput, IntInput, SecretStrInput
+
+
+class MaritalkModelComponent(LCModelComponent):
+    display_name = "MariTalk"
+    description = "Generates text using MariTalk LLMs."
+    icon = "Maritalk"
+    name = "Maritalk"
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            value=512,
+            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=["sabia-2-small", "sabia-2-medium"],
+            value=["sabia-2-small"],
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="MariTalk API Key",
+            info="The MariTalk API Key to use for authentication.",
+            advanced=False,
+        ),
+        FloatInput(name="temperature", display_name="Temperature", value=0.1, range_spec=RangeSpec(min=0, max=1)),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        # self.output_schea is a list of dictionarie s
+        # let's convert it to a dictionary
+        api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+
+        return ChatMaritalk(
+            max_tokens=max_tokens,
+            model=model_name,
+            api_key=api_key,
+            temperature=temperature or 0.1,
+        )

lfx/components/mem0/__init__.py

@@ -0,0 +1,3 @@
+from .mem0_chat_memory import Mem0MemoryComponent
+
+__all__ = ["Mem0MemoryComponent"]

lfx/components/mem0/mem0_chat_memory.py

@@ -0,0 +1,147 @@
+import os
+
+from mem0 import Memory, MemoryClient
+
+from lfx.base.memory.model import LCChatMemoryComponent
+from lfx.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDictInput, SecretStrInput
+from lfx.io import Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Mem0 chat memory is not supported in Astra cloud environment. Please use local storage mode or mem0 cloud."
+)
+
+
+class Mem0MemoryComponent(LCChatMemoryComponent):
+    display_name = "Mem0 Chat Memory"
+    description = "Retrieves and stores chat messages using Mem0 memory storage."
+    name = "mem0_chat_memory"
+    icon: str = "Mem0"
+    inputs = [
+        NestedDictInput(
+            name="mem0_config",
+            display_name="Mem0 Configuration",
+            info="""Configuration dictionary for initializing Mem0 memory instance.
+                    Example:
+                    {
+                        "graph_store": {
+                            "provider": "neo4j",
+                            "config": {
+                                "url": "neo4j+s://your-neo4j-url",
+                                "username": "neo4j",
+                                "password": "your-password"
+                            }
+                        },
+                        "version": "v1.1"
+                    }""",
+            input_types=["Data"],
+        ),
+        MessageTextInput(
+            name="ingest_message",
+            display_name="Message to Ingest",
+            info="The message content to be ingested into Mem0 memory.",
+        ),
+        HandleInput(
+            name="existing_memory",
+            display_name="Existing Memory Instance",
+            input_types=["Memory"],
+            info="Optional existing Mem0 memory instance. If not provided, a new instance will be created.",
+        ),
+        MessageTextInput(
+            name="user_id", display_name="User ID", info="Identifier for the user associated with the messages."
+        ),
+        MessageTextInput(
+            name="search_query", display_name="Search Query", info="Input text for searching related memories in Mem0."
+        ),
+        SecretStrInput(
+            name="mem0_api_key",
+            display_name="Mem0 API Key",
+            info="API key for Mem0 platform. Leave empty to use the local version.",
+        ),
+        DictInput(
+            name="metadata",
+            display_name="Metadata",
+            info="Additional metadata to associate with the ingested message.",
+            advanced=True,
+        ),
+        SecretStrInput(
+            name="openai_api_key",
+            display_name="OpenAI API Key",
+            required=False,
+            info="API key for OpenAI. Required if using OpenAI Embeddings without a provided configuration.",
+        ),
+    ]
+
+    outputs = [
+        Output(name="memory", display_name="Mem0 Memory", method="ingest_data"),
+        Output(
+            name="search_results",
+            display_name="Search Results",
+            method="build_search_results",
+        ),
+    ]
+
+    def build_mem0(self) -> Memory:
+        """Initializes a Mem0 memory instance based on provided configuration and API keys."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+        if self.openai_api_key:
+            os.environ["OPENAI_API_KEY"] = self.openai_api_key
+
+        try:
+            if not self.mem0_api_key:
+                return Memory.from_config(config_dict=dict(self.mem0_config)) if self.mem0_config else Memory()
+            if self.mem0_config:
+                return MemoryClient.from_config(api_key=self.mem0_api_key, config_dict=dict(self.mem0_config))
+            return MemoryClient(api_key=self.mem0_api_key)
+        except ImportError as e:
+            msg = "Mem0 is not properly installed. Please install it with 'pip install -U mem0ai'."
+            raise ImportError(msg) from e
+
+    def ingest_data(self) -> Memory:
+        """Ingests a new message into Mem0 memory and returns the updated memory instance."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+        mem0_memory = self.existing_memory or self.build_mem0()
+
+        if not self.ingest_message or not self.user_id:
+            logger.warning("Missing 'ingest_message' or 'user_id'; cannot ingest data.")
+            return mem0_memory
+
+        metadata = self.metadata or {}
+
+        logger.info("Ingesting message for user_id: %s", self.user_id)
+
+        try:
+            mem0_memory.add(self.ingest_message, user_id=self.user_id, metadata=metadata)
+        except Exception:
+            logger.exception("Failed to add message to Mem0 memory.")
+            raise
+
+        return mem0_memory
+
+    def build_search_results(self) -> Data:
+        """Searches the Mem0 memory for related messages based on the search query and returns the results."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
+        mem0_memory = self.ingest_data()
+        search_query = self.search_query
+        user_id = self.user_id
+
+        logger.info("Search query: %s", search_query)
+
+        try:
+            if search_query:
+                logger.info("Performing search with query.")
+                related_memories = mem0_memory.search(query=search_query, user_id=user_id)
+            else:
+                logger.info("Retrieving all memories for user_id: %s", user_id)
+                related_memories = mem0_memory.get_all(user_id=user_id)
+        except Exception:
+            logger.exception("Failed to retrieve related memories from Mem0.")
+            raise
+
+        logger.info("Related memories retrieved: %s", related_memories)
+        return related_memories

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

@@ -0,0 +1,115 @@
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    FloatInput,
+    HandleInput,
+    IntInput,
+    SecretStrInput,
+    StrInput,
+)
+from lfx.schema.data import Data
+
+
+class MilvusVectorStoreComponent(LCVectorStoreComponent):
+    """Milvus vector store with search capabilities."""
+
+    display_name: str = "Milvus"
+    description: str = "Milvus vector store with search capabilities"
+    name = "Milvus"
+    icon = "Milvus"
+
+    inputs = [
+        StrInput(name="collection_name", display_name="Collection Name", value="langflow"),
+        StrInput(name="collection_description", display_name="Collection Description", value=""),
+        StrInput(
+            name="uri",
+            display_name="Connection URI",
+            value="http://localhost:19530",
+        ),
+        SecretStrInput(
+            name="password",
+            display_name="Milvus Token",
+            value="",
+            info="Ignore this field if no token is required to make connection.",
+        ),
+        DictInput(name="connection_args", display_name="Other Connection Arguments", advanced=True),
+        StrInput(name="primary_field", display_name="Primary Field Name", value="pk"),
+        StrInput(name="text_field", display_name="Text Field Name", value="text"),
+        StrInput(name="vector_field", display_name="Vector Field Name", value="vector"),
+        DropdownInput(
+            name="consistency_level",
+            display_name="Consistencey Level",
+            options=["Bounded", "Session", "Strong", "Eventual"],
+            value="Session",
+            advanced=True,
+        ),
+        DictInput(name="index_params", display_name="Index Parameters", advanced=True),
+        DictInput(name="search_params", display_name="Search Parameters", advanced=True),
+        BoolInput(name="drop_old", display_name="Drop Old Collection", value=False, advanced=True),
+        FloatInput(name="timeout", display_name="Timeout", advanced=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self):
+        try:
+            from langchain_milvus.vectorstores import Milvus as LangchainMilvus
+        except ImportError as e:
+            msg = "Could not import Milvus integration package. Please install it with `pip install langchain-milvus`."
+            raise ImportError(msg) from e
+        self.connection_args.update(uri=self.uri, token=self.password)
+        milvus_store = LangchainMilvus(
+            embedding_function=self.embedding,
+            collection_name=self.collection_name,
+            collection_description=self.collection_description,
+            connection_args=self.connection_args,
+            consistency_level=self.consistency_level,
+            index_params=self.index_params,
+            search_params=self.search_params,
+            drop_old=self.drop_old,
+            auto_id=True,
+            primary_field=self.primary_field,
+            text_field=self.text_field,
+            vector_field=self.vector_field,
+            timeout=self.timeout,
+        )
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        if documents:
+            milvus_store.add_documents(documents)
+
+        return milvus_store
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/mistral/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .mistral import MistralAIModelComponent
+    from .mistral_embeddings import MistralAIEmbeddingsComponent
+
+_dynamic_imports = {
+    "MistralAIModelComponent": "mistral",
+    "MistralAIEmbeddingsComponent": "mistral_embeddings",
+}
+
+__all__ = [
+    "MistralAIEmbeddingsComponent",
+    "MistralAIModelComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import mistral 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/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 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,89 @@
+"""Models module - backwards compatibility alias for models_and_agents.
+
+This module provides backwards compatibility by forwarding model-related imports
+to models_and_agents where the actual model components are located.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from lfx.components._importing import import_mod
+
+# Forward model components from models_and_agents
+_dynamic_imports = {
+    "LanguageModelComponent": "language_model",
+    "EmbeddingModelComponent": "embedding_model",
+}
+
+__all__ = [
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+]
+
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.models.embedding_model
+_redirected_submodules = {
+    "lfx.components.models.embedding_model": "lfx.components.models_and_agents.embedding_model",
+    "lfx.components.models.language_model": "lfx.components.models_and_agents.language_model",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Forward attribute access to models_and_agents components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "embedding_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.embedding_model")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "language_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.language_model")
+        globals()[attr_name] = result
+        return result
+
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+
+    # Import from models_and_agents using the correct package path
+    package = "lfx.components.models_and_agents"
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
+    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 directory of available components."""
+    return list(__all__)