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

lfx/components/langchain_utilities/character.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from langchain_text_splitters import CharacterTextSplitter, TextSplitter
+
+from lfx.base.textsplitters.model import LCTextSplitterComponent
+from lfx.inputs.inputs import DataInput, IntInput, MessageTextInput
+from lfx.utils.util import unescape_string
+
+
+class CharacterTextSplitterComponent(LCTextSplitterComponent):
+    display_name = "Character Text Splitter"
+    description = "Split text by number of characters."
+    documentation = "https://docs.langflow.org/components/text-splitters#charactertextsplitter"
+    name = "CharacterTextSplitter"
+    icon = "LangChain"
+
+    inputs = [
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk Size",
+            info="The maximum length of each chunk.",
+            value=1000,
+        ),
+        IntInput(
+            name="chunk_overlap",
+            display_name="Chunk Overlap",
+            info="The amount of overlap between chunks.",
+            value=200,
+        ),
+        DataInput(
+            name="data_input",
+            display_name="Input",
+            info="The texts to split.",
+            input_types=["Document", "Data"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="separator",
+            display_name="Separator",
+            info='The characters to split on.\nIf left empty defaults to "\\n\\n".',
+        ),
+    ]
+
+    def get_data_input(self) -> Any:
+        return self.data_input
+
+    def build_text_splitter(self) -> TextSplitter:
+        separator = unescape_string(self.separator) if self.separator else "\n\n"
+        return CharacterTextSplitter(
+            chunk_overlap=self.chunk_overlap,
+            chunk_size=self.chunk_size,
+            separator=separator,
+        )

lfx/components/langchain_utilities/conversation.py

@@ -0,0 +1,59 @@
+from lfx.base.chains.model import LCChainComponent
+from lfx.inputs.inputs import HandleInput, MultilineInput
+from lfx.schema.message import Message
+
+
+class ConversationChainComponent(LCChainComponent):
+    display_name = "ConversationChain"
+    description = "Chain to have a conversation and load context from memory."
+    name = "ConversationChain"
+    legacy: bool = True
+    icon = "LangChain"
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            info="The input value to pass to the chain.",
+            required=True,
+        ),
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        HandleInput(
+            name="memory",
+            display_name="Memory",
+            input_types=["BaseChatMemory"],
+        ),
+    ]
+
+    def invoke_chain(self) -> Message:
+        try:
+            from langchain.chains import ConversationChain
+        except ImportError as e:
+            msg = (
+                "ConversationChain requires langchain to be installed. Please install it with "
+                "`uv pip install langchain`."
+            )
+            raise ImportError(msg) from e
+
+        if not self.memory:
+            chain = ConversationChain(llm=self.llm)
+        else:
+            chain = ConversationChain(llm=self.llm, memory=self.memory)
+
+        result = chain.invoke(
+            {"input": self.input_value},
+            config={"callbacks": self.get_langchain_callbacks()},
+        )
+        if isinstance(result, dict):
+            result = result.get(chain.output_key, "")
+
+        elif not isinstance(result, str):
+            result = result.get("response")
+        result = str(result)
+        self.status = result
+        return Message(text=result)

lfx/components/langchain_utilities/csv_agent.py

