lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/vectorstores/cassandra_graph.py

@@ -0,0 +1,238 @@
+from uuid import UUID
+
+from langchain_community.graph_vectorstores import CassandraGraphVectorStore
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.inputs.inputs import DictInput, FloatInput
+from lfx.io import (
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    MessageTextInput,
+    SecretStrInput,
+)
+from lfx.schema.data import Data
+
+
+class CassandraGraphVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Cassandra Graph"
+    description = "Cassandra Graph Vector Store"
+    name = "CassandraGraph"
+    icon = "Cassandra"
+
+    inputs = [
+        MessageTextInput(
+            name="database_ref",
+            display_name="Contact Points / Astra Database ID",
+            info="Contact points for the database (or Astra DB database ID)",
+            required=True,
+        ),
+        MessageTextInput(
+            name="username", display_name="Username", info="Username for the database (leave empty for Astra DB)."
+        ),
+        SecretStrInput(
+            name="token",
+            display_name="Password / Astra DB Token",
+            info="User password for the database (or Astra DB token).",
+            required=True,
+        ),
+        MessageTextInput(
+            name="keyspace",
+            display_name="Keyspace",
+            info="Table Keyspace (or Astra DB namespace).",
+            required=True,
+        ),
+        MessageTextInput(
+            name="table_name",
+            display_name="Table Name",
+            info="The name of the table (or Astra DB collection) where vectors will be stored.",
+            required=True,
+        ),
+        DropdownInput(
+            name="setup_mode",
+            display_name="Setup Mode",
+            info="Configuration mode for setting up the Cassandra table, with options like 'Sync' or 'Off'.",
+            options=["Sync", "Off"],
+            value="Sync",
+            advanced=True,
+        ),
+        DictInput(
+            name="cluster_kwargs",
+            display_name="Cluster arguments",
+            info="Optional dictionary of additional keyword arguments for the Cassandra cluster.",
+            advanced=True,
+            list=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,
+        ),
+        DropdownInput(
+            name="search_type",
+            display_name="Search Type",
+            info="Search type to use",
+            options=[
+                "Traversal",
+                "MMR traversal",
+                "Similarity",
+                "Similarity with score threshold",
+                "MMR (Max Marginal Relevance)",
+            ],
+            value="Traversal",
+            advanced=True,
+        ),
+        IntInput(
+            name="depth",
+            display_name="Depth of traversal",
+            info="The maximum depth of edges to traverse. (when using 'Traversal' or 'MMR traversal')",
+            value=1,
+            advanced=True,
+        ),
+        FloatInput(
+            name="search_score_threshold",
+            display_name="Search Score Threshold",
+            info="Minimum similarity score threshold for search results. "
+            "(when using 'Similarity with score threshold')",
+            value=0,
+            advanced=True,
+        ),
+        DictInput(
+            name="search_filter",
+            display_name="Search Metadata Filter",
+            info="Optional dictionary of filters to apply to the search query.",
+            advanced=True,
+            list=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> CassandraGraphVectorStore:
+        try:
+            import cassio
+            from langchain_community.utilities.cassandra import SetupMode
+        except ImportError as e:
+            msg = "Could not import cassio integration package. Please install it with `pip install cassio`."
+            raise ImportError(msg) from e
+
+        database_ref = self.database_ref
+
+        try:
+            UUID(self.database_ref)
+            is_astra = True
+        except ValueError:
+            is_astra = False
+            if "," in self.database_ref:
+                # use a copy because we can't change the type of the parameter
+                database_ref = self.database_ref.split(",")
+
+        if is_astra:
+            cassio.init(
+                database_id=database_ref,
+                token=self.token,
+                cluster_kwargs=self.cluster_kwargs,
+            )
+        else:
+            cassio.init(
+                contact_points=database_ref,
+                username=self.username,
+                password=self.token,
+                cluster_kwargs=self.cluster_kwargs,
+            )
+
+        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)
+
+        setup_mode = SetupMode.OFF if self.setup_mode == "Off" else SetupMode.SYNC
+
+        if documents:
+            self.log(f"Adding {len(documents)} documents to the Vector Store.")
+            store = CassandraGraphVectorStore.from_documents(
+                documents=documents,
+                embedding=self.embedding,
+                node_table=self.table_name,
+                keyspace=self.keyspace,
+            )
+        else:
+            self.log("No documents to add to the Vector Store.")
+            store = CassandraGraphVectorStore(
+                embedding=self.embedding,
+                node_table=self.table_name,
+                keyspace=self.keyspace,
+                setup_mode=setup_mode,
+            )
+        return store
+
+    def _map_search_type(self) -> str:
+        if self.search_type == "Similarity":
+            return "similarity"
+        if self.search_type == "Similarity with score threshold":
+            return "similarity_score_threshold"
+        if self.search_type == "MMR (Max Marginal Relevance)":
+            return "mmr"
+        if self.search_type == "MMR Traversal":
+            return "mmr_traversal"
+        return "traversal"
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        self.log(f"Search input: {self.search_query}")
+        self.log(f"Search type: {self.search_type}")
+        self.log(f"Number of results: {self.number_of_results}")
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            try:
+                search_type = self._map_search_type()
+                search_args = self._build_search_args()
+
+                self.log(f"Search args: {search_args}")
+
+                docs = vector_store.search(query=self.search_query, search_type=search_type, **search_args)
+            except KeyError as e:
+                if "content" in str(e):
+                    msg = (
+                        "You should ingest data through Langflow (or LangChain) to query it in Langflow. "
+                        "Your collection does not contain a field name 'content'."
+                    )
+                    raise ValueError(msg) from e
+                raise
+
+            self.log(f"Retrieved documents: {len(docs)}")
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []
+
+    def _build_search_args(self):
+        args = {
+            "k": self.number_of_results,
+            "score_threshold": self.search_score_threshold,
+            "depth": self.depth,
+        }
+
+        if self.search_filter:
+            clean_filter = {k: v for k, v in self.search_filter.items() if k and v}
+            if len(clean_filter) > 0:
+                args["filter"] = clean_filter
+        return args
+
+    def get_retriever_kwargs(self):
+        search_args = self._build_search_args()
+        return {
+            "search_type": self._map_search_type(),
+            "search_kwargs": search_args,
+        }

lfx/components/vectorstores/chroma.py

@@ -0,0 +1,167 @@
+from copy import deepcopy
+from typing import TYPE_CHECKING
+
+from chromadb.config import Settings
+from langchain_chroma import Chroma
+from typing_extensions import override
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.base.vectorstores.utils import chroma_collection_to_data
+from lfx.inputs.inputs import BoolInput, DropdownInput, HandleInput, IntInput, StrInput
+from lfx.schema.data import Data
+
+if TYPE_CHECKING:
+    from lfx.schema.dataframe import DataFrame
+
+
+class ChromaVectorStoreComponent(LCVectorStoreComponent):
+    """Chroma Vector Store with search capabilities."""
+
+    display_name: str = "Chroma DB"
+    description: str = "Chroma Vector Store with search capabilities"
+    name = "Chroma"
+    icon = "Chroma"
+
+    inputs = [
+        StrInput(
+            name="collection_name",
+            display_name="Collection Name",
+            value="langflow",
+        ),
+        StrInput(
+            name="persist_directory",
+            display_name="Persist Directory",
+        ),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        StrInput(
+            name="chroma_server_cors_allow_origins",
+            display_name="Server CORS Allow Origins",
+            advanced=True,
+        ),
+        StrInput(
+            name="chroma_server_host",
+            display_name="Server Host",
+            advanced=True,
+        ),
+        IntInput(
+            name="chroma_server_http_port",
+            display_name="Server HTTP Port",
+            advanced=True,
+        ),
+        IntInput(
+            name="chroma_server_grpc_port",
+            display_name="Server gRPC Port",
+            advanced=True,
+        ),
+        BoolInput(
+            name="chroma_server_ssl_enabled",
+            display_name="Server SSL Enabled",
+            advanced=True,
+        ),
+        BoolInput(
+            name="allow_duplicates",
+            display_name="Allow Duplicates",
+            advanced=True,
+            info="If false, will not add documents that are already in the Vector Store.",
+        ),
+        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=10,
+        ),
+        IntInput(
+            name="limit",
+            display_name="Limit",
+            advanced=True,
+            info="Limit the number of records to compare when Allow Duplicates is False.",
+        ),
+    ]
+
+    @override
+    @check_cached_vector_store
+    def build_vector_store(self) -> Chroma:
+        """Builds the Chroma object."""
+        try:
+            from chromadb import Client
+            from langchain_chroma import Chroma
+        except ImportError as e:
+            msg = "Could not import Chroma integration package. Please install it with `pip install langchain-chroma`."
+            raise ImportError(msg) from e
+        # Chroma settings
+        chroma_settings = None
+        client = None
+        if self.chroma_server_host:
+            chroma_settings = Settings(
+                chroma_server_cors_allow_origins=self.chroma_server_cors_allow_origins or [],
+                chroma_server_host=self.chroma_server_host,
+                chroma_server_http_port=self.chroma_server_http_port or None,
+                chroma_server_grpc_port=self.chroma_server_grpc_port or None,
+                chroma_server_ssl_enabled=self.chroma_server_ssl_enabled,
+            )
+            client = Client(settings=chroma_settings)
+
+        # Check persist_directory and expand it if it is a relative path
+        persist_directory = self.resolve_path(self.persist_directory) if self.persist_directory is not None else None
+
+        chroma = Chroma(
+            persist_directory=persist_directory,
+            client=client,
+            embedding_function=self.embedding,
+            collection_name=self.collection_name,
+        )
+
+        self._add_documents_to_vector_store(chroma)
+        self.status = chroma_collection_to_data(chroma.get(limit=self.limit))
+        return chroma
+
+    def _add_documents_to_vector_store(self, vector_store: "Chroma") -> None:
+        """Adds documents to the Vector Store."""
+        ingest_data: list | Data | DataFrame = self.ingest_data
+        if not ingest_data:
+            self.status = ""
+            return
+
+        # Convert DataFrame to Data if needed using parent's method
+        ingest_data = self._prepare_ingest_data()
+
+        stored_documents_without_id = []
+        if self.allow_duplicates:
+            stored_data = []
+        else:
+            stored_data = chroma_collection_to_data(vector_store.get(limit=self.limit))
+            for value in deepcopy(stored_data):
+                del value.id
+                stored_documents_without_id.append(value)
+
+        documents = []
+        for _input in ingest_data or []:
+            if isinstance(_input, Data):
+                if _input not in stored_documents_without_id:
+                    documents.append(_input.to_lc_document())
+            else:
+                msg = "Vector Store Inputs must be Data objects."
+                raise TypeError(msg)
+
+        if documents and self.embedding is not None:
+            self.log(f"Adding {len(documents)} documents to the Vector Store.")
+            # Filter complex metadata to prevent ChromaDB errors
+            try:
+                from langchain_community.vectorstores.utils import filter_complex_metadata
+
+                filtered_documents = filter_complex_metadata(documents)
+                vector_store.add_documents(filtered_documents)
+            except ImportError:
+                self.log("Warning: Could not import filter_complex_metadata. Adding documents without filtering.")
+                vector_store.add_documents(documents)
+        else:
+            self.log("No documents to add to the Vector Store.")

