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

langflow/components/elastic/elasticsearch.py

@@ -1,267 +0,0 @@
-from typing import Any
-
-from elasticsearch import Elasticsearch
-from langchain.schema import Document
-from langchain_elasticsearch import ElasticsearchStore
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.io import (
-    BoolInput,
-    DropdownInput,
-    FloatInput,
-    HandleInput,
-    IntInput,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.schema.data import Data
-
-
-class ElasticsearchVectorStoreComponent(LCVectorStoreComponent):
-    """Elasticsearch Vector Store with with advanced, customizable search capabilities."""
-
-    display_name: str = "Elasticsearch"
-    description: str = "Elasticsearch Vector Store with with advanced, customizable search capabilities."
-    name = "Elasticsearch"
-    icon = "ElasticsearchStore"
-
-    inputs = [
-        StrInput(
-            name="elasticsearch_url",
-            display_name="Elasticsearch URL",
-            value="http://localhost:9200",
-            info="URL for self-managed Elasticsearch deployments (e.g., http://localhost:9200). "
-            "Do not use with Elastic Cloud deployments, use Elastic Cloud ID instead.",
-        ),
-        SecretStrInput(
-            name="cloud_id",
-            display_name="Elastic Cloud ID",
-            value="",
-            info="Use this for Elastic Cloud deployments. Do not use together with 'Elasticsearch URL'.",
-        ),
-        StrInput(
-            name="index_name",
-            display_name="Index Name",
-            value="langflow",
-            info="The index name where the vectors will be stored in Elasticsearch cluster.",
-        ),
-        *LCVectorStoreComponent.inputs,
-        StrInput(
-            name="username",
-            display_name="Username",
-            value="",
-            advanced=False,
-            info=(
-                "Elasticsearch username (e.g., 'elastic'). "
-                "Required for both local and Elastic Cloud setups unless API keys are used."
-            ),
-        ),
-        SecretStrInput(
-            name="password",
-            display_name="Password",
-            value="",
-            advanced=False,
-            info=(
-                "Elasticsearch password for the specified user. "
-                "Required for both local and Elastic Cloud setups unless API keys are used."
-            ),
-        ),
-        HandleInput(
-            name="embedding",
-            display_name="Embedding",
-            input_types=["Embeddings"],
-        ),
-        DropdownInput(
-            name="search_type",
-            display_name="Search Type",
-            options=["similarity", "mmr"],
-            value="similarity",
-            advanced=True,
-        ),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            advanced=True,
-            value=4,
-        ),
-        FloatInput(
-            name="search_score_threshold",
-            display_name="Search Score Threshold",
-            info="Minimum similarity score threshold for search results.",
-            value=0.0,
-            advanced=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Elastic API Key",
-            value="",
-            advanced=True,
-            info="API Key for Elastic Cloud authentication. If used, 'username' and 'password' are not required.",
-        ),
-        BoolInput(
-            name="verify_certs",
-            display_name="Verify SSL Certificates",
-            value=True,
-            advanced=True,
-            info="Whether to verify SSL certificates when connecting to Elasticsearch.",
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> ElasticsearchStore:
-        """Builds the Elasticsearch Vector Store object."""
-        if self.cloud_id and self.elasticsearch_url:
-            msg = (
-                "Both 'cloud_id' and 'elasticsearch_url' provided. "
-                "Please use only one based on your deployment (Cloud or Local)."
-            )
-            raise ValueError(msg)
-
-        es_params = {
-            "index_name": self.index_name,
-            "embedding": self.embedding,
-            "es_user": self.username or None,
-            "es_password": self.password or None,
-        }
-
-        if self.cloud_id:
-            es_params["es_cloud_id"] = self.cloud_id
-        else:
-            es_params["es_url"] = self.elasticsearch_url
-
-        if self.api_key:
-            es_params["api_key"] = self.api_key
-
-        # Check if we need to verify SSL certificates
-        if self.verify_certs is False:
-            # Build client parameters for Elasticsearch constructor
-            client_params: dict[str, Any] = {}
-            client_params["verify_certs"] = False
-
-            if self.cloud_id:
-                client_params["cloud_id"] = self.cloud_id
-            else:
-                client_params["hosts"] = [self.elasticsearch_url]
-
-            if self.api_key:
-                client_params["api_key"] = self.api_key
-            elif self.username and self.password:
-                client_params["basic_auth"] = (self.username, self.password)
-
-            es_client = Elasticsearch(**client_params)
-            es_params["es_connection"] = es_client
-
-        elasticsearch = ElasticsearchStore(**es_params)
-
-        # If documents are provided, add them to the store
-        if self.ingest_data:
-            documents = self._prepare_documents()
-            if documents:
-                elasticsearch.add_documents(documents)
-
-        return elasticsearch
-
-    def _prepare_documents(self) -> list[Document]:
-        """Prepares documents from the input data to add to the vector store."""
-        self.ingest_data = self._prepare_ingest_data()
-
-        documents = []
-        for data in self.ingest_data:
-            if isinstance(data, Data):
-                documents.append(data.to_lc_document())
-            else:
-                error_message = "Vector Store Inputs must be Data objects."
-                self.log(error_message)
-                raise TypeError(error_message)
-        return documents
-
-    def _add_documents_to_vector_store(self, vector_store: "ElasticsearchStore") -> None:
-        """Adds documents to the Vector Store."""
-        documents = self._prepare_documents()
-        if documents and self.embedding:
-            self.log(f"Adding {len(documents)} documents to the Vector Store.")
-            vector_store.add_documents(documents)
-        else:
-            self.log("No documents to add to the Vector Store.")
-
-    def search(self, query: str | None = None) -> list[dict[str, Any]]:
-        """Search for similar documents in the vector store or retrieve all documents if no query is provided."""
-        vector_store = self.build_vector_store()
-        search_kwargs = {
-            "k": self.number_of_results,
-            "score_threshold": self.search_score_threshold,
-        }
-
-        if query:
-            search_type = self.search_type.lower()
-            if search_type not in {"similarity", "mmr"}:
-                msg = f"Invalid search type: {self.search_type}"
-                self.log(msg)
-                raise ValueError(msg)
-            try:
-                if search_type == "similarity":
-                    results = vector_store.similarity_search_with_score(query, **search_kwargs)
-                elif search_type == "mmr":
-                    results = vector_store.max_marginal_relevance_search(query, **search_kwargs)
-            except Exception as e:
-                msg = (
-                    "Error occurred while querying the Elasticsearch VectorStore,"
-                    " there is no Data into the VectorStore."
-                )
-                self.log(msg)
-                raise ValueError(msg) from e
-            return [
-                {"page_content": doc.page_content, "metadata": doc.metadata, "score": score} for doc, score in results
-            ]
-        results = self.get_all_documents(vector_store, **search_kwargs)
-        return [{"page_content": doc.page_content, "metadata": doc.metadata, "score": score} for doc, score in results]
-
-    def get_all_documents(self, vector_store: ElasticsearchStore, **kwargs) -> list[tuple[Document, float]]:
-        """Retrieve all documents from the vector store."""
-        client = vector_store.client
-        index_name = self.index_name
-
-        query = {
-            "query": {"match_all": {}},
-            "size": kwargs.get("k", self.number_of_results),
-        }
-
-        response = client.search(index=index_name, body=query)
-
-        results = []
-        for hit in response["hits"]["hits"]:
-            doc = Document(
-                page_content=hit["_source"].get("text", ""),
-                metadata=hit["_source"].get("metadata", {}),
-            )
-            score = hit["_score"]
-            results.append((doc, score))
-
-        return results
-
-    def search_documents(self) -> list[Data]:
-        """Search for documents in the vector store based on the search input.
-
-        If no search input is provided, retrieve all documents.
-        """
-        results = self.search(self.search_query)
-        retrieved_data = [
-            Data(
-                text=result["page_content"],
-                file_path=result["metadata"].get("file_path", ""),
-            )
-            for result in results
-        ]
-        self.status = retrieved_data
-        return retrieved_data
-
-    def get_retriever_kwargs(self):
-        """Get the keyword arguments for the retriever."""
-        return {
-            "search_type": self.search_type.lower(),
-            "search_kwargs": {
-                "k": self.number_of_results,
-                "score_threshold": self.search_score_threshold,
-            },
-        }

langflow/components/elastic/opensearch.py

@@ -1,243 +0,0 @@
-import json
-from typing import Any
-
-from langchain_community.vectorstores import OpenSearchVectorSearch
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.base.vectorstores.vector_store_connection_decorator import vector_store_connection
-from langflow.io import (
-    BoolInput,
-    DropdownInput,
-    FloatInput,
-    HandleInput,
-    IntInput,
-    MultilineInput,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.schema.data import Data
-
-
-@vector_store_connection
-class OpenSearchVectorStoreComponent(LCVectorStoreComponent):
-    """OpenSearch Vector Store with advanced, customizable search capabilities."""
-
-    display_name: str = "OpenSearch"
-    description: str = "OpenSearch Vector Store with advanced, customizable search capabilities."
-    name = "OpenSearch"
-    icon = "OpenSearch"
-
-    inputs = [
-        StrInput(
-            name="opensearch_url",
-            display_name="OpenSearch URL",
-            value="http://localhost:9200",
-            info="URL for OpenSearch cluster (e.g. https://192.168.1.1:9200).",
-        ),
-        StrInput(
-            name="index_name",
-            display_name="Index Name",
-            value="langflow",
-            info="The index name where the vectors will be stored in OpenSearch cluster.",
-        ),
-        *LCVectorStoreComponent.inputs,
-        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
-        DropdownInput(
-            name="search_type",
-            display_name="Search Type",
-            options=["similarity", "similarity_score_threshold", "mmr"],
-            value="similarity",
-            advanced=True,
-        ),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            advanced=True,
-            value=4,
-        ),
-        FloatInput(
-            name="search_score_threshold",
-            display_name="Search Score Threshold",
-            info="Minimum similarity score threshold for search results.",
-            value=0.0,
-            advanced=True,
-        ),
-        StrInput(
-            name="username",
-            display_name="Username",
-            value="admin",
-            advanced=True,
-        ),
-        SecretStrInput(
-            name="password",
-            display_name="Password",
-            value="admin",
-            advanced=True,
-        ),
-        BoolInput(
-            name="use_ssl",
-            display_name="Use SSL",
-            value=True,
-            advanced=True,
-        ),
-        BoolInput(
-            name="verify_certs",
-            display_name="Verify Certificates",
-            value=False,
-            advanced=True,
-        ),
-        MultilineInput(
-            name="hybrid_search_query",
-            display_name="Hybrid Search Query",
-            value="",
-            advanced=True,
-            info=(
-                "Provide a custom hybrid search query in JSON format. This allows you to combine "
-                "vector similarity and keyword matching."
-            ),
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> OpenSearchVectorSearch:
-        """Builds the OpenSearch Vector Store object."""
-        try:
-            from langchain_community.vectorstores import OpenSearchVectorSearch
-        except ImportError as e:
-            error_message = f"Failed to import required modules: {e}"
-            self.log(error_message)
-            raise ImportError(error_message) from e
-
-        try:
-            opensearch = OpenSearchVectorSearch(
-                index_name=self.index_name,
-                embedding_function=self.embedding,
-                opensearch_url=self.opensearch_url,
-                http_auth=(self.username, self.password),
-                use_ssl=self.use_ssl,
-                verify_certs=self.verify_certs,
-                ssl_assert_hostname=False,
-                ssl_show_warn=False,
-            )
-        except Exception as e:
-            error_message = f"Failed to create OpenSearchVectorSearch instance: {e}"
-            self.log(error_message)
-            raise RuntimeError(error_message) from e
-
-        if self.ingest_data:
-            self._add_documents_to_vector_store(opensearch)
-
-        return opensearch
-
-    def _add_documents_to_vector_store(self, vector_store: "OpenSearchVectorSearch") -> None:
-        """Adds documents to the Vector Store."""
-        # 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:
-                error_message = f"Expected Data object, got {type(_input)}"
-                self.log(error_message)
-                raise TypeError(error_message)
-
-        if documents and self.embedding is not None:
-            self.log(f"Adding {len(documents)} documents to the Vector Store.")
-            try:
-                vector_store.add_documents(documents)
-            except Exception as e:
-                error_message = f"Error adding documents to Vector Store: {e}"
-                self.log(error_message)
-                raise RuntimeError(error_message) from e
-        else:
-            self.log("No documents to add to the Vector Store.")
-
-    def search(self, query: str | None = None) -> list[dict[str, Any]]:
-        """Search for similar documents in the vector store or retrieve all documents if no query is provided."""
-        try:
-            vector_store = self.build_vector_store()
-
-            query = query or ""
-
-            if self.hybrid_search_query.strip():
-                try:
-                    hybrid_query = json.loads(self.hybrid_search_query)
-                except json.JSONDecodeError as e:
-                    error_message = f"Invalid hybrid search query JSON: {e}"
-                    self.log(error_message)
-                    raise ValueError(error_message) from e
-
-                results = vector_store.client.search(index=self.index_name, body=hybrid_query)
-
-                processed_results = []
-                for hit in results.get("hits", {}).get("hits", []):
-                    source = hit.get("_source", {})
-                    text = source.get("text", "")
-                    metadata = source.get("metadata", {})
-
-                    if isinstance(text, dict):
-                        text = text.get("text", "")
-
-                    processed_results.append(
-                        {
-                            "page_content": text,
-                            "metadata": metadata,
-                        }
-                    )
-                return processed_results
-
-            search_kwargs = {"k": self.number_of_results}
-            search_type = self.search_type.lower()
-
-            if search_type == "similarity":
-                results = vector_store.similarity_search(query, **search_kwargs)
-                return [{"page_content": doc.page_content, "metadata": doc.metadata} for doc in results]
-            if search_type == "similarity_score_threshold":
-                search_kwargs["score_threshold"] = self.search_score_threshold
-                results = vector_store.similarity_search_with_relevance_scores(query, **search_kwargs)
-                return [
-                    {
-                        "page_content": doc.page_content,
-                        "metadata": doc.metadata,
-                        "score": score,
-                    }
-                    for doc, score in results
-                ]
-            if search_type == "mmr":
-                results = vector_store.max_marginal_relevance_search(query, **search_kwargs)
-                return [{"page_content": doc.page_content, "metadata": doc.metadata} for doc in results]
-
-        except Exception as e:
-            error_message = f"Error during search: {e}"
-            self.log(error_message)
-            raise RuntimeError(error_message) from e
-
-        error_message = f"Error during search. Invalid search type: {self.search_type}"
-        self.log(error_message)
-        raise ValueError(error_message)
-
-    def search_documents(self) -> list[Data]:
-        """Search for documents in the vector store based on the search input.
-
-        If no search input is provided, retrieve all documents.
-        """
-        try:
-            query = self.search_query.strip() if self.search_query else None
-            results = self.search(query)
-            retrieved_data = [
-                Data(
-                    file_path=result["metadata"].get("file_path", ""),
-                    text=result["page_content"],
-                )
-                for result in results
-            ]
-        except Exception as e:
-            error_message = f"Error during document search: {e}"
-            self.log(error_message)
-            raise RuntimeError(error_message) from e
-
-        self.status = retrieved_data
-        return retrieved_data

langflow/components/embeddings/__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 langflow.components.embeddings.similarity import EmbeddingSimilarityComponent
-    from langflow.components.embeddings.text_embedder import TextEmbedderComponent
-
-_dynamic_imports = {
-    "EmbeddingSimilarityComponent": "similarity",
-    "TextEmbedderComponent": "text_embedder",
-}
-
-__all__ = [
-    "EmbeddingSimilarityComponent",
-    "TextEmbedderComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import embedding 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/embeddings/similarity.py

@@ -1,76 +0,0 @@
-from typing import Any
-
-import numpy as np
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import DataInput, DropdownInput, Output
-from langflow.schema.data import Data
-
-
-class EmbeddingSimilarityComponent(Component):
-    display_name: str = "Embedding Similarity"
-    description: str = "Compute selected form of similarity between two embedding vectors."
-    icon = "equal"
-    legacy: bool = True
-
-    inputs = [
-        DataInput(
-            name="embedding_vectors",
-            display_name="Embedding Vectors",
-            info="A list containing exactly two data objects with embedding vectors to compare.",
-            is_list=True,
-            required=True,
-        ),
-        DropdownInput(
-            name="similarity_metric",
-            display_name="Similarity Metric",
-            info="Select the similarity metric to use.",
-            options=["Cosine Similarity", "Euclidean Distance", "Manhattan Distance"],
-            value="Cosine Similarity",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Similarity Data", name="similarity_data", method="compute_similarity"),
-    ]
-
-    def compute_similarity(self) -> Data:
-        embedding_vectors: list[Data] = self.embedding_vectors
-
-        # Assert that the list contains exactly two Data objects
-        if len(embedding_vectors) != 2:  # noqa: PLR2004
-            msg = "Exactly two embedding vectors are required."
-            raise ValueError(msg)
-
-        embedding_1 = np.array(embedding_vectors[0].data["embeddings"])
-        embedding_2 = np.array(embedding_vectors[1].data["embeddings"])
-
-        if embedding_1.shape != embedding_2.shape:
-            similarity_score: dict[str, Any] = {"error": "Embeddings must have the same dimensions."}
-        else:
-            similarity_metric = self.similarity_metric
-
-            if similarity_metric == "Cosine Similarity":
-                score = np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))
-                similarity_score = {"cosine_similarity": score}
-
-            elif similarity_metric == "Euclidean Distance":
-                score = np.linalg.norm(embedding_1 - embedding_2)
-                similarity_score = {"euclidean_distance": score}
-
-            elif similarity_metric == "Manhattan Distance":
-                score = np.sum(np.abs(embedding_1 - embedding_2))
-                similarity_score = {"manhattan_distance": score}
-
-        # Create a Data object to encapsulate the similarity score and additional information
-        similarity_data = Data(
-            data={
-                "embedding_1": embedding_vectors[0].data["embeddings"],
-                "embedding_2": embedding_vectors[1].data["embeddings"],
-                "similarity_score": similarity_score,
-            },
-            text_key="similarity_score",
-        )
-
-        self.status = similarity_data
-        return similarity_data

langflow/components/embeddings/text_embedder.py

@@ -1,64 +0,0 @@
-from typing import TYPE_CHECKING
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import HandleInput, MessageInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-if TYPE_CHECKING:
-    from langflow.field_typing import Embeddings
-    from langflow.schema.message import Message
-
-
-class TextEmbedderComponent(Component):
-    display_name: str = "Text Embedder"
-    description: str = "Generate embeddings for a given message using the specified embedding model."
-    icon = "binary"
-    legacy: bool = True
-    inputs = [
-        HandleInput(
-            name="embedding_model",
-            display_name="Embedding Model",
-            info="The embedding model to use for generating embeddings.",
-            input_types=["Embeddings"],
-            required=True,
-        ),
-        MessageInput(
-            name="message",
-            display_name="Message",
-            info="The message to generate embeddings for.",
-            required=True,
-        ),
-    ]
-    outputs = [
-        Output(display_name="Embedding Data", name="embeddings", method="generate_embeddings"),
-    ]
-
-    def generate_embeddings(self) -> Data:
-        try:
-            embedding_model: Embeddings = self.embedding_model
-            message: Message = self.message
-
-            # Combine validation checks to reduce nesting
-            if not embedding_model or not hasattr(embedding_model, "embed_documents"):
-                msg = "Invalid or incompatible embedding model"
-                raise ValueError(msg)
-
-            text_content = message.text if message and message.text else ""
-            if not text_content:
-                msg = "No text content found in message"
-                raise ValueError(msg)
-
-            embeddings = embedding_model.embed_documents([text_content])
-            if not embeddings or not isinstance(embeddings, list):
-                msg = "Invalid embeddings generated"
-                raise ValueError(msg)
-
-            embedding_vector = embeddings[0]
-            self.status = {"text": text_content, "embeddings": embedding_vector}
-            return Data(data={"text": text_content, "embeddings": embedding_vector})
-        except Exception as e:  # noqa: BLE001
-            logger.exception("Error generating embeddings")
-            error_data = Data(data={"text": "", "embeddings": [], "error": str(e)})
-            self.status = {"error": str(e)}
-            return error_data

langflow/components/exa/__init__.py

@@ -1,3 +0,0 @@
-from .exa_search import ExaSearchToolkit
-
-__all__ = ["ExaSearchToolkit"]