@@ -0,0 +1,107 @@
+from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+
+from lfx.base.agents.agent import LCAgentComponent
+from lfx.field_typing import AgentExecutor
+from lfx.inputs.inputs import (
+    DictInput,
+    DropdownInput,
+    FileInput,
+    HandleInput,
+    MessageTextInput,
+)
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+
+
+class CSVAgentComponent(LCAgentComponent):
+    display_name = "CSV Agent"
+    description = "Construct a CSV agent from a CSV and tools."
+    documentation = "https://python.langchain.com/docs/modules/agents/toolkits/csv"
+    name = "CSVAgent"
+    icon = "LangChain"
+
+    inputs = [
+        *LCAgentComponent.get_base_inputs(),
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            input_types=["LanguageModel"],
+            required=True,
+            info="An LLM Model Object (It can be found in any LLM Component).",
+        ),
+        FileInput(
+            name="path",
+            display_name="File Path",
+            file_types=["csv"],
+            input_types=["str", "Message"],
+            required=True,
+            info="A CSV File or File Path.",
+        ),
+        DropdownInput(
+            name="agent_type",
+            display_name="Agent Type",
+            advanced=True,
+            options=["zero-shot-react-description", "openai-functions", "openai-tools"],
+            value="openai-tools",
+        ),
+        MessageTextInput(
+            name="input_value",
+            display_name="Text",
+            info="Text to be passed as input and extract info from the CSV File.",
+            required=True,
+        ),
+        DictInput(
+            name="pandas_kwargs",
+            display_name="Pandas Kwargs",
+            info="Pandas Kwargs to be passed to the agent.",
+            advanced=True,
+            is_list=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Response", name="response", method="build_agent_response"),
+        Output(display_name="Agent", name="agent", method="build_agent", hidden=True, tool_mode=False),
+    ]
+
+    def _path(self) -> str:
+        if isinstance(self.path, Message) and isinstance(self.path.text, str):
+            return self.path.text
+        return self.path
+
+    def build_agent_response(self) -> Message:
+        agent_kwargs = {
+            "verbose": self.verbose,
+            "allow_dangerous_code": True,
+        }
+
+        agent_csv = create_csv_agent(
+            llm=self.llm,
+            path=self._path(),
+            agent_type=self.agent_type,
+            handle_parsing_errors=self.handle_parsing_errors,
+            pandas_kwargs=self.pandas_kwargs,
+            **agent_kwargs,
+        )
+
+        result = agent_csv.invoke({"input": self.input_value})
+        return Message(text=str(result["output"]))
+
+    def build_agent(self) -> AgentExecutor:
+        agent_kwargs = {
+            "verbose": self.verbose,
+            "allow_dangerous_code": True,
+        }
+
+        agent_csv = create_csv_agent(
+            llm=self.llm,
+            path=self._path(),
+            agent_type=self.agent_type,
+            handle_parsing_errors=self.handle_parsing_errors,
+            pandas_kwargs=self.pandas_kwargs,
+            **agent_kwargs,
+        )
+
+        self.status = Message(text=str(agent_csv))
+
+        return agent_csv

lfx/components/langchain_utilities/fake_embeddings.py

@@ -0,0 +1,26 @@
+from langchain_community.embeddings import FakeEmbeddings
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.io import IntInput
+
+
+class FakeEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "Fake Embeddings"
+    description = "Generate fake embeddings, useful for initial testing and connecting components."
+    icon = "LangChain"
+    name = "LangChainFakeEmbeddings"
+
+    inputs = [
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have.",
+            value=5,
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return FakeEmbeddings(
+            size=self.dimensions or 5,
+        )

lfx/components/langchain_utilities/html_link_extractor.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+from langchain_community.graph_vectorstores.extractors import HtmlLinkExtractor, LinkExtractorTransformer
+from langchain_core.documents import BaseDocumentTransformer
+
+from lfx.base.document_transformers.model import LCDocumentTransformerComponent
+from lfx.inputs.inputs import BoolInput, DataInput, StrInput
+
+
+class HtmlLinkExtractorComponent(LCDocumentTransformerComponent):
+    display_name = "HTML Link Extractor"
+    description = "Extract hyperlinks from HTML content."
+    documentation = "https://python.langchain.com/v0.2/api_reference/community/graph_vectorstores/langchain_community.graph_vectorstores.extractors.html_link_extractor.HtmlLinkExtractor.html"
+    name = "HtmlLinkExtractor"
+    icon = "LangChain"
+
+    inputs = [
+        StrInput(name="kind", display_name="Kind of edge", value="hyperlink", required=False),
+        BoolInput(name="drop_fragments", display_name="Drop URL fragments", value=True, required=False),
+        DataInput(
+            name="data_input",
+            display_name="Input",
+            info="The texts from which to extract links.",
+            input_types=["Document", "Data"],
+            required=True,
+        ),
+    ]
+
+    def get_data_input(self) -> Any:
+        return self.data_input
+
+    def build_document_transformer(self) -> BaseDocumentTransformer:
+        return LinkExtractorTransformer(
+            [HtmlLinkExtractor(kind=self.kind, drop_fragments=self.drop_fragments).as_document_extractor()]
+        )

lfx/components/langchain_utilities/json_agent.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+import yaml
+from langchain.agents import AgentExecutor
+from langchain_community.agent_toolkits import create_json_agent
+from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
+from langchain_community.tools.json.tool import JsonSpec
+
+from lfx.base.agents.agent import LCAgentComponent
+from lfx.inputs.inputs import FileInput, HandleInput
+
+
+class JsonAgentComponent(LCAgentComponent):
+    display_name = "JsonAgent"
+    description = "Construct a json agent from an LLM and tools."
+    name = "JsonAgent"
+    legacy: bool = True
+
+    inputs = [
+        *LCAgentComponent.get_base_inputs(),
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        FileInput(
+            name="path",
+            display_name="File Path",
+            file_types=["json", "yaml", "yml"],
+            required=True,
+        ),
+    ]
+
+    def build_agent(self) -> AgentExecutor:
+        path = Path(self.path)
+        if path.suffix in {"yaml", "yml"}:
+            with path.open(encoding="utf-8") as file:
+                yaml_dict = yaml.safe_load(file)
+            spec = JsonSpec(dict_=yaml_dict)
+        else:
+            spec = JsonSpec.from_file(path)
+        toolkit = JsonToolkit(spec=spec)
+
+        return create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())

