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

lfx/components/deactivated/__init__.py

@@ -0,0 +1,15 @@
+from .extract_key_from_data import ExtractKeyFromDataComponent
+from .list_flows import ListFlowsComponent
+from .merge_data import MergeDataComponent
+from .selective_passthrough import SelectivePassThroughComponent
+from .split_text import SplitTextComponent
+from .sub_flow import SubFlowComponent
+
+__all__ = [
+    "ExtractKeyFromDataComponent",
+    "ListFlowsComponent",
+    "MergeDataComponent",
+    "SelectivePassThroughComponent",
+    "SplitTextComponent",
+    "SubFlowComponent",
+]

lfx/components/deactivated/amazon_kendra.py

@@ -0,0 +1,66 @@
+# mypy: disable-error-code="attr-defined"
+from langchain_community.retrievers import AmazonKendraRetriever
+
+from lfx.base.vectorstores.model import check_cached_vector_store
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.io import DictInput, IntInput, StrInput
+
+
+class AmazonKendraRetrieverComponent(CustomComponent):
+    display_name: str = "Amazon Kendra Retriever"
+    description: str = "Retriever that uses the Amazon Kendra API."
+    name = "AmazonKendra"
+    icon = "Amazon"
+    legacy = True
+
+    inputs = [
+        StrInput(
+            name="index_id",
+            display_name="Index ID",
+        ),
+        StrInput(
+            name="region_name",
+            display_name="Region Name",
+        ),
+        StrInput(
+            name="credentials_profile_name",
+            display_name="Credentials Profile Name",
+        ),
+        DictInput(
+            name="attribute_filter",
+            display_name="Attribute Filter",
+        ),
+        IntInput(
+            name="top_k",
+            display_name="Top K",
+            value=3,
+        ),
+        DictInput(
+            name="user_context",
+            display_name="User Context",
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> AmazonKendraRetriever:
+        """Builds the Amazon Kendra Retriever."""
+        try:
+            from langchain_community.retrievers import AmazonKendraRetriever
+        except ImportError as e:
+            msg = "Could not import AmazonKendraRetriever. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            output = AmazonKendraRetriever(
+                index_id=self.index_id,
+                top_k=self.top_k,
+                region_name=self.region_name,
+                credentials_profile_name=self.credentials_profile_name,
+                attribute_filter=self.attribute_filter,
+                user_context=self.user_context,
+            )
+        except Exception as e:
+            msg = "Could not connect to AmazonKendra API."
+            raise ValueError(msg) from e
+
+        return output

lfx/components/deactivated/chat_litellm_model.py

@@ -0,0 +1,158 @@
+from langchain_community.chat_models.litellm import ChatLiteLLM, ChatLiteLLMException
+
+from lfx.base.constants import STREAM_INFO_TEXT
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.io import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    FloatInput,
+    IntInput,
+    MessageInput,
+    SecretStrInput,
+    StrInput,
+)
+
+
+class ChatLiteLLMModelComponent(LCModelComponent):
+    display_name = "LiteLLM"
+    description = "`LiteLLM` collection of large language models."
+    documentation = "https://python.langchain.com/docs/integrations/chat/litellm"
+    icon = "🚄"
+
+    inputs = [
+        MessageInput(name="input_value", display_name="Input"),
+        StrInput(
+            name="model",
+            display_name="Model name",
+            advanced=False,
+            required=True,
+            info="The name of the model to use. For example, `gpt-3.5-turbo`.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Chat LiteLLM API Key",
+            advanced=False,
+            required=False,
+        ),
+        DropdownInput(
+            name="provider",
+            display_name="Provider",
+            info="The provider of the API key.",
+            options=[
+                "OpenAI",
+                "Azure",
+                "Anthropic",
+                "Replicate",
+                "Cohere",
+                "OpenRouter",
+            ],
+        ),
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            advanced=False,
+            required=False,
+            value=0.7,
+        ),
+        DictInput(
+            name="kwargs",
+            display_name="Kwargs",
+            advanced=True,
+            required=False,
+            is_list=True,
+            value={},
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model kwargs",
+            advanced=True,
+            required=False,
+            is_list=True,
+            value={},
+        ),
+        FloatInput(name="top_p", display_name="Top p", advanced=True, required=False, value=0.5),
+        IntInput(name="top_k", display_name="Top k", advanced=True, required=False, value=35),
+        IntInput(
+            name="n",
+            display_name="N",
+            advanced=True,
+            required=False,
+            info="Number of chat completions to generate for each prompt. "
+            "Note that the API may not return the full n completions if duplicates are generated.",
+            value=1,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max tokens",
+            advanced=False,
+            value=256,
+            info="The maximum number of tokens to generate for each chat completion.",
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max retries",
+            advanced=True,
+            required=False,
+            value=6,
+        ),
+        BoolInput(
+            name="verbose",
+            display_name="Verbose",
+            advanced=True,
+            required=False,
+            value=False,
+        ),
+        BoolInput(
+            name="stream",
+            display_name="Stream",
+            info=STREAM_INFO_TEXT,
+            advanced=True,
+        ),
+        StrInput(
+            name="system_message",
+            display_name="System Message",
+            info="System message to pass to the model.",
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            import litellm
+
+            litellm.drop_params = True
+            litellm.set_verbose = self.verbose
+        except ImportError as e:
+            msg = "Could not import litellm python package. Please install it with `pip install litellm`"
+            raise ChatLiteLLMException(msg) from e
+        # Remove empty keys
+        if "" in self.kwargs:
+            del self.kwargs[""]
+        if "" in self.model_kwargs:
+            del self.model_kwargs[""]
+        # Report missing fields for Azure provider
+        if self.provider == "Azure":
+            if "api_base" not in self.kwargs:
+                msg = "Missing api_base on kwargs"
+                raise ValueError(msg)
+            if "api_version" not in self.model_kwargs:
+                msg = "Missing api_version on model_kwargs"
+                raise ValueError(msg)
+        output = ChatLiteLLM(
+            model=f"{self.provider.lower()}/{self.model}",
+            client=None,
+            streaming=self.stream,
+            temperature=self.temperature,
+            model_kwargs=self.model_kwargs if self.model_kwargs is not None else {},
+            top_p=self.top_p,
+            top_k=self.top_k,
+            n=self.n,
+            max_tokens=self.max_tokens,
+            max_retries=self.max_retries,
+            **self.kwargs,
+        )
+        output.client.api_key = self.api_key
+
+        return output

lfx/components/deactivated/code_block_extractor.py

@@ -0,0 +1,26 @@
+import re
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Input, Output, Text
+
+
+class CodeBlockExtractor(Component):
+    display_name = "Code Block Extractor"
+    description = "Extracts code block from text."
+    name = "CodeBlockExtractor"
+
+    inputs = [Input(name="text", field_type=Text, description="Text to extract code blocks from.")]
+
+    outputs = [Output(name="code_block", display_name="Code Block", method="get_code_block")]
+
+    def get_code_block(self) -> Text:
+        text = self.text.strip()
+        # Extract code block
+        # It may start with ``` or ```language
+        # It may end with ```
+        pattern = r"^```(?:\w+)?\s*\n(.*?)(?=^```)```"
+        match = re.search(pattern, text, re.MULTILINE)
+        code_block = ""
+        if match:
+            code_block = match.group(1)
+        return code_block

lfx/components/deactivated/documents_to_data.py

@@ -0,0 +1,22 @@
+from langchain_core.documents import Document
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.schema.data import Data
+
+
+class DocumentsToDataComponent(CustomComponent):
+    display_name = "Documents ⇢ Data"
+    description = "Convert LangChain Documents into Data."
+    icon = "LangChain"
+    name = "DocumentsToData"
+
+    field_config = {
+        "documents": {"display_name": "Documents"},
+    }
+
+    def build(self, documents: list[Document]) -> list[Data]:
+        if isinstance(documents, Document):
+            documents = [documents]
+        data = [Data.from_document(document) for document in documents]
+        self.status = data
+        return data

lfx/components/deactivated/embed.py

@@ -0,0 +1,16 @@
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import Embeddings
+from lfx.schema.data import Data
+
+
+class EmbedComponent(CustomComponent):
+    display_name = "Embed Texts"
+    name = "Embed"
+
+    def build_config(self):
+        return {"texts": {"display_name": "Texts"}, "embbedings": {"display_name": "Embeddings"}}
+
+    def build(self, texts: list[str], embbedings: Embeddings) -> Data:
+        vectors = Data(vector=embbedings.embed_documents(texts))
+        self.status = vectors
+        return vectors

lfx/components/deactivated/extract_key_from_data.py

@@ -0,0 +1,46 @@
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.schema.data import Data
+
+
+class ExtractKeyFromDataComponent(CustomComponent):
+    display_name = "Extract Key From Data"
+    description = "Extracts a key from a data."
+    beta: bool = True
+    name = "ExtractKeyFromData"
+
+    field_config = {
+        "data": {"display_name": "Data"},
+        "keys": {
+            "display_name": "Keys",
+            "info": "The keys to extract from the data.",
+            "input_types": [],
+        },
+        "silent_error": {
+            "display_name": "Silent Errors",
+            "info": "If True, errors will not be raised.",
+            "advanced": True,
+        },
+    }
+
+    def build(self, data: Data, keys: list[str], *, silent_error: bool = True) -> Data:
+        """Extracts the keys from a data.
+
+        Args:
+            data (Data): The data from which to extract the keys.
+            keys (list[str]): The keys to extract from the data.
+            silent_error (bool): If True, errors will not be raised.
+
+        Returns:
+            dict: The extracted keys.
+        """
+        extracted_keys = {}
+        for key in keys:
+            try:
+                extracted_keys[key] = getattr(data, key)
+            except AttributeError as e:
+                if not silent_error:
+                    msg = f"The key '{key}' does not exist in the data."
+                    raise KeyError(msg) from e
+        return_data = Data(data=extracted_keys)
+        self.status = return_data
+        return return_data

lfx/components/deactivated/json_document_builder.py

@@ -0,0 +1,57 @@
+# JSON Document Builder
+
+# Build a Document containing a JSON object using a key and another Document page content.
+
+# **Params**
+
+# - **Key:** The key to use for the JSON object.
+# - **Document:** The Document page to use for the JSON object.
+
+# **Output**
+
+# - **Document:** The Document containing the JSON object.
+
+
+import orjson
+from langchain_core.documents import Document
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.io import HandleInput, StrInput
+
+
+class JSONDocumentBuilder(CustomComponent):
+    display_name: str = "JSON Document Builder"
+    description: str = "Build a Document containing a JSON object using a key and another Document page content."
+    name = "JSONDocumentBuilder"
+    documentation: str = "https://docs.langflow.org/legacy-core-components"
+    legacy = True
+
+    inputs = [
+        StrInput(
+            name="key",
+            display_name="Key",
+            required=True,
+        ),
+        HandleInput(
+            name="document",
+            display_name="Document",
+            required=True,
+        ),
+    ]
+
+    def build(
+        self,
+        key: str,
+        document: Document,
+    ) -> Document:
+        documents = None
+        if isinstance(document, list):
+            documents = [Document(page_content=orjson.dumps({key: doc.page_content}).decode()) for doc in document]
+        elif isinstance(document, Document):
+            documents = Document(page_content=orjson.dumps({key: document.page_content}).decode())
+        else:
+            msg = f"Expected Document or list of Documents, got {type(document)}"
+            raise TypeError(msg)
+
+        self.repr_value = documents
+        return documents

lfx/components/deactivated/list_flows.py

@@ -0,0 +1,20 @@
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.schema.data import Data
+
+
+class ListFlowsComponent(CustomComponent):
+    display_name = "List Flows"
+    description = "A component to list all available flows."
+    icon = "ListFlows"
+    beta: bool = True
+    name = "ListFlows"
+
+    def build_config(self):
+        return {}
+
+    async def build(
+        self,
+    ) -> list[Data]:
+        flows = await self.alist_flows()
+        self.status = flows
+        return flows

lfx/components/deactivated/mcp_sse.py

@@ -0,0 +1,61 @@
+# from lfx.field_typing import Data
+
+from langchain_core.tools import StructuredTool
+from mcp import types
+
+from lfx.base.mcp.util import (
+    MCPSseClient,
+    create_input_schema_from_json_schema,
+    create_tool_coroutine,
+    create_tool_func,
+)
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Tool
+from lfx.io import MessageTextInput, Output
+
+
+class MCPSse(Component):
+    client = MCPSseClient()
+    tools = types.ListToolsResult
+    tool_names = [str]
+    display_name = "MCP Tools (SSE) [DEPRECATED]"
+    description = "Connects to an MCP server over SSE and exposes it's tools as langflow tools to be used by an Agent."
+    documentation: str = "https://docs.langflow.org/components-custom-components"
+    icon = "code"
+    name = "MCPSse"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="url",
+            display_name="mcp sse url",
+            info="sse url",
+            value="http://localhost:7860/api/v1/mcp/sse",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Tools", name="tools", method="build_output"),
+    ]
+
+    async def build_output(self) -> list[Tool]:
+        if self.client.session is None:
+            self.tools = await self.client.connect_to_server(self.url, {})
+
+        tool_list = []
+
+        for tool in self.tools:
+            args_schema = create_input_schema_from_json_schema(tool.inputSchema)
+            tool_list.append(
+                StructuredTool(
+                    name=tool.name,  # maybe format this
+                    description=tool.description,
+                    args_schema=args_schema,
+                    func=create_tool_func(tool.name, args_schema, self.client.session),
+                    coroutine=create_tool_coroutine(tool.name, args_schema, self.client.session),
+                )
+            )
+
+        self.tool_names = [tool.name for tool in self.tools]
+        return tool_list

