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

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/components/utilities#json-document-builder"
+    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

lfx/components/deactivated/metal.py

@@ -0,0 +1,54 @@
+# mypy: disable-error-code="attr-defined"
+from langchain_community.retrievers import MetalRetriever
+
+from lfx.base.vectorstores.model import check_cached_vector_store
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.io import DictInput, SecretStrInput, StrInput
+
+
+class MetalRetrieverComponent(CustomComponent):
+    display_name: str = "Metal Retriever"
+    description: str = "Retriever that uses the Metal API."
+    name = "MetalRetriever"
+    legacy = True
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            required=True,
+        ),
+        SecretStrInput(
+            name="client_id",
+            display_name="Client ID",
+            required=True,
+        ),
+        StrInput(
+            name="index_id",
+            display_name="Index ID",
+            required=True,
+        ),
+        DictInput(
+            name="params",
+            display_name="Parameters",
+            required=False,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> MetalRetriever:
+        """Builds the Metal Retriever."""
+        try:
+            from langchain_community.retrievers import MetalRetriever
+            from metal_sdk.metal import Metal
+        except ImportError as e:
+            msg = "Could not import Metal. Please install it with `pip install metal-sdk langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            metal = Metal(api_key=self.api_key, client_id=self.client_id, index_id=self.index_id)
+        except Exception as e:
+            msg = "Could not connect to Metal API."
+            raise ValueError(msg) from e
+
+        return MetalRetriever(client=metal, params=self.params or {})

lfx/components/deactivated/multi_query.py

@@ -0,0 +1,59 @@
+from langchain.prompts import PromptTemplate
+from langchain.retrievers import MultiQueryRetriever
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import BaseRetriever, LanguageModel, Text
+from lfx.inputs.inputs import HandleInput, StrInput
+
+
+class MultiQueryRetrieverComponent(CustomComponent):
+    display_name = "MultiQueryRetriever"
+    description = "Initialize from llm using default template."
+    documentation = "https://python.langchain.com/docs/modules/data_connection/retrievers/how_to/MultiQueryRetriever"
+    name = "MultiQueryRetriever"
+    legacy = True
+
+    inputs = [
+        HandleInput(
+            name="llm",
+            display_name="LLM",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        HandleInput(
+            name="retriever",
+            display_name="Retriever",
+            input_types=["BaseRetriever"],
+            required=True,
+        ),
+        StrInput(
+            name="prompt",
+            display_name="Prompt",
+            value="You are an AI language model assistant. Your task is \n"
+            "to generate 3 different versions of the given user \n"
+            "question to retrieve relevant documents from a vector database. \n"
+            "By generating multiple perspectives on the user question, \n"
+            "your goal is to help the user overcome some of the limitations \n"
+            "of distance-based similarity search. Provide these alternative \n"
+            "questions separated by newlines. Original question: {question}",
+            required=False,
+        ),
+        StrInput(
+            name="parser_key",
+            display_name="Parser Key",
+            value="lines",
+            required=False,
+        ),
+    ]
+
+    def build(
+        self,
+        llm: LanguageModel,
+        retriever: BaseRetriever,
+        prompt: Text | None = None,
+        parser_key: str = "lines",
+    ) -> MultiQueryRetriever:
+        if not prompt:
+            return MultiQueryRetriever.from_llm(llm=llm, retriever=retriever, parser_key=parser_key)
+        prompt_template = PromptTemplate.from_template(prompt)
+        return MultiQueryRetriever.from_llm(llm=llm, retriever=retriever, prompt=prompt_template, parser_key=parser_key)

lfx/components/deactivated/retriever.py

@@ -0,0 +1,43 @@
+from langchain_core.tools import create_retriever_tool
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import BaseRetriever, Tool
+from lfx.io import HandleInput, StrInput
+
+
+class RetrieverToolComponent(CustomComponent):
+    display_name = "RetrieverTool"
+    description = "Tool for interacting with retriever"
+    name = "RetrieverTool"
+    icon = "LangChain"
+    legacy = True
+
+    inputs = [
+        HandleInput(
+            name="retriever",
+            display_name="Retriever",
+            info="Retriever to interact with",
+            input_types=["Retriever"],
+            required=True,
+        ),
+        StrInput(
+            name="name",
+            display_name="Name",
+            info="Name of the tool",
+            required=True,
+        ),
+        StrInput(
+            name="description",
+            display_name="Description",
+            info="Description of the tool",
+            required=True,
+        ),
+    ]
+
+    def build(self, retriever: BaseRetriever, name: str, description: str, **kwargs) -> Tool:
+        _ = kwargs
+        return create_retriever_tool(
+            retriever=retriever,
+            name=name,
+            description=description,
+        )

lfx/components/deactivated/selective_passthrough.py

@@ -0,0 +1,77 @@
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Text
+from lfx.io import BoolInput, DropdownInput, MessageTextInput, Output
+
+
+class SelectivePassThroughComponent(Component):
+    display_name = "Selective Pass Through"
+    description = "Passes the specified value if a specified condition is met."
+    icon = "filter"
+    name = "SelectivePassThrough"
+
+    inputs = [
+        MessageTextInput(
+            name="input_value",
+            display_name="Input Value",
+            info="The primary input value to evaluate.",
+        ),
+        MessageTextInput(
+            name="comparison_value",
+            display_name="Comparison Value",
+            info="The value to compare against the input value.",
+        ),
+        DropdownInput(
+            name="operator",
+            display_name="Operator",
+            options=["equals", "not equals", "contains", "starts with", "ends with"],
+            info="Condition to evaluate the input value.",
+        ),
+        MessageTextInput(
+            name="value_to_pass",
+            display_name="Value to Pass",
+            info="The value to pass if the condition is met.",
+        ),
+        BoolInput(
+            name="case_sensitive",
+            display_name="Case Sensitive",
+            info="If true, the comparison will be case sensitive.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Passed Output", name="passed_output", method="pass_through"),
+    ]
+
+    def evaluate_condition(
+        self, input_value: str, comparison_value: str, operator: str, *, case_sensitive: bool
+    ) -> bool:
+        if not case_sensitive:
+            input_value = input_value.lower()
+            comparison_value = comparison_value.lower()
+
+        if operator == "equals":
+            return input_value == comparison_value
+        if operator == "not equals":
+            return input_value != comparison_value
+        if operator == "contains":
+            return comparison_value in input_value
+        if operator == "starts with":
+            return input_value.startswith(comparison_value)
+        if operator == "ends with":
+            return input_value.endswith(comparison_value)
+        return False
+
+    def pass_through(self) -> Text:
+        input_value = self.input_value
+        comparison_value = self.comparison_value
+        operator = self.operator
+        value_to_pass = self.value_to_pass
+        case_sensitive = self.case_sensitive
+
+        if self.evaluate_condition(input_value, comparison_value, operator, case_sensitive=case_sensitive):
+            self.status = value_to_pass
+            return value_to_pass
+        self.status = ""
+        return ""