lfx-nightly 0.1.12.dev42__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

lfx/components/vectorstores/opensearch.py

@@ -1,243 +0,0 @@
-import json
-from typing import Any
-
-from langchain_community.vectorstores import OpenSearchVectorSearch
-
-from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from lfx.base.vectorstores.vector_store_connection_decorator import vector_store_connection
-from lfx.io import (
-    BoolInput,
-    DropdownInput,
-    FloatInput,
-    HandleInput,
-    IntInput,
-    MultilineInput,
-    SecretStrInput,
-    StrInput,
-)
-from lfx.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

lfx/components/vectorstores/pgvector.py

@@ -1,72 +0,0 @@
-from langchain_community.vectorstores import PGVector
-
-from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from lfx.helpers.data import docs_to_data
-from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
-from lfx.schema.data import Data
-from lfx.utils.connection_string_parser import transform_connection_string
-
-
-class PGVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "PGVector"
-    description = "PGVector Vector Store with search capabilities"
-    name = "pgvector"
-    icon = "cpu"
-
-    inputs = [
-        SecretStrInput(name="pg_server_url", display_name="PostgreSQL Server Connection String", required=True),
-        StrInput(name="collection_name", display_name="Table", required=True),
-        *LCVectorStoreComponent.inputs,
-        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"], required=True),
-        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) -> PGVector:
-        # 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)
-
-        connection_string_parsed = transform_connection_string(self.pg_server_url)
-
-        if documents:
-            pgvector = PGVector.from_documents(
-                embedding=self.embedding,
-                documents=documents,
-                collection_name=self.collection_name,
-                connection_string=connection_string_parsed,
-            )
-        else:
-            pgvector = PGVector.from_existing_index(
-                embedding=self.embedding,
-                collection_name=self.collection_name,
-                connection_string=connection_string_parsed,
-            )
-
-        return pgvector
-
-    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/vectorstores/pinecone.py