lfx/components/langchain_utilities/langchain_hub.py

@@ -0,0 +1,126 @@
+import re
+
+from langchain_core.prompts import HumanMessagePromptTemplate
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DefaultPromptField, SecretStrInput, StrInput
+from lfx.io import Output
+from lfx.schema.message import Message
+
+
+class LangChainHubPromptComponent(Component):
+    display_name: str = "Prompt Hub"
+    description: str = "Prompt Component that uses LangChain Hub prompts"
+    beta = True
+    icon = "LangChain"
+    trace_type = "prompt"
+    name = "LangChain Hub Prompt"
+
+    inputs = [
+        SecretStrInput(
+            name="langchain_api_key",
+            display_name="Your LangChain API Key",
+            info="The LangChain API Key to use.",
+            required=True,
+        ),
+        StrInput(
+            name="langchain_hub_prompt",
+            display_name="LangChain Hub Prompt",
+            info="The LangChain Hub prompt to use, i.e., 'efriis/my-first-prompt'",
+            refresh_button=True,
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Build Prompt", name="prompt", method="build_prompt"),
+    ]
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        # If the field is not langchain_hub_prompt or the value is empty, return the build config as is
+        if field_name != "langchain_hub_prompt" or not field_value:
+            return build_config
+
+        # Fetch the template
+        template = self._fetch_langchain_hub_template()
+
+        # Get the template's messages
+        if hasattr(template, "messages"):
+            template_messages = template.messages
+        else:
+            template_messages = [HumanMessagePromptTemplate(prompt=template)]
+
+        # Extract the messages from the prompt data
+        prompt_template = [message_data.prompt for message_data in template_messages]
+
+        # Regular expression to find all instances of {<string>}
+        pattern = r"\{(.*?)\}"
+
+        # Get all the custom fields
+        custom_fields: list[str] = []
+        full_template = ""
+        for message in prompt_template:
+            # Find all matches
+            matches = re.findall(pattern, message.template)
+            custom_fields += matches
+
+            # Create a string version of the full template
+            full_template = full_template + "\n" + message.template
+
+        # No need to reprocess if we have them already
+        if all("param_" + custom_field in build_config for custom_field in custom_fields):
+            return build_config
+
+        # Easter egg: Show template in info popup
+        build_config["langchain_hub_prompt"]["info"] = full_template
+
+        # Remove old parameter inputs if any
+        for key in build_config.copy():
+            if key.startswith("param_"):
+                del build_config[key]
+
+        # Now create inputs for each
+        for custom_field in custom_fields:
+            new_parameter = DefaultPromptField(
+                name=f"param_{custom_field}",
+                display_name=custom_field,
+                info="Fill in the value for {" + custom_field + "}",
+            ).to_dict()
+
+            # Add the new parameter to the build config
+            build_config[f"param_{custom_field}"] = new_parameter
+
+        return build_config
+
+    async def build_prompt(
+        self,
+    ) -> Message:
+        # Fetch the template
+        template = self._fetch_langchain_hub_template()
+
+        # Get the parameters from the attributes
+        params_dict = {param: getattr(self, "param_" + param, f"{{{param}}}") for param in template.input_variables}
+        original_params = {k: v.text if hasattr(v, "text") else v for k, v in params_dict.items() if v is not None}
+        prompt_value = template.invoke(original_params)
+
+        # Update the template with the new value
+        original_params["template"] = prompt_value.to_string()
+
+        # Now pass the filtered attributes to the function
+        prompt = Message.from_template(**original_params)
+
+        self.status = prompt.text
+
+        return prompt
+
+    def _fetch_langchain_hub_template(self):
+        import langchain.hub
+
+        # Check if the api key is provided
+        if not self.langchain_api_key:
+            msg = "Please provide a LangChain API Key"
+
+            raise ValueError(msg)
+
+        # Pull the prompt from LangChain Hub
+        return langchain.hub.pull(self.langchain_hub_prompt, api_key=self.langchain_api_key)

lfx/components/langchain_utilities/language_recursive.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+from langchain_text_splitters import Language, RecursiveCharacterTextSplitter, TextSplitter
+
+from lfx.base.textsplitters.model import LCTextSplitterComponent
+from lfx.inputs.inputs import DataInput, DropdownInput, IntInput
+
+
+class LanguageRecursiveTextSplitterComponent(LCTextSplitterComponent):
+    display_name: str = "Language Recursive Text Splitter"
+    description: str = "Split text into chunks of a specified length based on language."
+    documentation: str = "https://docs.langflow.org/components/text-splitters#languagerecursivetextsplitter"
+    name = "LanguageRecursiveTextSplitter"
+    icon = "LangChain"
+
+    inputs = [
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk Size",
+            info="The maximum length of each chunk.",
+            value=1000,
+        ),
+        IntInput(
+            name="chunk_overlap",
+            display_name="Chunk Overlap",
+            info="The amount of overlap between chunks.",
+            value=200,
+        ),
+        DataInput(
+            name="data_input",
+            display_name="Input",
+            info="The texts to split.",
+            input_types=["Document", "Data"],
+            required=True,
+        ),
+        DropdownInput(
+            name="code_language", display_name="Code Language", options=[x.value for x in Language], value="python"
+        ),
+    ]
+
+    def get_data_input(self) -> Any:
+        return self.data_input
+
+    def build_text_splitter(self) -> TextSplitter:
+        return RecursiveCharacterTextSplitter.from_language(
+            language=Language(self.code_language),
+            chunk_size=self.chunk_size,
+            chunk_overlap=self.chunk_overlap,
+        )

