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

lfx/components/cleanlab/cleanlab_remediator.py

@@ -0,0 +1,131 @@
+from lfx.custom import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import BoolInput, FloatInput, HandleInput, MessageTextInput, Output, PromptInput
+from lfx.schema.message import Message
+
+
+class CleanlabRemediator(Component):
+    """Remediates potentially untrustworthy LLM responses based on trust scores computed by the Cleanlab Evaluator.
+
+    This component takes a response and its associated trust score,
+    and applies remediation strategies based on configurable thresholds and settings.
+
+    Inputs:
+        - response (MessageTextInput): The original LLM-generated response to be evaluated and possibly remediated.
+          The CleanlabEvaluator passes this response through.
+        - score (HandleInput): The trust score output from CleanlabEvaluator (expected to be a float between 0 and 1).
+        - explanation (MessageTextInput): Optional textual explanation for the trust score, to be included in the
+          output.
+        - threshold (Input[float]): Minimum trust score required to accept the response. If the score is lower, the
+          response is remediated.
+        - show_untrustworthy_response (BoolInput): If true, returns the original response with a warning; if false,
+          returns fallback text.
+        - untrustworthy_warning_text (PromptInput): Text warning to append to responses deemed untrustworthy (when
+          showing them).
+        - fallback_text (PromptInput): Replacement message returned if the response is untrustworthy and should be
+          hidden.
+
+    Outputs:
+        - remediated_response (Message): Either:
+            • the original response,
+            • the original response with appended warning, or
+            • the fallback response,
+          depending on the trust score and configuration.
+
+    This component is typically used downstream of CleanlabEvaluator or CleanlabRagValidator
+    to take appropriate action on low-trust responses and inform users accordingly.
+    """
+
+    display_name = "Cleanlab Remediator"
+    description = (
+        "Remediates an untrustworthy response based on trust score from the Cleanlab Evaluator, "
+        "score threshold, and message handling settings."
+    )
+    icon = "Cleanlab"
+    name = "CleanlabRemediator"
+
+    inputs = [
+        MessageTextInput(
+            name="response",
+            display_name="Response",
+            info="The response to the user's query.",
+            required=True,
+        ),
+        HandleInput(
+            name="score",
+            display_name="Trust Score",
+            info="The trustworthiness score output from the Cleanlab Evaluator.",
+            input_types=["number"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="explanation",
+            display_name="Explanation",
+            info="The explanation from the Cleanlab Evaluator.",
+            required=False,
+        ),
+        FloatInput(
+            name="threshold",
+            display_name="Threshold",
+            field_type="float",
+            value=0.7,
+            range_spec=RangeSpec(min=0.0, max=1.0, step=0.05),
+            info="Minimum score required to show the response unmodified. Reponses with scores above this threshold "
+            "are considered trustworthy. Reponses with scores below this threshold are considered untrustworthy and "
+            "will be remediated based on the settings below.",
+            required=True,
+            show=True,
+        ),
+        BoolInput(
+            name="show_untrustworthy_response",
+            display_name="Show Untrustworthy Response",
+            info="If enabled, and the trust score is below the threshold, the original response is shown with the "
+            "added warning. If disabled, and the trust score is below the threshold, the fallback answer is returned.",
+            value=True,
+        ),
+        PromptInput(
+            name="untrustworthy_warning_text",
+            display_name="Warning for Untrustworthy Response",
+            info="Warning to append to the response if Show Untrustworthy Response is enabled and trust score is "
+            "below the threshold.",
+            value="⚠️ WARNING: The following response is potentially untrustworthy.",
+        ),
+        PromptInput(
+            name="fallback_text",
+            display_name="Fallback Answer",
+            info="Response returned if the trust score is below the threshold and 'Show Untrustworthy Response' is "
+            "disabled.",
+            value="Based on the available information, I cannot provide a complete answer to this question.",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Remediated Message",
+            name="remediated_response",
+            method="remediate_response",
+            types=["Message"],
+        ),
+    ]
+
+    def remediate_response(self) -> Message:
+        if self.score >= self.threshold:
+            self.status = f"Score {self.score:.2f} ≥ threshold {self.threshold:.2f} → accepted"
+            return Message(
+                text=f"{self.response}\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n**Trust Score:** {self.score:.2f}"
+            )
+
+        self.status = f"Score {self.score:.2f} < threshold {self.threshold:.2f} → flagged"
+
+        if self.show_untrustworthy_response:
+            parts = [
+                self.response,
+                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+                f"**{self.untrustworthy_warning_text.strip()}**",
+                f"**Trust Score:** {self.score:.2f}",
+            ]
+            if self.explanation:
+                parts.append(f"**Explanation:** {self.explanation}")
+            return Message(text="\n\n".join(parts))
+
+        return Message(text=self.fallback_text)

lfx/components/clickhouse/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .clickhouse import ClickhouseVectorStoreComponent
+
+_dynamic_imports = {
+    "ClickhouseVectorStoreComponent": "clickhouse",
+}
+
+__all__ = [
+    "ClickhouseVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import ClickHouse 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/clickhouse/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/cloudflare/__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.cloudflare.cloudflare import CloudflareWorkersAIEmbeddingsComponent
+
+_dynamic_imports = {
+    "CloudflareWorkersAIEmbeddingsComponent": "cloudflare",
+}
+
+__all__ = ["CloudflareWorkersAIEmbeddingsComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cloudflare 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/cloudflare/cloudflare.py

@@ -0,0 +1,81 @@
+from langchain_community.embeddings.cloudflare_workersai import CloudflareWorkersAIEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, DictInput, IntInput, MessageTextInput, Output, SecretStrInput
+
+
+class CloudflareWorkersAIEmbeddingsComponent(LCModelComponent):
+    display_name: str = "Cloudflare Workers AI Embeddings"
+    description: str = "Generate embeddings using Cloudflare Workers AI models."
+    documentation: str = "https://python.langchain.com/docs/integrations/text_embedding/cloudflare_workersai/"
+    icon = "Cloudflare"
+    name = "CloudflareWorkersAIEmbeddings"
+
+    inputs = [
+        MessageTextInput(
+            name="account_id",
+            display_name="Cloudflare account ID",
+            info="Find your account ID https://developers.cloudflare.com/fundamentals/setup/find-account-and-zone-ids/#find-account-id-workers-and-pages",
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_token",
+            display_name="Cloudflare API token",
+            info="Create an API token https://developers.cloudflare.com/fundamentals/api/get-started/create-token/",
+            required=True,
+        ),
+        MessageTextInput(
+            name="model_name",
+            display_name="Model Name",
+            info="List of supported models https://developers.cloudflare.com/workers-ai/models/#text-embeddings",
+            required=True,
+            value="@cf/baai/bge-base-en-v1.5",
+        ),
+        BoolInput(
+            name="strip_new_lines",
+            display_name="Strip New Lines",
+            advanced=True,
+            value=True,
+        ),
+        IntInput(
+            name="batch_size",
+            display_name="Batch Size",
+            advanced=True,
+            value=50,
+        ),
+        MessageTextInput(
+            name="api_base_url",
+            display_name="Cloudflare API base URL",
+            advanced=True,
+            value="https://api.cloudflare.com/client/v4/accounts",
+        ),
+        DictInput(
+            name="headers",
+            display_name="Headers",
+            info="Additional request headers",
+            is_list=True,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            embeddings = CloudflareWorkersAIEmbeddings(
+                account_id=self.account_id,
+                api_base_url=self.api_base_url,
+                api_token=self.api_token,
+                batch_size=self.batch_size,
+                headers=self.headers,
+                model_name=self.model_name,
+                strip_new_lines=self.strip_new_lines,
+            )
+        except Exception as e:
+            msg = f"Could not connect to CloudflareWorkersAIEmbeddings API: {e!s}"
+            raise ValueError(msg) from e
+
+        return embeddings

lfx/components/cohere/__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 .cohere_embeddings import CohereEmbeddingsComponent
+    from .cohere_models import CohereComponent
+    from .cohere_rerank import CohereRerankComponent
+
+_dynamic_imports = {
+    "CohereComponent": "cohere_models",
+    "CohereEmbeddingsComponent": "cohere_embeddings",
+    "CohereRerankComponent": "cohere_rerank",
+}
+
+__all__ = [
+    "CohereComponent",
+    "CohereEmbeddingsComponent",
+    "CohereRerankComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cohere 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/cohere/cohere_embeddings.py

@@ -0,0 +1,81 @@
+from typing import Any
+
+import cohere
+from langchain_cohere import CohereEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import DropdownInput, FloatInput, IntInput, MessageTextInput, Output, SecretStrInput
+
+HTTP_STATUS_OK = 200
+
+
+class CohereEmbeddingsComponent(LCModelComponent):
+    display_name = "Cohere Embeddings"
+    description = "Generate embeddings using Cohere models."
+    icon = "Cohere"
+    name = "CohereEmbeddings"
+
+    inputs = [
+        SecretStrInput(name="api_key", display_name="Cohere API Key", required=True, real_time_refresh=True),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            advanced=False,
+            options=[
+                "embed-english-v2.0",
+                "embed-multilingual-v2.0",
+                "embed-english-light-v2.0",
+                "embed-multilingual-light-v2.0",
+            ],
+            value="embed-english-v2.0",
+            refresh_button=True,
+            combobox=True,
+        ),
+        MessageTextInput(name="truncate", display_name="Truncate", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", value=3, advanced=True),
+        MessageTextInput(name="user_agent", display_name="User Agent", advanced=True, value="langchain"),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        data = None
+        try:
+            data = CohereEmbeddings(
+                cohere_api_key=self.api_key,
+                model=self.model_name,
+                truncate=self.truncate,
+                max_retries=self.max_retries,
+                user_agent=self.user_agent,
+                request_timeout=self.request_timeout or None,
+            )
+        except Exception as e:
+            msg = (
+                "Unable to create Cohere Embeddings. ",
+                "Please verify the API key and model parameters, and try again.",
+            )
+            raise ValueError(msg) from e
+        # added status if not the return data would be serialised to create the status
+        return data
+
+    def get_model(self):
+        try:
+            co = cohere.ClientV2(self.api_key)
+            response = co.models.list(endpoint="embed")
+            models = response.models
+            return [model.name for model in models]
+        except Exception as e:
+            msg = f"Failed to fetch Cohere models. Error: {e}"
+            raise ValueError(msg) from e
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):
+        if field_name in {"model_name", "api_key"}:
+            if build_config.get("api_key", {}).get("value", None):
+                build_config["model_name"]["options"] = self.get_model()
+        else:
+            build_config["model_name"]["options"] = field_value
+        return build_config

lfx/components/cohere/cohere_models.py

@@ -0,0 +1,46 @@
+from langchain_cohere import ChatCohere
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import SecretStrInput, SliderInput
+
+
+class CohereComponent(LCModelComponent):
+    display_name = "Cohere Language Models"
+    description = "Generate text using Cohere LLMs."
+    documentation = "https://python.langchain.com/docs/modules/model_io/models/llms/integrations/cohere"
+    icon = "Cohere"
+    name = "CohereModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        SecretStrInput(
+            name="cohere_api_key",
+            display_name="Cohere API Key",
+            info="The Cohere API Key to use for the Cohere model.",
+            advanced=False,
+            value="COHERE_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.75,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        cohere_api_key = self.cohere_api_key
+        temperature = self.temperature
+
+        api_key = SecretStr(cohere_api_key).get_secret_value() if cohere_api_key else None
+
+        return ChatCohere(
+            temperature=temperature or 0.75,
+            cohere_api_key=api_key,
+        )

lfx/components/cohere/cohere_rerank.py

@@ -0,0 +1,51 @@
+from lfx.base.compressors.model import LCCompressorComponent
+from lfx.field_typing import BaseDocumentCompressor
+from lfx.inputs.inputs import SecretStrInput
+from lfx.io import DropdownInput
+from lfx.template.field.base import Output
+
+
+class CohereRerankComponent(LCCompressorComponent):
+    display_name = "Cohere Rerank"
+    description = "Rerank documents using the Cohere API."
+    name = "CohereRerank"
+    icon = "Cohere"
+
+    inputs = [
+        *LCCompressorComponent.inputs,
+        SecretStrInput(
+            name="api_key",
+            display_name="Cohere API Key",
+        ),
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            options=[
+                "rerank-english-v3.0",
+                "rerank-multilingual-v3.0",
+                "rerank-english-v2.0",
+                "rerank-multilingual-v2.0",
+            ],
+            value="rerank-english-v3.0",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Reranked Documents",
+            name="reranked_documents",
+            method="compress_documents",
+        ),
+    ]
+
+    def build_compressor(self) -> BaseDocumentCompressor:  # type: ignore[type-var]
+        try:
+            from langchain_cohere import CohereRerank
+        except ImportError as e:
+            msg = "Please install langchain-cohere to use the Cohere model."
+            raise ImportError(msg) from e
+        return CohereRerank(
+            cohere_api_key=self.api_key,
+            model=self.model,
+            top_n=self.top_n,
+        )