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

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,175 @@
+import contextlib
+import tempfile
+from pathlib import Path
+
+from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
+from lfx.field_typing import AgentExecutor
+from lfx.inputs.inputs import (
+    DictInput,
+    DropdownInput,
+    FileInput,
+    HandleInput,
+    MessageTextInput,
+)
+from lfx.schema.message import Message
+from lfx.services.deps import get_settings_service
+from lfx.template.field.base import Output
+from lfx.utils.async_helpers import run_until_complete
+
+
+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:
+        """Build and execute the CSV agent, returning the response."""
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
+
+        try:
+            agent_kwargs = {
+                "verbose": self.verbose,
+                "allow_dangerous_code": True,
+            }
+
+            # Get local path (downloads from S3 if needed)
+            local_path = self._get_local_path()
+
+            agent_csv = create_csv_agent(
+                llm=self.llm,
+                path=local_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"]))
+
+        finally:
+            # Clean up temp file if created
+            self._cleanup_temp_file()
+
+    def build_agent(self) -> AgentExecutor:
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
+
+        agent_kwargs = {
+            "verbose": self.verbose,
+            "allow_dangerous_code": True,
+        }
+
+        # Get local path (downloads from S3 if needed)
+        local_path = self._get_local_path()
+
+        agent_csv = create_csv_agent(
+            llm=self.llm,
+            path=local_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))
+
+        # Note: Temp file will be cleaned up when the component is destroyed or
+        # when build_agent_response is called
+        return agent_csv
+
+    def _get_local_path(self) -> str:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            str: Local file path that can be used by LangChain
+        """
+        file_path = self._path()
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            csv_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with .csv extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".csv"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(csv_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return temp_path
+
+        # Local storage - return path as-is
+        return file_path
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors

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,100 @@
+import contextlib
+import tempfile
+from pathlib import Path
+
+import yaml
+from langchain.agents import AgentExecutor
+
+from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
+from lfx.inputs.inputs import FileInput, HandleInput
+from lfx.services.deps import get_settings_service
+from lfx.utils.async_helpers import run_until_complete
+
+
+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 _get_local_path(self) -> Path:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            Path: Local file path that can be used by LangChain
+        """
+        file_path = self.path
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            file_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with appropriate extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".json"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(file_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return Path(temp_path)
+
+        # Local storage - return as Path
+        return Path(file_path)
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors
+
+    def build_agent(self) -> AgentExecutor:
+        """Build the JSON agent executor."""
+        try:
+            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
+        except ImportError as e:
+            msg = "langchain-community is not installed. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            # Get local path (downloads from S3 if needed)
+            path = self._get_local_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(str(path))
+            toolkit = JsonToolkit(spec=spec)
+
+            agent = create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+        except Exception:
+            # Make sure to clean up temp file on error
+            self._cleanup_temp_file()
+            raise
+        else:
+            # Clean up temp file after agent is created
+            self._cleanup_temp_file()
+            return agent

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="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/bundles-langchain"
+    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,
+        )