lfx/components/deactivated/mcp_stdio.py

@@ -0,0 +1,62 @@
+# from lfx.field_typing import Data
+
+from langchain_core.tools import StructuredTool
+from mcp import types
+
+from lfx.base.mcp.util import (
+    MCPStdioClient,
+    create_input_schema_from_json_schema,
+    create_tool_coroutine,
+    create_tool_func,
+)
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Tool
+from lfx.io import MessageTextInput, Output
+
+
+class MCPStdio(Component):
+    client = MCPStdioClient()
+    tools = types.ListToolsResult
+    tool_names = [str]
+    display_name = "MCP Tools (stdio) [DEPRECATED]"
+    description = (
+        "Connects to an MCP server over stdio and exposes it's tools as langflow tools to be used by an Agent."
+    )
+    documentation: str = "https://docs.langflow.org/components-custom-components"
+    icon = "code"
+    name = "MCPStdio"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="command",
+            display_name="mcp command",
+            info="mcp command",
+            value="uvx mcp-sse-shim@latest",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Tools", name="tools", method="build_output"),
+    ]
+
+    async def build_output(self) -> list[Tool]:
+        if self.client.session is None:
+            self.tools = await self.client.connect_to_server(self.command)
+
+        tool_list = []
+
+        for tool in self.tools:
+            args_schema = create_input_schema_from_json_schema(tool.inputSchema)
+            tool_list.append(
+                StructuredTool(
+                    name=tool.name,
+                    description=tool.description,
+                    args_schema=args_schema,
+                    func=create_tool_func(tool.name, args_schema, self.client.session),
+                    coroutine=create_tool_coroutine(tool.name, args_schema, self.client.session),
+                )
+            )
+        self.tool_names = [tool.name for tool in self.tools]
+        return tool_list