@@ -1,134 +0,0 @@
-import numpy as np
-from langchain_core.vectorstores import VectorStore
-
-from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from lfx.helpers.data import docs_to_data
-from lfx.io import DropdownInput, HandleInput, IntInput, SecretStrInput, StrInput
-from lfx.schema.data import Data
-
-
-class PineconeVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "Pinecone"
-    description = "Pinecone Vector Store with search capabilities"
-    name = "Pinecone"
-    icon = "Pinecone"
-    inputs = [
-        StrInput(name="index_name", display_name="Index Name", required=True),
-        StrInput(name="namespace", display_name="Namespace", info="Namespace for the index."),
-        DropdownInput(
-            name="distance_strategy",
-            display_name="Distance Strategy",
-            options=["Cosine", "Euclidean", "Dot Product"],
-            value="Cosine",
-            advanced=True,
-        ),
-        SecretStrInput(name="pinecone_api_key", display_name="Pinecone API Key", required=True),
-        StrInput(
-            name="text_key",
-            display_name="Text Key",
-            info="Key in the record to use as text.",
-            value="text",
-            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) -> VectorStore:
-        """Build and return a Pinecone vector store instance."""
-        try:
-            from langchain_pinecone import PineconeVectorStore
-        except ImportError as e:
-            msg = "langchain-pinecone is not installed. Please install it with `pip install langchain-pinecone`."
-            raise ValueError(msg) from e
-
-        try:
-            from langchain_pinecone._utilities import DistanceStrategy
-
-            # Wrap the embedding model to ensure float32 output
-            wrapped_embeddings = Float32Embeddings(self.embedding)
-
-            # Convert distance strategy
-            distance_strategy = self.distance_strategy.replace(" ", "_").upper()
-            distance_strategy = DistanceStrategy[distance_strategy]
-
-            # Initialize Pinecone instance with wrapped embeddings
-            pinecone = PineconeVectorStore(
-                index_name=self.index_name,
-                embedding=wrapped_embeddings,  # Use wrapped embeddings
-                text_key=self.text_key,
-                namespace=self.namespace,
-                distance_strategy=distance_strategy,
-                pinecone_api_key=self.pinecone_api_key,
-            )
-        except Exception as e:
-            error_msg = "Error building Pinecone vector store"
-            raise ValueError(error_msg) from e
-        else:
-            self.ingest_data = self._prepare_ingest_data()
-
-            # Process documents if any
-            documents = []
-            if self.ingest_data:
-                # Convert DataFrame to Data if needed using parent's method
-
-                for doc in self.ingest_data:
-                    if isinstance(doc, Data):
-                        documents.append(doc.to_lc_document())
-                    else:
-                        documents.append(doc)
-
-                if documents:
-                    pinecone.add_documents(documents)
-
-            return pinecone
-
-    def search_documents(self) -> list[Data]:
-        """Search documents in the vector store."""
-        try:
-            if not self.search_query or not isinstance(self.search_query, str) or not self.search_query.strip():
-                return []
-
-            vector_store = self.build_vector_store()
-            docs = vector_store.similarity_search(
-                query=self.search_query,
-                k=self.number_of_results,
-            )
-        except Exception as e:
-            error_msg = "Error searching documents"
-            raise ValueError(error_msg) from e
-        else:
-            data = docs_to_data(docs)
-            self.status = data
-            return data
-
-
-class Float32Embeddings:
-    """Wrapper class to ensure float32 embeddings."""
-
-    def __init__(self, base_embeddings):
-        self.base_embeddings = base_embeddings
-
-    def embed_documents(self, texts):
-        embeddings = self.base_embeddings.embed_documents(texts)
-        if isinstance(embeddings, np.ndarray):
-            return [[self._force_float32(x) for x in vec] for vec in embeddings]
-        return [[self._force_float32(x) for x in vec] for vec in embeddings]
-
-    def embed_query(self, text):
-        embedding = self.base_embeddings.embed_query(text)
-        if isinstance(embedding, np.ndarray):
-            return [self._force_float32(x) for x in embedding]
-        return [self._force_float32(x) for x in embedding]
-
-    def _force_float32(self, value):
-        """Convert any numeric type to Python float."""
-        return float(np.float32(value))

lfx/components/vectorstores/qdrant.py

@@ -1,109 +0,0 @@
-from langchain.embeddings.base import Embeddings
-from langchain_community.vectorstores import Qdrant
-
-from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from lfx.helpers.data import docs_to_data
-from lfx.io import (
-    DropdownInput,
-    HandleInput,
-    IntInput,
-    SecretStrInput,
-    StrInput,
-)
-from lfx.schema.data import Data
-
-
-class QdrantVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "Qdrant"
-    description = "Qdrant Vector Store with search capabilities"
-    icon = "Qdrant"
-
-    inputs = [
-        StrInput(name="collection_name", display_name="Collection Name", required=True),
-        StrInput(name="host", display_name="Host", value="localhost", advanced=True),
-        IntInput(name="port", display_name="Port", value=6333, advanced=True),
-        IntInput(name="grpc_port", display_name="gRPC Port", value=6334, advanced=True),
-        SecretStrInput(name="api_key", display_name="API Key", advanced=True),
-        StrInput(name="prefix", display_name="Prefix", advanced=True),
-        IntInput(name="timeout", display_name="Timeout", advanced=True),
-        StrInput(name="path", display_name="Path", advanced=True),
-        StrInput(name="url", display_name="URL", advanced=True),
-        DropdownInput(
-            name="distance_func",
-            display_name="Distance Function",
-            options=["Cosine", "Euclidean", "Dot Product"],
-            value="Cosine",
-            advanced=True,
-        ),
-        StrInput(name="content_payload_key", display_name="Content Payload Key", value="page_content", advanced=True),
-        StrInput(name="metadata_payload_key", display_name="Metadata Payload Key", value="metadata", 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) -> Qdrant:
-        qdrant_kwargs = {
-            "collection_name": self.collection_name,
-            "content_payload_key": self.content_payload_key,
-            "metadata_payload_key": self.metadata_payload_key,
-        }
-
-        server_kwargs = {
-            "host": self.host or None,
-            "port": int(self.port),  # Ensure port is an integer
-            "grpc_port": int(self.grpc_port),  # Ensure grpc_port is an integer
-            "api_key": self.api_key,
-            "prefix": self.prefix,
-            # Ensure timeout is an integer
-            "timeout": int(self.timeout) if self.timeout else None,
-            "path": self.path or None,
-            "url": self.url or None,
-        }
-
-        server_kwargs = {k: v for k, v in server_kwargs.items() if v is not None}
-
-        # 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 not isinstance(self.embedding, Embeddings):
-            msg = "Invalid embedding object"
-            raise TypeError(msg)
-
-        if documents:
-            qdrant = Qdrant.from_documents(documents, embedding=self.embedding, **qdrant_kwargs, **server_kwargs)
-        else:
-            from qdrant_client import QdrantClient
-
-            client = QdrantClient(**server_kwargs)
-            qdrant = Qdrant(embeddings=self.embedding, client=client, **qdrant_kwargs)
-
-        return qdrant
-
-    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/vectorstores/supabase.py

@@ -1,76 +0,0 @@
-from langchain_community.vectorstores import SupabaseVectorStore
-from supabase.client import Client, create_client
-
-from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from lfx.helpers.data import docs_to_data
-from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
-from lfx.schema.data import Data
-
-
-class SupabaseVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "Supabase"
-    description = "Supabase Vector Store with search capabilities"
-    name = "SupabaseVectorStore"
-    icon = "Supabase"
-
-    inputs = [
-        StrInput(name="supabase_url", display_name="Supabase URL", required=True),
-        SecretStrInput(name="supabase_service_key", display_name="Supabase Service Key", required=True),
-        StrInput(name="table_name", display_name="Table Name", advanced=True),
-        StrInput(name="query_name", display_name="Query Name"),
-        *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) -> SupabaseVectorStore:
-        supabase: Client = create_client(self.supabase_url, supabase_key=self.supabase_service_key)
-
-        # 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:
-            supabase_vs = SupabaseVectorStore.from_documents(
-                documents=documents,
-                embedding=self.embedding,
-                query_name=self.query_name,
-                client=supabase,
-                table_name=self.table_name,
-            )
-        else:
-            supabase_vs = SupabaseVectorStore(
-                client=supabase,
-                embedding=self.embedding,
-                table_name=self.table_name,
-                query_name=self.query_name,
-            )
-
-        return supabase_vs
-
-    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 []