lfx/components/langchain_utilities/language_semantic.py

@@ -0,0 +1,138 @@
+from langchain.docstore.document import Document
+from langchain_experimental.text_splitter import SemanticChunker
+
+from lfx.base.textsplitters.model import LCTextSplitterComponent
+from lfx.io import (
+    DropdownInput,
+    FloatInput,
+    HandleInput,
+    IntInput,
+    MessageTextInput,
+    Output,
+)
+from lfx.schema.data import Data
+
+
+class SemanticTextSplitterComponent(LCTextSplitterComponent):
+    """Split text into semantically meaningful chunks using semantic similarity."""
+
+    display_name: str = "Semantic Text Splitter"
+    name: str = "SemanticTextSplitter"
+    description: str = "Split text into semantically meaningful chunks using semantic similarity."
+    documentation = "https://python.langchain.com/docs/how_to/semantic-chunker/"
+    beta = True  # this component is beta because it is imported from langchain_experimental
+    icon = "LangChain"
+
+    inputs = [
+        HandleInput(
+            name="data_inputs",
+            display_name="Data Inputs",
+            info="List of Data objects containing text and metadata to split.",
+            input_types=["Data"],
+            is_list=True,
+            required=True,
+        ),
+        HandleInput(
+            name="embeddings",
+            display_name="Embeddings",
+            info="Embeddings model to use for semantic similarity. Required.",
+            input_types=["Embeddings"],
+            is_list=False,
+            required=True,
+        ),
+        DropdownInput(
+            name="breakpoint_threshold_type",
+            display_name="Breakpoint Threshold Type",
+            info=(
+                "Method to determine breakpoints. Options: 'percentile', "
+                "'standard_deviation', 'interquartile'. Defaults to 'percentile'."
+            ),
+            value="percentile",
+            options=["percentile", "standard_deviation", "interquartile"],
+        ),
+        FloatInput(
+            name="breakpoint_threshold_amount",
+            display_name="Breakpoint Threshold Amount",
+            info="Numerical amount for the breakpoint threshold.",
+            value=0.5,
+        ),
+        IntInput(
+            name="number_of_chunks",
+            display_name="Number of Chunks",
+            info="Number of chunks to split the text into.",
+            value=5,
+        ),
+        MessageTextInput(
+            name="sentence_split_regex",
+            display_name="Sentence Split Regex",
+            info="Regular expression to split sentences. Optional.",
+            value="",
+            advanced=True,
+        ),
+        IntInput(
+            name="buffer_size",
+            display_name="Buffer Size",
+            info="Size of the buffer.",
+            value=0,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Chunks", name="chunks", method="split_text"),
+    ]
+
+    def _docs_to_data(self, docs: list[Document]) -> list[Data]:
+        """Convert a list of Document objects to Data objects."""
+        return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
+
+    def split_text(self) -> list[Data]:
+        """Split the input data into semantically meaningful chunks."""
+        try:
+            embeddings = getattr(self, "embeddings", None)
+            if embeddings is None:
+                error_msg = "An embeddings model is required for SemanticTextSplitter."
+                raise ValueError(error_msg)
+
+            if not self.data_inputs:
+                error_msg = "Data inputs cannot be empty."
+                raise ValueError(error_msg)
+
+            documents = []
+            for _input in self.data_inputs:
+                if isinstance(_input, Data):
+                    documents.append(_input.to_lc_document())
+                else:
+                    error_msg = f"Invalid data input type: {_input}"
+                    raise TypeError(error_msg)
+
+            if not documents:
+                error_msg = "No valid Data objects found in data_inputs."
+                raise ValueError(error_msg)
+
+            texts = [doc.page_content for doc in documents]
+            metadatas = [doc.metadata for doc in documents]
+
+            splitter_params = {
+                "embeddings": embeddings,
+                "breakpoint_threshold_type": self.breakpoint_threshold_type or "percentile",
+                "breakpoint_threshold_amount": self.breakpoint_threshold_amount,
+                "number_of_chunks": self.number_of_chunks,
+                "buffer_size": self.buffer_size,
+            }
+
+            if self.sentence_split_regex:
+                splitter_params["sentence_split_regex"] = self.sentence_split_regex
+
+            splitter = SemanticChunker(**splitter_params)
+            docs = splitter.create_documents(texts, metadatas=metadatas)
+
+            data = self._docs_to_data(docs)
+            self.status = data
+
+        except Exception as e:
+            error_msg = f"An error occurred during semantic splitting: {e}"
+            raise RuntimeError(error_msg) from e
+
+        else:
+            return data

lfx/components/langchain_utilities/llm_checker.py

@@ -0,0 +1,39 @@
+from langchain.chains import LLMCheckerChain
+
+from lfx.base.chains.model import LCChainComponent
+from lfx.inputs.inputs import HandleInput, MultilineInput
+from lfx.schema import Message
+
+
+class LLMCheckerChainComponent(LCChainComponent):
+    display_name = "LLMCheckerChain"
+    description = "Chain for question-answering with self-verification."
+    documentation = "https://python.langchain.com/docs/modules/chains/additional/llm_checker"
+    name = "LLMCheckerChain"
+    legacy: bool = True
+    icon = "LangChain"
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            info="The input value to pass to the chain.",
+            required=True,
+        ),
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+    ]
+
+    def invoke_chain(self) -> Message:
+        chain = LLMCheckerChain.from_llm(llm=self.llm)
+        response = chain.invoke(
+            {chain.input_key: self.input_value},
+            config={"callbacks": self.get_langchain_callbacks()},
+        )
+        result = response.get(chain.output_key, "")
+        result = str(result)
+        self.status = result
+        return Message(text=result)