lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/azure/azure_openai_embeddings.py

@@ -0,0 +1,83 @@
+from langchain_openai import AzureOpenAIEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.field_typing import Embeddings
+from lfx.io import DropdownInput, IntInput, MessageTextInput, Output, SecretStrInput
+
+
+class AzureOpenAIEmbeddingsComponent(LCModelComponent):
+    display_name: str = "Azure OpenAI Embeddings"
+    description: str = "Generate embeddings using Azure OpenAI models."
+    documentation: str = "https://python.langchain.com/docs/integrations/text_embedding/azureopenai"
+    icon = "Azure"
+    name = "AzureOpenAIEmbeddings"
+
+    API_VERSION_OPTIONS = [
+        "2022-12-01",
+        "2023-03-15-preview",
+        "2023-05-15",
+        "2023-06-01-preview",
+        "2023-07-01-preview",
+        "2023-08-01-preview",
+    ]
+
+    inputs = [
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            advanced=False,
+            options=OPENAI_EMBEDDING_MODEL_NAMES,
+            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
+        ),
+        MessageTextInput(
+            name="azure_endpoint",
+            display_name="Azure Endpoint",
+            required=True,
+            info="Your Azure endpoint, including the resource. Example: `https://example-resource.azure.openai.com/`",
+        ),
+        MessageTextInput(
+            name="azure_deployment",
+            display_name="Deployment Name",
+            required=True,
+        ),
+        DropdownInput(
+            name="api_version",
+            display_name="API Version",
+            options=API_VERSION_OPTIONS,
+            value=API_VERSION_OPTIONS[-1],
+            advanced=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Azure OpenAI API Key",
+            required=True,
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            embeddings = AzureOpenAIEmbeddings(
+                model=self.model,
+                azure_endpoint=self.azure_endpoint,
+                azure_deployment=self.azure_deployment,
+                api_version=self.api_version,
+                api_key=self.api_key,
+                dimensions=self.dimensions or None,
+            )
+        except Exception as e:
+            msg = f"Could not connect to AzureOpenAIEmbeddings API: {e}"
+            raise ValueError(msg) from e
+
+        return embeddings

lfx/components/baidu/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.baidu.baidu_qianfan_chat import QianfanChatEndpoint
+
+_dynamic_imports = {
+    "QianfanChatEndpoint": "baidu_qianfan_chat",
+}
+
+__all__ = ["QianfanChatEndpoint"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import baidu 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__)

lfx/components/baidu/baidu_qianfan_chat.py

@@ -0,0 +1,113 @@
+from langchain_community.chat_models.baidu_qianfan_endpoint import QianfanChatEndpoint
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing.constants import LanguageModel
+from lfx.io import DropdownInput, FloatInput, MessageTextInput, SecretStrInput
+
+
+class QianfanChatEndpointComponent(LCModelComponent):
+    display_name: str = "Qianfan"
+    description: str = "Generate text using Baidu Qianfan LLMs."
+    documentation: str = "https://python.langchain.com/docs/integrations/chat/baidu_qianfan_endpoint"
+    icon = "BaiduQianfan"
+    name = "BaiduQianfanChatModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        DropdownInput(
+            name="model",
+            display_name="Model Name",
+            options=[
+                "EB-turbo-AppBuilder",
+                "Llama-2-70b-chat",
+                "ERNIE-Bot-turbo-AI",
+                "ERNIE-Lite-8K-0308",
+                "ERNIE-Speed",
+                "Qianfan-Chinese-Llama-2-13B",
+                "ERNIE-3.5-8K",
+                "BLOOMZ-7B",
+                "Qianfan-Chinese-Llama-2-7B",
+                "XuanYuan-70B-Chat-4bit",
+                "AquilaChat-7B",
+                "ERNIE-Bot-4",
+                "Llama-2-13b-chat",
+                "ChatGLM2-6B-32K",
+                "ERNIE-Bot",
+                "ERNIE-Speed-128k",
+                "ERNIE-4.0-8K",
+                "Qianfan-BLOOMZ-7B-compressed",
+                "ERNIE Speed",
+                "Llama-2-7b-chat",
+                "Mixtral-8x7B-Instruct",
+                "ERNIE 3.5",
+                "ERNIE Speed-AppBuilder",
+                "ERNIE-Speed-8K",
+                "Yi-34B-Chat",
+            ],
+            info="https://python.langchain.com/docs/integrations/chat/baidu_qianfan_endpoint",
+            value="ERNIE-4.0-8K",
+        ),
+        SecretStrInput(
+            name="qianfan_ak",
+            display_name="Qianfan Ak",
+            info="which you could get from  https://cloud.baidu.com/product/wenxinworkshop",
+        ),
+        SecretStrInput(
+            name="qianfan_sk",
+            display_name="Qianfan Sk",
+            info="which you could get from  https://cloud.baidu.com/product/wenxinworkshop",
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top p",
+            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
+            value=0.8,
+            advanced=True,
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
+            value=0.95,
+        ),
+        FloatInput(
+            name="penalty_score",
+            display_name="Penalty Score",
+            info="Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo",
+            value=1.0,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="endpoint", display_name="Endpoint", info="Endpoint of the Qianfan LLM, required if custom model used."
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        model = self.model
+        qianfan_ak = self.qianfan_ak
+        qianfan_sk = self.qianfan_sk
+        top_p = self.top_p
+        temperature = self.temperature
+        penalty_score = self.penalty_score
+        endpoint = self.endpoint
+
+        try:
+            kwargs = {
+                "model": model,
+                "qianfan_ak": qianfan_ak or None,
+                "qianfan_sk": qianfan_sk or None,
+                "top_p": top_p,
+                "temperature": temperature,
+                "penalty_score": penalty_score,
+            }
+
+            if endpoint:  # Only add endpoint if it has a value
+                kwargs["endpoint"] = endpoint
+
+            output = QianfanChatEndpoint(**kwargs)
+
+        except Exception as e:
+            msg = "Could not connect to Baidu Qianfan API."
+            raise ValueError(msg) from e
+
+        return output

lfx/components/bing/__init__.py

@@ -0,0 +1,3 @@
+from .bing_search_api import BingSearchAPIComponent
+
+__all__ = ["BingSearchAPIComponent"]

lfx/components/bing/bing_search_api.py

@@ -0,0 +1,61 @@
+from typing import cast
+
+from langchain_community.tools.bing_search import BingSearchResults
+from langchain_community.utilities import BingSearchAPIWrapper
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing import Tool
+from lfx.inputs.inputs import IntInput, MessageTextInput, MultilineInput, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class BingSearchAPIComponent(LCToolComponent):
+    display_name = "Bing Search API"
+    description = "Call the Bing Search API."
+    name = "BingSearchAPI"
+    icon = "Bing"
+
+    inputs = [
+        SecretStrInput(name="bing_subscription_key", display_name="Bing Subscription Key"),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+        ),
+        MessageTextInput(name="bing_search_url", display_name="Bing Search URL", advanced=True),
+        IntInput(name="k", display_name="Number of results", value=4, required=True),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+        Output(display_name="Tool", name="tool", method="build_tool"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def fetch_content(self) -> list[Data]:
+        if self.bing_search_url:
+            wrapper = BingSearchAPIWrapper(
+                bing_search_url=self.bing_search_url, bing_subscription_key=self.bing_subscription_key
+            )
+        else:
+            wrapper = BingSearchAPIWrapper(bing_subscription_key=self.bing_subscription_key)
+        results = wrapper.results(query=self.input_value, num_results=self.k)
+        data = [Data(data=result, text=result["snippet"]) for result in results]
+        self.status = data
+        return data
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)
+
+    def build_tool(self) -> Tool:
+        if self.bing_search_url:
+            wrapper = BingSearchAPIWrapper(
+                bing_search_url=self.bing_search_url, bing_subscription_key=self.bing_subscription_key
+            )
+        else:
+            wrapper = BingSearchAPIWrapper(bing_subscription_key=self.bing_subscription_key)
+        return cast("Tool", BingSearchResults(api_wrapper=wrapper, num_results=self.k))

lfx/components/cassandra/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .cassandra import CassandraVectorStoreComponent
+    from .cassandra_chat import CassandraChatMemory
+    from .cassandra_graph import CassandraGraphVectorStoreComponent
+
+_dynamic_imports = {
+    "CassandraVectorStoreComponent": "cassandra",
+    "CassandraGraphVectorStoreComponent": "cassandra_graph",
+    "CassandraChatMemory": "cassandra_chat",
+}
+
+__all__ = [
+    "CassandraChatMemory",
+    "CassandraGraphVectorStoreComponent",
+    "CassandraVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Cassandra 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__)

lfx/components/cassandra/cassandra.py

@@ -0,0 +1,264 @@
+from langchain_community.vectorstores import Cassandra
+
+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, DictInput, FloatInput
+from lfx.io import (
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    MessageTextInput,
+    SecretStrInput,
+)
+from lfx.schema.data import Data
+
+
+class CassandraVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Cassandra"
+    description = "Cassandra Vector Store with search capabilities"
+    documentation = "https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/cassandra"
+    name = "Cassandra"
+    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,
+        ),
+        IntInput(
+            name="ttl_seconds",
+            display_name="TTL Seconds",
+            info="Optional time-to-live for the added texts.",
+            advanced=True,
+        ),
+        IntInput(
+            name="batch_size",
+            display_name="Batch Size",
+            info="Optional number of data to process in a single batch.",
+            value=16,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="setup_mode",
+            display_name="Setup Mode",
+            info="Configuration mode for setting up the Cassandra table, with options like 'Sync', 'Async', or 'Off'.",
+            options=["Sync", "Async", "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=["Similarity", "Similarity with score threshold", "MMR (Max Marginal Relevance)"],
+            value="Similarity",
+            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,
+        ),
+        MessageTextInput(
+            name="body_search",
+            display_name="Search Body",
+            info="Document textual search terms to apply to the search query.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="enable_body_search",
+            display_name="Enable Body Search",
+            info="Flag to enable body search. This must be enabled BEFORE the table is created.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Cassandra:
+        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
+
+        from uuid import UUID
+
+        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,
+            )
+
+        # 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)
+
+        body_index_options = [("index_analyzer", "STANDARD")] if self.enable_body_search else None
+
+        if self.setup_mode == "Off":
+            setup_mode = SetupMode.OFF
+        elif self.setup_mode == "Sync":
+            setup_mode = SetupMode.SYNC
+        else:
+            setup_mode = SetupMode.ASYNC
+
+        if documents:
+            self.log(f"Adding {len(documents)} documents to the Vector Store.")
+            table = Cassandra.from_documents(
+                documents=documents,
+                embedding=self.embedding,
+                table_name=self.table_name,
+                keyspace=self.keyspace,
+                ttl_seconds=self.ttl_seconds or None,
+                batch_size=self.batch_size,
+                body_index_options=body_index_options,
+            )
+        else:
+            self.log("No documents to add to the Vector Store.")
+            table = Cassandra(
+                embedding=self.embedding,
+                table_name=self.table_name,
+                keyspace=self.keyspace,
+                ttl_seconds=self.ttl_seconds or None,
+                body_index_options=body_index_options,
+                setup_mode=setup_mode,
+            )
+        return table
+
+    def _map_search_type(self) -> str:
+        if self.search_type == "Similarity with score threshold":
+            return "similarity_score_threshold"
+        if self.search_type == "MMR (Max Marginal Relevance)":
+            return "mmr"
+        return "similarity"
+
+    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,
+        }
+
+        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
+        if self.body_search:
+            if not self.enable_body_search:
+                msg = "You should enable body search when creating the table to search the body field."
+                raise ValueError(msg)
+            args["body_search"] = self.body_search
+        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/cassandra/cassandra_chat.py

@@ -0,0 +1,92 @@
+from lfx.base.memory.model import LCChatMemoryComponent
+from lfx.field_typing.constants import Memory
+from lfx.inputs.inputs import DictInput, MessageTextInput, SecretStrInput
+
+
+class CassandraChatMemory(LCChatMemoryComponent):
+    display_name = "Cassandra Chat Memory"
+    description = "Retrieves and store chat messages from Apache Cassandra."
+    name = "CassandraChatMemory"
+    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,
+        ),
+        MessageTextInput(
+            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
+        ),
+        DictInput(
+            name="cluster_kwargs",
+            display_name="Cluster arguments",
+            info="Optional dictionary of additional keyword arguments for the Cassandra cluster.",
+            advanced=True,
+            is_list=True,
+        ),
+    ]
+
+    def build_message_history(self) -> Memory:
+        from langchain_community.chat_message_histories import CassandraChatMessageHistory
+
+        try:
+            import cassio
+        except ImportError as e:
+            msg = "Could not import cassio integration package. Please install it with `pip install cassio`."
+            raise ImportError(msg) from e
+
+        from uuid import UUID
+
+        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,
+            )
+
+        return CassandraChatMessageHistory(
+            session_id=self.session_id,
+            table_name=self.table_name,
+            keyspace=self.keyspace,
+        )