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

langflow/components/cleanlab/cleanlab_remediator.py

@@ -1,131 +0,0 @@
-from langflow.custom import Component
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.io import BoolInput, FloatInput, HandleInput, MessageTextInput, Output, PromptInput
-from langflow.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)

langflow/components/clickhouse/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)

langflow/components/clickhouse/clickhouse.py

@@ -1,135 +0,0 @@
-from langchain_community.vectorstores import Clickhouse, ClickhouseSettings
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.inputs.inputs import BoolInput, FloatInput
-from langflow.io import (
-    DictInput,
-    DropdownInput,
-    HandleInput,
-    IntInput,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.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 []

langflow/components/cloudflare/__init__.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.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__)

langflow/components/cloudflare/cloudflare.py

@@ -1,81 +0,0 @@
-from langchain_community.embeddings.cloudflare_workersai import CloudflareWorkersAIEmbeddings
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import Embeddings
-from langflow.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

langflow/components/cohere/__init__.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)

langflow/components/cohere/cohere_embeddings.py

@@ -1,81 +0,0 @@
-from typing import Any
-
-import cohere
-from langchain_cohere import CohereEmbeddings
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import Embeddings
-from langflow.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

langflow/components/cohere/cohere_models.py

@@ -1,46 +0,0 @@
-from langchain_cohere import ChatCohere
-from pydantic.v1 import SecretStr
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.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._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,
-        )

langflow/components/cohere/cohere_rerank.py

@@ -1,51 +0,0 @@
-from langflow.base.compressors.model import LCCompressorComponent
-from langflow.field_typing import BaseDocumentCompressor
-from langflow.inputs.inputs import SecretStrInput
-from langflow.io import DropdownInput
-from langflow.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,
-        )