langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/components/langchain_utilities/csv_agent.py

@@ -1,107 +0,0 @@
-from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
-
-from langflow.base.agents.agent import LCAgentComponent
-from langflow.field_typing import AgentExecutor
-from langflow.inputs.inputs import (
-    DictInput,
-    DropdownInput,
-    FileInput,
-    HandleInput,
-    MessageTextInput,
-)
-from langflow.schema.message import Message
-from langflow.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._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

langflow/components/langchain_utilities/fake_embeddings.py

@@ -1,26 +0,0 @@
-from langchain_community.embeddings import FakeEmbeddings
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.field_typing import Embeddings
-from langflow.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,
-        )

langflow/components/langchain_utilities/html_link_extractor.py

@@ -1,35 +0,0 @@
-from typing import Any
-
-from langchain_community.graph_vectorstores.extractors import HtmlLinkExtractor, LinkExtractorTransformer
-from langchain_core.documents import BaseDocumentTransformer
-
-from langflow.base.document_transformers.model import LCDocumentTransformerComponent
-from langflow.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()]
-        )

langflow/components/langchain_utilities/json_agent.py

@@ -1,45 +0,0 @@
-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 langflow.base.agents.agent import LCAgentComponent
-from langflow.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._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())

langflow/components/langchain_utilities/langchain_hub.py

@@ -1,126 +0,0 @@
-import re
-
-from langchain_core.prompts import HumanMessagePromptTemplate
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DefaultPromptField, SecretStrInput, StrInput
-from langflow.io import Output
-from langflow.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)

langflow/components/langchain_utilities/language_recursive.py

@@ -1,49 +0,0 @@
-from typing import Any
-
-from langchain_text_splitters import Language, RecursiveCharacterTextSplitter, TextSplitter
-
-from langflow.base.textsplitters.model import LCTextSplitterComponent
-from langflow.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,
-        )

langflow/components/langchain_utilities/language_semantic.py

@@ -1,138 +0,0 @@
-from langchain.docstore.document import Document
-from langchain_experimental.text_splitter import SemanticChunker
-
-from langflow.base.textsplitters.model import LCTextSplitterComponent
-from langflow.io import (
-    DropdownInput,
-    FloatInput,
-    HandleInput,
-    IntInput,
-    MessageTextInput,
-    Output,
-)
-from langflow.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

langflow/components/langchain_utilities/llm_checker.py

@@ -1,39 +0,0 @@
-from langchain.chains import LLMCheckerChain
-
-from langflow.base.chains.model import LCChainComponent
-from langflow.inputs.inputs import HandleInput, MultilineInput
-from langflow.schema.message 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)

langflow/components/langchain_utilities/llm_math.py

@@ -1,42 +0,0 @@
-from langchain.chains import LLMMathChain
-
-from langflow.base.chains.model import LCChainComponent
-from langflow.inputs.inputs import HandleInput, MultilineInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class LLMMathChainComponent(LCChainComponent):
-    display_name = "LLMMathChain"
-    description = "Chain that interprets a prompt and executes python code to do math."
-    documentation = "https://python.langchain.com/docs/modules/chains/additional/llm_math"
-    name = "LLMMathChain"
-    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,
-        ),
-    ]
-
-    outputs = [Output(display_name="Message", name="text", method="invoke_chain")]
-
-    def invoke_chain(self) -> Message:
-        chain = LLMMathChain.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)

langflow/components/langchain_utilities/natural_language.py

@@ -1,61 +0,0 @@
-from typing import Any
-
-from langchain_text_splitters import NLTKTextSplitter, TextSplitter
-
-from langflow.base.textsplitters.model import LCTextSplitterComponent
-from langflow.inputs.inputs import DataInput, IntInput, MessageTextInput
-from langflow.utils.util import unescape_string
-
-
-class NaturalLanguageTextSplitterComponent(LCTextSplitterComponent):
-    display_name = "Natural Language Text Splitter"
-    description = "Split text based on natural language boundaries, optimized for a specified language."
-    documentation = (
-        "https://python.langchain.com/v0.1/docs/modules/data_connection/document_transformers/split_by_token/#nltk"
-    )
-    name = "NaturalLanguageTextSplitter"
-    icon = "LangChain"
-    inputs = [
-        IntInput(
-            name="chunk_size",
-            display_name="Chunk Size",
-            info="The maximum number of characters in each chunk after splitting.",
-            value=1000,
-        ),
-        IntInput(
-            name="chunk_overlap",
-            display_name="Chunk Overlap",
-            info="The number of characters that overlap between consecutive chunks.",
-            value=200,
-        ),
-        DataInput(
-            name="data_input",
-            display_name="Input",
-            info="The text data to be split.",
-            input_types=["Document", "Data"],
-            required=True,
-        ),
-        MessageTextInput(
-            name="separator",
-            display_name="Separator",
-            info='The character(s) to use as a delimiter when splitting text.\nDefaults to "\\n\\n" if left empty.',
-        ),
-        MessageTextInput(
-            name="language",
-            display_name="Language",
-            info='The language of the text. Default is "English". '
-            "Supports multiple languages for better text boundary recognition.",
-        ),
-    ]
-
-    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 NLTKTextSplitter(
-            language=self.language.lower() if self.language else "english",
-            separator=separator,
-            chunk_size=self.chunk_size,
-            chunk_overlap=self.chunk_overlap,
-        )