lfx/components/vectorstores/clickhouse.py

@@ -0,0 +1,135 @@
+from langchain_community.vectorstores import Clickhouse, ClickhouseSettings
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.inputs.inputs import BoolInput, FloatInput
+from lfx.io import (
+    DictInput,
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    SecretStrInput,
+    StrInput,
+)
+from lfx.schema.data import Data
+
+
+class ClickhouseVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Clickhouse"
+    description = "Clickhouse Vector Store with search capabilities"
+    name = "Clickhouse"
+    icon = "Clickhouse"
+
+    inputs = [
+        StrInput(name="host", display_name="hostname", required=True, value="localhost"),
+        IntInput(name="port", display_name="port", required=True, value=8123),
+        StrInput(name="database", display_name="database", required=True),
+        StrInput(name="table", display_name="Table name", required=True),
+        StrInput(name="username", display_name="The ClickHouse user name.", required=True),
+        SecretStrInput(name="password", display_name="The password for username.", required=True),
+        DropdownInput(
+            name="index_type",
+            display_name="index_type",
+            options=["annoy", "vector_similarity"],
+            info="Type of the index.",
+            value="annoy",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="metric",
+            display_name="metric",
+            options=["angular", "euclidean", "manhattan", "hamming", "dot"],
+            info="Metric to compute distance.",
+            value="angular",
+            advanced=True,
+        ),
+        BoolInput(
+            name="secure",
+            display_name="Use https/TLS. This overrides inferred values from the interface or port arguments.",
+            value=False,
+            advanced=True,
+        ),
+        StrInput(name="index_param", display_name="Param of the index", value="100,'L2Distance'", advanced=True),
+        DictInput(name="index_query_params", display_name="index query params", 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,
+        ),
+        FloatInput(name="score_threshold", display_name="Score threshold", advanced=True),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Clickhouse:
+        try:
+            import clickhouse_connect
+        except ImportError as e:
+            msg = (
+                "Failed to import Clickhouse dependencies. "
+                "Install it using `uv pip install langflow[clickhouse-connect] --pre`"
+            )
+            raise ImportError(msg) from e
+
+        try:
+            client = clickhouse_connect.get_client(
+                host=self.host, port=self.port, username=self.username, password=self.password
+            )
+            client.command("SELECT 1")
+        except Exception as e:
+            msg = f"Failed to connect to Clickhouse: {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)
+
+        kwargs = {}
+        if self.index_param:
+            kwargs["index_param"] = self.index_param.split(",")
+        if self.index_query_params:
+            kwargs["index_query_params"] = self.index_query_params
+
+        settings = ClickhouseSettings(
+            table=self.table,
+            database=self.database,
+            host=self.host,
+            index_type=self.index_type,
+            metric=self.metric,
+            password=self.password,
+            port=self.port,
+            secure=self.secure,
+            username=self.username,
+            **kwargs,
+        )
+        if documents:
+            clickhouse_vs = Clickhouse.from_documents(documents=documents, embedding=self.embedding, config=settings)
+
+        else:
+            clickhouse_vs = Clickhouse(embedding=self.embedding, config=settings)
+
+        return clickhouse_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():
+            kwargs = {}
+            if self.score_threshold:
+                kwargs["score_threshold"] = self.score_threshold
+
+            docs = vector_store.similarity_search(query=self.search_query, k=self.number_of_results, **kwargs)
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/vectorstores/couchbase.py

@@ -0,0 +1,102 @@
+from datetime import timedelta
+
+from langchain_community.vectorstores import CouchbaseVectorStore
+
+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 CouchbaseVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Couchbase"
+    description = "Couchbase Vector Store with search capabilities"
+    name = "Couchbase"
+    icon = "Couchbase"
+
+    inputs = [
+        SecretStrInput(
+            name="couchbase_connection_string", display_name="Couchbase Cluster connection string", required=True
+        ),
+        StrInput(name="couchbase_username", display_name="Couchbase username", required=True),
+        SecretStrInput(name="couchbase_password", display_name="Couchbase password", required=True),
+        StrInput(name="bucket_name", display_name="Bucket Name", required=True),
+        StrInput(name="scope_name", display_name="Scope Name", required=True),
+        StrInput(name="collection_name", display_name="Collection Name", required=True),
+        StrInput(name="index_name", display_name="Index Name", required=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) -> CouchbaseVectorStore:
+        try:
+            from couchbase.auth import PasswordAuthenticator
+            from couchbase.cluster import Cluster
+            from couchbase.options import ClusterOptions
+        except ImportError as e:
+            msg = "Failed to import Couchbase dependencies. Install it using `uv pip install langflow[couchbase] --pre`"
+            raise ImportError(msg) from e
+
+        try:
+            auth = PasswordAuthenticator(self.couchbase_username, self.couchbase_password)
+            options = ClusterOptions(auth)
+            cluster = Cluster(self.couchbase_connection_string, options)
+
+            cluster.wait_until_ready(timedelta(seconds=5))
+        except Exception as e:
+            msg = f"Failed to connect to Couchbase: {e}"
+            raise ValueError(msg) from e
+
+        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:
+            couchbase_vs = CouchbaseVectorStore.from_documents(
+                documents=documents,
+                cluster=cluster,
+                bucket_name=self.bucket_name,
+                scope_name=self.scope_name,
+                collection_name=self.collection_name,
+                embedding=self.embedding,
+                index_name=self.index_name,
+            )
+
+        else:
+            couchbase_vs = CouchbaseVectorStore(
+                cluster=cluster,
+                bucket_name=self.bucket_name,
+                scope_name=self.scope_name,
+                collection_name=self.collection_name,
+                embedding=self.embedding,
+                index_name=self.index_name,
+            )
+
+        return couchbase_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 []