langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/mem0/mem0_chat_memory.py

@@ -1,136 +0,0 @@
-import os
-
-from mem0 import Memory, MemoryClient
-
-from langflow.base.memory.model import LCChatMemoryComponent
-from langflow.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDictInput, SecretStrInput
-from langflow.io import Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-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."""
-        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."""
-        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."""
-        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

langflow/components/milvus/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)

langflow/components/milvus/milvus.py

@@ -1,115 +0,0 @@
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FloatInput,
-    HandleInput,
-    IntInput,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.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="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 []

langflow/components/mistral/__init__.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)

langflow/components/mistral/mistral.py

@@ -1,114 +0,0 @@
-from langchain_mistralai import ChatMistralAI
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.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._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

langflow/components/mistral/mistral_embeddings.py

@@ -1,58 +0,0 @@
-from langchain_mistralai.embeddings import MistralAIEmbeddings
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import Embeddings
-from langflow.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,
-        )

langflow/components/models/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.models.embedding_model import EmbeddingModelComponent
-    from langflow.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__)

langflow/components/models/embedding_model.py

@@ -1,114 +0,0 @@
-from typing import Any
-
-from langchain_openai import OpenAIEmbeddings
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
-from langflow.field_typing import Embeddings
-from langflow.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FloatInput,
-    IntInput,
-    MessageTextInput,
-    SecretStrInput,
-)
-from langflow.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