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

langflow/components/models/language_model.py

@@ -1,144 +0,0 @@
-from typing import Any
-
-from langchain_anthropic import ChatAnthropic
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_openai import ChatOpenAI
-
-from langflow.base.models.anthropic_constants import ANTHROPIC_MODELS
-from langflow.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
-from langflow.base.models.model import LCModelComponent
-from langflow.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import BoolInput
-from langflow.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
-from langflow.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

langflow/components/mongodb/__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 .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__)

langflow/components/mongodb/mongodb_atlas.py

@@ -1,213 +0,0 @@
-import tempfile
-import time
-
-import certifi
-from langchain_community.vectorstores import MongoDBAtlasVectorSearch
-from pymongo.collection import Collection
-from pymongo.operations import SearchIndexModel
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import BoolInput, DropdownInput, HandleInput, IntInput, SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class MongoVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "MongoDB Atlas"
-    description = "MongoDB Atlas Vector Store with search capabilities"
-    name = "MongoDBAtlasVector"
-    icon = "MongoDB"
-    INSERT_MODES = ["append", "overwrite"]
-    SIMILARITY_OPTIONS = ["cosine", "euclidean", "dotProduct"]
-    QUANTIZATION_OPTIONS = ["scalar", "binary"]
-    inputs = [
-        SecretStrInput(name="mongodb_atlas_cluster_uri", display_name="MongoDB Atlas Cluster URI", required=True),
-        BoolInput(name="enable_mtls", display_name="Enable mTLS", value=False, advanced=True, required=True),
-        SecretStrInput(
-            name="mongodb_atlas_client_cert",
-            display_name="MongoDB Atlas Combined Client Certificate",
-            required=False,
-            info="Client Certificate combined with the private key in the following format:\n "
-            "-----BEGIN PRIVATE KEY-----\n...\n -----END PRIVATE KEY-----\n-----BEGIN CERTIFICATE-----\n"
-            "...\n-----END CERTIFICATE-----\n",
-        ),
-        StrInput(name="db_name", display_name="Database Name", required=True),
-        StrInput(name="collection_name", display_name="Collection Name", required=True),
-        StrInput(
-            name="index_name",
-            display_name="Index Name",
-            required=True,
-            info="The name of Atlas Search index, it should be a Vector Search.",
-        ),
-        *LCVectorStoreComponent.inputs,
-        DropdownInput(
-            name="insert_mode",
-            display_name="Insert Mode",
-            options=INSERT_MODES,
-            value=INSERT_MODES[0],
-            info="How to insert new documents into the collection.",
-            advanced=True,
-        ),
-        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,
-        ),
-        StrInput(
-            name="index_field",
-            display_name="Index Field",
-            advanced=True,
-            required=True,
-            info="The field to index.",
-            value="embedding",
-        ),
-        StrInput(
-            name="filter_field", display_name="Filter Field", advanced=True, info="The field to filter the index."
-        ),
-        IntInput(
-            name="number_dimensions",
-            display_name="Number of Dimensions",
-            info="Embedding Context Length.",
-            value=1536,
-            advanced=True,
-            required=True,
-        ),
-        DropdownInput(
-            name="similarity",
-            display_name="Similarity",
-            options=SIMILARITY_OPTIONS,
-            value=SIMILARITY_OPTIONS[0],
-            info="The method used to measure the similarity between vectors.",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="quantization",
-            display_name="Quantization",
-            options=QUANTIZATION_OPTIONS,
-            value=None,
-            info="Quantization reduces memory costs converting 32-bit floats to smaller data types",
-            advanced=True,
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> MongoDBAtlasVectorSearch:
-        try:
-            from pymongo import MongoClient
-        except ImportError as e:
-            msg = "Please install pymongo to use MongoDB Atlas Vector Store"
-            raise ImportError(msg) from e
-
-        # Create temporary files for the client certificate
-        if self.enable_mtls:
-            client_cert_path = None
-            try:
-                client_cert = self.mongodb_atlas_client_cert.replace(" ", "\n")
-                client_cert = client_cert.replace("-----BEGIN\nPRIVATE\nKEY-----", "-----BEGIN PRIVATE KEY-----")
-                client_cert = client_cert.replace(
-                    "-----END\nPRIVATE\nKEY-----\n-----BEGIN\nCERTIFICATE-----",
-                    "-----END PRIVATE KEY-----\n-----BEGIN CERTIFICATE-----",
-                )
-                client_cert = client_cert.replace("-----END\nCERTIFICATE-----", "-----END CERTIFICATE-----")
-                with tempfile.NamedTemporaryFile(delete=False) as client_cert_file:
-                    client_cert_file.write(client_cert.encode("utf-8"))
-                    client_cert_path = client_cert_file.name
-
-            except Exception as e:
-                msg = f"Failed to write certificate to temporary file: {e}"
-                raise ValueError(msg) from e
-
-        try:
-            mongo_client: MongoClient = (
-                MongoClient(
-                    self.mongodb_atlas_cluster_uri,
-                    tls=True,
-                    tlsCertificateKeyFile=client_cert_path,
-                    tlsCAFile=certifi.where(),
-                )
-                if self.enable_mtls
-                else MongoClient(self.mongodb_atlas_cluster_uri)
-            )
-
-            collection = mongo_client[self.db_name][self.collection_name]
-
-        except Exception as e:
-            msg = f"Failed to connect to MongoDB Atlas: {e}"
-            raise ValueError(msg) from e
-
-        # 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:
-            self.__insert_mode(collection)
-
-            return MongoDBAtlasVectorSearch.from_documents(
-                documents=documents, embedding=self.embedding, collection=collection, index_name=self.index_name
-            )
-        return MongoDBAtlasVectorSearch(embedding=self.embedding, collection=collection, index_name=self.index_name)
-
-    def search_documents(self) -> list[Data]:
-        from bson.objectid import ObjectId
-
-        vector_store = self.build_vector_store()
-
-        self.verify_search_index(vector_store._collection)
-
-        if self.search_query and isinstance(self.search_query, str):
-            docs = vector_store.similarity_search(
-                query=self.search_query,
-                k=self.number_of_results,
-            )
-            for doc in docs:
-                doc.metadata = {
-                    key: str(value) if isinstance(value, ObjectId) else value for key, value in doc.metadata.items()
-                }
-
-            data = docs_to_data(docs)
-            self.status = data
-            return data
-        return []
-
-    def __insert_mode(self, collection: Collection) -> None:
-        if self.insert_mode == "overwrite":
-            collection.delete_many({})  # Delete all documents while preserving collection structure
-
-    def verify_search_index(self, collection: Collection) -> None:
-        """Verify if the search index exists, if not, create it.
-
-        Args:
-            collection (Collection): The collection to verify the search index on.
-        """
-        indexes = collection.list_search_indexes()
-
-        index_names_types = {idx["name"]: idx["type"] for idx in indexes}
-        index_names = list(index_names_types.keys())
-        index_type = index_names_types.get(self.index_name)
-        if self.index_name not in index_names and index_type != "vectorSearch":
-            collection.create_search_index(self.__create_index_definition())
-
-            time.sleep(20)  # Give some time for index to be ready
-
-    def __create_index_definition(self) -> SearchIndexModel:
-        fields = [
-            {
-                "type": "vector",
-                "path": self.index_field,
-                "numDimensions": self.number_dimensions,
-                "similarity": self.similarity,
-                "quantization": self.quantization,
-            }
-        ]
-        if self.filter_field:
-            fields.append({"type": "filter", "path": self.filter_field})
-        return SearchIndexModel(definition={"fields": fields}, name=self.index_name, type="vectorSearch")

langflow/components/needle/__init__.py

@@ -1,3 +0,0 @@
-from .needle import NeedleComponent
-
-__all__ = ["NeedleComponent"]

langflow/components/needle/needle.py

@@ -1,104 +0,0 @@
-from langchain_community.retrievers.needle import NeedleRetriever
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import IntInput, MessageTextInput, Output, SecretStrInput
-from langflow.schema.message import Message
-from langflow.utils.constants import MESSAGE_SENDER_AI
-
-
-class NeedleComponent(Component):
-    display_name = "Needle Retriever"
-    description = "A retriever that uses the Needle API to search collections."
-    documentation = "https://docs.needle-ai.com"
-    icon = "Needle"
-    name = "needle"
-
-    inputs = [
-        SecretStrInput(
-            name="needle_api_key",
-            display_name="Needle API Key",
-            info="Your Needle API key.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="collection_id",
-            display_name="Collection ID",
-            info="The ID of the Needle collection.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="query",
-            display_name="User Query",
-            info="Enter your question here. In tool mode, you can also specify top_k parameter (min: 20).",
-            required=True,
-            tool_mode=True,
-        ),
-        IntInput(
-            name="top_k",
-            display_name="Top K Results",
-            info="Number of search results to return (min: 20).",
-            value=20,
-            required=True,
-        ),
-    ]
-
-    outputs = [Output(display_name="Result", name="result", type_="Message", method="run")]
-
-    def run(self) -> Message:
-        # Extract query and top_k
-        query_input = self.query
-        actual_query = query_input.get("query", "") if isinstance(query_input, dict) else query_input
-
-        # Parse top_k from tool input or use default, always enforcing minimum of 20
-        try:
-            if isinstance(query_input, dict) and "top_k" in query_input:
-                agent_top_k = query_input.get("top_k")
-                # Check if agent_top_k is not None before converting to int
-                top_k = max(20, int(agent_top_k)) if agent_top_k is not None else max(20, self.top_k)
-            else:
-                top_k = max(20, self.top_k)
-        except (ValueError, TypeError):
-            top_k = max(20, self.top_k)
-
-        # Validate required inputs
-        if not self.needle_api_key or not self.needle_api_key.strip():
-            error_msg = "The Needle API key cannot be empty."
-            raise ValueError(error_msg)
-        if not self.collection_id or not self.collection_id.strip():
-            error_msg = "The Collection ID cannot be empty."
-            raise ValueError(error_msg)
-        if not actual_query or not actual_query.strip():
-            error_msg = "The query cannot be empty."
-            raise ValueError(error_msg)
-
-        try:
-            # Initialize the retriever and get documents
-            retriever = NeedleRetriever(
-                needle_api_key=self.needle_api_key,
-                collection_id=self.collection_id,
-                top_k=top_k,
-            )
-
-            docs = retriever.get_relevant_documents(actual_query)
-
-            # Format the response
-            if not docs:
-                text_content = "No relevant documents found for the query."
-            else:
-                context = "\n\n".join([f"Document {i + 1}:\n{doc.page_content}" for i, doc in enumerate(docs)])
-                text_content = f"Question: {actual_query}\n\nContext:\n{context}"
-
-            # Return formatted message
-            return Message(
-                text=text_content,
-                type="assistant",
-                sender=MESSAGE_SENDER_AI,
-                additional_kwargs={
-                    "source_documents": [{"page_content": doc.page_content, "metadata": doc.metadata} for doc in docs],
-                    "top_k_used": top_k,
-                },
-            )
-
-        except Exception as e:
-            error_msg = f"Error processing query: {e!s}"
-            raise ValueError(error_msg) from e

langflow/components/notdiamond/__init__.py

@@ -1,36 +0,0 @@
-"""NotDiamond components for LangFlow."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.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__)