lfx/components/deactivated/merge_data.py

@@ -0,0 +1,93 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import DataInput, Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+
+
+class MergeDataComponent(Component):
+    """MergeDataComponent is responsible for combining multiple Data objects into a unified list of Data objects.
+
+    It ensures that all keys across the input Data objects are present in each merged Data object.
+    Missing keys are filled with empty strings to maintain consistency.
+    """
+
+    display_name = "Merge Data"
+    description = (
+        "Combines multiple Data objects into a unified list, ensuring all keys are present in each Data object."
+    )
+    icon = "merge"
+
+    inputs = [
+        DataInput(
+            name="data_inputs",
+            display_name="Data Inputs",
+            is_list=True,
+            info="A list of Data inputs objects to be merged.",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Merged Data",
+            name="merged_data",
+            method="merge_data",
+        ),
+    ]
+
+    def merge_data(self) -> list[Data]:
+        """Merges multiple Data objects into a single list of Data objects.
+
+        Ensures that all keys from the input Data objects are present in each merged Data object.
+        Missing keys are filled with empty strings.
+
+        Returns:
+            List[Data]: A list of merged Data objects with consistent keys.
+        """
+        logger.info("Initiating the data merging process.")
+
+        data_inputs: list[Data] = self.data_inputs
+        logger.debug(f"Received {len(data_inputs)} data input(s) for merging.")
+
+        if not data_inputs:
+            logger.warning("No data inputs provided. Returning an empty list.")
+            return []
+
+        # Collect all unique keys from all Data objects
+        all_keys: set[str] = set()
+        for idx, data_input in enumerate(data_inputs):
+            if not isinstance(data_input, Data):
+                error_message = f"Data input at index {idx} is not of type Data."
+                logger.error(error_message)
+                type_error_message = (
+                    f"All items in data_inputs must be of type Data. Item at index {idx} is {type(data_input)}"
+                )
+                raise TypeError(type_error_message)
+            all_keys.update(data_input.data.keys())
+        logger.debug(f"Collected {len(all_keys)} unique key(s) from input data.")
+
+        try:
+            # Create new list of Data objects with missing keys filled with empty strings
+            merged_data_list = []
+            for idx, data_input in enumerate(data_inputs):
+                merged_data_dict = {}
+
+                for key in all_keys:
+                    # Use the existing value if the key exists, otherwise use an empty string
+                    value = data_input.data.get(key, "")
+                    if key not in data_input.data:
+                        log_message = f"Key '{key}' missing in data input at index {idx}. Assigning empty string."
+                        logger.debug(log_message)
+                    merged_data_dict[key] = value
+
+                merged_data = Data(
+                    text_key=data_input.text_key, data=merged_data_dict, default_value=data_input.default_value
+                )
+                merged_data_list.append(merged_data)
+                logger.debug(f"Merged Data object created for input at index {idx}.")
+
+        except Exception:
+            logger.exception("An error occurred during the data merging process.")
+            raise
+
+        logger.info("Data merging process completed successfully.")
+        return merged_data_list

lfx/components/deactivated/message.py

@@ -0,0 +1,37 @@
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.schema.message import Message
+from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
+
+
+class MessageComponent(CustomComponent):
+    display_name = "Message"
+    description = "Creates a Message object given a Session ID."
+    name = "Message"
+
+    def build_config(self):
+        return {
+            "sender": {
+                "options": [MESSAGE_SENDER_AI, MESSAGE_SENDER_USER],
+                "display_name": "Sender Type",
+            },
+            "sender_name": {"display_name": "Sender Name"},
+            "text": {"display_name": "Text"},
+            "session_id": {
+                "display_name": "Session ID",
+                "info": "Session ID of the chat history.",
+                "input_types": ["Message"],
+            },
+        }
+
+    def build(
+        self,
+        sender: str = MESSAGE_SENDER_USER,
+        sender_name: str | None = None,
+        session_id: str | None = None,
+        text: str = "",
+    ) -> Message:
+        flow_id = self.graph.flow_id if hasattr(self, "graph") else None
+        message = Message(text=text, sender=sender, sender_name=sender_name, flow_id=flow_id, session_id=session_id)
+
+        self.status = message
+        return message