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

langflow/components/langchain_utilities/openai_tools.py

@@ -1,53 +0,0 @@
-from langchain.agents import create_openai_tools_agent
-from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, PromptTemplate
-
-from langflow.base.agents.agent import LCToolsAgentComponent
-from langflow.inputs.inputs import (
-    DataInput,
-    HandleInput,
-    MultilineInput,
-)
-from langflow.schema.data import Data
-
-
-class OpenAIToolsAgentComponent(LCToolsAgentComponent):
-    display_name: str = "OpenAI Tools Agent"
-    description: str = "Agent that uses tools via openai-tools."
-    icon = "LangChain"
-    name = "OpenAIToolsAgent"
-
-    inputs = [
-        *LCToolsAgentComponent._base_inputs,
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel", "ToolEnabledLanguageModel"],
-            required=True,
-        ),
-        MultilineInput(
-            name="system_prompt",
-            display_name="System Prompt",
-            info="System prompt for the agent.",
-            value="You are a helpful assistant",
-        ),
-        MultilineInput(
-            name="user_prompt", display_name="Prompt", info="This prompt must contain 'input' key.", value="{input}"
-        ),
-        DataInput(name="chat_history", display_name="Chat History", is_list=True, advanced=True),
-    ]
-
-    def get_chat_history_data(self) -> list[Data] | None:
-        return self.chat_history
-
-    def create_agent_runnable(self):
-        if "input" not in self.user_prompt:
-            msg = "Prompt must contain 'input' key."
-            raise ValueError(msg)
-        messages = [
-            ("system", self.system_prompt),
-            ("placeholder", "{chat_history}"),
-            HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=["input"], template=self.user_prompt)),
-            ("placeholder", "{agent_scratchpad}"),
-        ]
-        prompt = ChatPromptTemplate.from_messages(messages)
-        return create_openai_tools_agent(self.llm, self.tools, prompt)

langflow/components/langchain_utilities/openapi.py

@@ -1,48 +0,0 @@
-from pathlib import Path
-
-import yaml
-from langchain.agents import AgentExecutor
-from langchain_community.agent_toolkits import create_openapi_agent
-from langchain_community.agent_toolkits.openapi.toolkit import OpenAPIToolkit
-from langchain_community.tools.json.tool import JsonSpec
-from langchain_community.utilities.requests import TextRequestsWrapper
-
-from langflow.base.agents.agent import LCAgentComponent
-from langflow.inputs.inputs import BoolInput, FileInput, HandleInput
-
-
-class OpenAPIAgentComponent(LCAgentComponent):
-    display_name = "OpenAPI Agent"
-    description = "Agent to interact with OpenAPI API."
-    name = "OpenAPIAgent"
-    icon = "LangChain"
-    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),
-        BoolInput(name="allow_dangerous_requests", display_name="Allow Dangerous Requests", value=False, 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)
-        requests_wrapper = TextRequestsWrapper()
-        toolkit = OpenAPIToolkit.from_llm(
-            llm=self.llm,
-            json_spec=spec,
-            requests_wrapper=requests_wrapper,
-            allow_dangerous_requests=self.allow_dangerous_requests,
-        )
-
-        agent_args = self.get_agent_kwargs()
-
-        # This is bit weird - generally other create_*_agent functions have max_iterations in the
-        # `agent_executor_kwargs`, but openai has this parameter passed directly.
-        agent_args["max_iterations"] = agent_args["agent_executor_kwargs"]["max_iterations"]
-        del agent_args["agent_executor_kwargs"]["max_iterations"]
-        return create_openapi_agent(llm=self.llm, toolkit=toolkit, **agent_args)

langflow/components/langchain_utilities/recursive_character.py

@@ -1,60 +0,0 @@
-from typing import Any
-
-from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
-
-from langflow.base.textsplitters.model import LCTextSplitterComponent
-from langflow.inputs.inputs import DataInput, IntInput, MessageTextInput
-from langflow.utils.util import unescape_string
-
-
-class RecursiveCharacterTextSplitterComponent(LCTextSplitterComponent):
-    display_name: str = "Recursive Character Text Splitter"
-    description: str = "Split text trying to keep all related text together."
-    documentation: str = "https://docs.langflow.org/components-processing"
-    name = "RecursiveCharacterTextSplitter"
-    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="separators",
-            display_name="Separators",
-            info='The characters to split on.\nIf left empty defaults to ["\\n\\n", "\\n", " ", ""].',
-            is_list=True,
-        ),
-    ]
-
-    def get_data_input(self) -> Any:
-        return self.data_input
-
-    def build_text_splitter(self) -> TextSplitter:
-        if not self.separators:
-            separators: list[str] | None = None
-        else:
-            # check if the separators list has escaped characters
-            # if there are escaped characters, unescape them
-            separators = [unescape_string(x) for x in self.separators]
-
-        return RecursiveCharacterTextSplitter(
-            separators=separators,
-            chunk_size=self.chunk_size,
-            chunk_overlap=self.chunk_overlap,
-        )

langflow/components/langchain_utilities/retrieval_qa.py

@@ -1,83 +0,0 @@
-from typing import cast
-
-from langchain.chains import RetrievalQA
-
-from langflow.base.chains.model import LCChainComponent
-from langflow.inputs.inputs import BoolInput, DropdownInput, HandleInput, MultilineInput
-from langflow.schema.message import Message
-
-
-class RetrievalQAComponent(LCChainComponent):
-    display_name = "Retrieval QA"
-    description = "Chain for question-answering querying sources from a retriever."
-    name = "RetrievalQA"
-    legacy: bool = True
-    icon = "LangChain"
-    inputs = [
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            info="The input value to pass to the chain.",
-            required=True,
-        ),
-        DropdownInput(
-            name="chain_type",
-            display_name="Chain Type",
-            info="Chain type to use.",
-            options=["Stuff", "Map Reduce", "Refine", "Map Rerank"],
-            value="Stuff",
-            advanced=True,
-        ),
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        HandleInput(
-            name="retriever",
-            display_name="Retriever",
-            input_types=["Retriever"],
-            required=True,
-        ),
-        HandleInput(
-            name="memory",
-            display_name="Memory",
-            input_types=["BaseChatMemory"],
-        ),
-        BoolInput(
-            name="return_source_documents",
-            display_name="Return Source Documents",
-            value=False,
-        ),
-    ]
-
-    def invoke_chain(self) -> Message:
-        chain_type = self.chain_type.lower().replace(" ", "_")
-        if self.memory:
-            self.memory.input_key = "query"
-            self.memory.output_key = "result"
-
-        runnable = RetrievalQA.from_chain_type(
-            llm=self.llm,
-            chain_type=chain_type,
-            retriever=self.retriever,
-            memory=self.memory,
-            # always include to help debugging
-            #
-            return_source_documents=True,
-        )
-
-        result = runnable.invoke(
-            {"query": self.input_value},
-            config={"callbacks": self.get_langchain_callbacks()},
-        )
-
-        source_docs = self.to_data(result.get("source_documents", keys=[]))
-        result_str = str(result.get("result", ""))
-        if self.return_source_documents and len(source_docs):
-            references_str = self.create_references_from_data(source_docs)
-            result_str = f"{result_str}\n{references_str}"
-        # put the entire result to debug history, query and content
-        self.status = {**result, "source_documents": source_docs, "output": result_str}
-        return cast("Message", result_str)

langflow/components/langchain_utilities/runnable_executor.py

@@ -1,137 +0,0 @@
-from langchain.agents import AgentExecutor
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, HandleInput, MessageTextInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class RunnableExecComponent(Component):
-    description = "Execute a runnable. It will try to guess the input and output keys."
-    display_name = "Runnable Executor"
-    name = "RunnableExecutor"
-    beta: bool = True
-    icon = "LangChain"
-
-    inputs = [
-        MessageTextInput(name="input_value", display_name="Input", required=True),
-        HandleInput(
-            name="runnable",
-            display_name="Agent Executor",
-            input_types=["Chain", "AgentExecutor", "Agent", "Runnable"],
-            required=True,
-        ),
-        MessageTextInput(
-            name="input_key",
-            display_name="Input Key",
-            value="input",
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="output_key",
-            display_name="Output Key",
-            value="output",
-            advanced=True,
-        ),
-        BoolInput(
-            name="use_stream",
-            display_name="Stream",
-            value=False,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Message",
-            name="text",
-            method="build_executor",
-        ),
-    ]
-
-    def get_output(self, result, input_key, output_key):
-        """Retrieves the output value from the given result dictionary based on the specified input and output keys.
-
-        Args:
-            result (dict): The result dictionary containing the output value.
-            input_key (str): The key used to retrieve the input value from the result dictionary.
-            output_key (str): The key used to retrieve the output value from the result dictionary.
-
-        Returns:
-            tuple: A tuple containing the output value and the status message.
-
-        """
-        possible_output_keys = ["answer", "response", "output", "result", "text"]
-        status = ""
-        result_value = None
-
-        if output_key in result:
-            result_value = result.get(output_key)
-        elif len(result) == 2 and input_key in result:  # noqa: PLR2004
-            # get the other key from the result dict
-            other_key = next(k for k in result if k != input_key)
-            if other_key == output_key:
-                result_value = result.get(output_key)
-            else:
-                status += f"Warning: The output key is not '{output_key}'. The output key is '{other_key}'."
-                result_value = result.get(other_key)
-        elif len(result) == 1:
-            result_value = next(iter(result.values()))
-        elif any(k in result for k in possible_output_keys):
-            for key in possible_output_keys:
-                if key in result:
-                    result_value = result.get(key)
-                    status += f"Output key: '{key}'."
-                    break
-            if result_value is None:
-                result_value = result
-                status += f"Warning: The output key is not '{output_key}'."
-        else:
-            result_value = result
-            status += f"Warning: The output key is not '{output_key}'."
-
-        return result_value, status
-
-    def get_input_dict(self, runnable, input_key, input_value):
-        """Returns a dictionary containing the input key-value pair for the given runnable.
-
-        Args:
-            runnable: The runnable object.
-            input_key: The key for the input value.
-            input_value: The value for the input key.
-
-        Returns:
-            input_dict: A dictionary containing the input key-value pair.
-            status: A status message indicating if the input key is not in the runnable's input keys.
-        """
-        input_dict = {}
-        status = ""
-        if hasattr(runnable, "input_keys"):
-            # Check if input_key is in the runnable's input_keys
-            if input_key in runnable.input_keys:
-                input_dict[input_key] = input_value
-            else:
-                input_dict = dict.fromkeys(runnable.input_keys, input_value)
-                status = f"Warning: The input key is not '{input_key}'. The input key is '{runnable.input_keys}'."
-        return input_dict, status
-
-    async def build_executor(self) -> Message:
-        input_dict, status = self.get_input_dict(self.runnable, self.input_key, self.input_value)
-        if not isinstance(self.runnable, AgentExecutor):
-            msg = "The runnable must be an AgentExecutor"
-            raise TypeError(msg)
-
-        if self.use_stream:
-            return self.astream_events(input_dict)
-        result = await self.runnable.ainvoke(input_dict)
-        result_value, status_ = self.get_output(result, self.input_key, self.output_key)
-        status += status_
-        status += f"\n\nOutput: {result_value}\n\nRaw Output: {result}"
-        self.status = status
-        return result_value
-
-    async def astream_events(self, runnable_input):
-        async for event in self.runnable.astream_events(runnable_input, version="v1"):
-            if event.get("event") != "on_chat_model_stream":
-                continue
-
-            yield event.get("data").get("chunk")

langflow/components/langchain_utilities/self_query.py

@@ -1,80 +0,0 @@
-from langchain.chains.query_constructor.base import AttributeInfo
-from langchain.retrievers.self_query.base import SelfQueryRetriever
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import HandleInput, MessageTextInput
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-class SelfQueryRetrieverComponent(Component):
-    display_name = "Self Query Retriever"
-    description = "Retriever that uses a vector store and an LLM to generate the vector store queries."
-    name = "SelfQueryRetriever"
-    icon = "LangChain"
-    legacy: bool = True
-
-    inputs = [
-        HandleInput(
-            name="query",
-            display_name="Query",
-            info="Query to be passed as input.",
-            input_types=["Message"],
-        ),
-        HandleInput(
-            name="vectorstore",
-            display_name="Vector Store",
-            info="Vector Store to be passed as input.",
-            input_types=["VectorStore"],
-        ),
-        HandleInput(
-            name="attribute_infos",
-            display_name="Metadata Field Info",
-            info="Metadata Field Info to be passed as input.",
-            input_types=["Data"],
-            is_list=True,
-        ),
-        MessageTextInput(
-            name="document_content_description",
-            display_name="Document Content Description",
-            info="Document Content Description to be passed as input.",
-        ),
-        HandleInput(
-            name="llm",
-            display_name="LLM",
-            info="LLM to be passed as input.",
-            input_types=["LanguageModel"],
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Retrieved Documents",
-            name="documents",
-            method="retrieve_documents",
-        ),
-    ]
-
-    def retrieve_documents(self) -> list[Data]:
-        metadata_field_infos = [AttributeInfo(**value.data) for value in self.attribute_infos]
-        self_query_retriever = SelfQueryRetriever.from_llm(
-            llm=self.llm,
-            vectorstore=self.vectorstore,
-            document_contents=self.document_content_description,
-            metadata_field_info=metadata_field_infos,
-            enable_limit=True,
-        )
-
-        if isinstance(self.query, Message):
-            input_text = self.query.text
-        elif isinstance(self.query, str):
-            input_text = self.query
-        else:
-            msg = f"Query type {type(self.query)} not supported."
-            raise TypeError(msg)
-
-        documents = self_query_retriever.invoke(input=input_text, config={"callbacks": self.get_langchain_callbacks()})
-        data = [Data.from_document(document) for document in documents]
-        self.status = data
-        return data

langflow/components/langchain_utilities/spider.py

@@ -1,142 +0,0 @@
-from spider.spider import Spider
-
-from langflow.base.langchain_utilities.spider_constants import MODES
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    IntInput,
-    Output,
-    SecretStrInput,
-    StrInput,
-)
-from langflow.schema.data import Data
-
-
-class SpiderTool(Component):
-    display_name: str = "Spider Web Crawler & Scraper"
-    description: str = "Spider API for web crawling and scraping."
-    output_types: list[str] = ["Document"]
-    documentation: str = "https://spider.cloud/docs/api"
-
-    inputs = [
-        SecretStrInput(
-            name="spider_api_key",
-            display_name="Spider API Key",
-            required=True,
-            password=True,
-            info="The Spider API Key, get it from https://spider.cloud",
-        ),
-        StrInput(
-            name="url",
-            display_name="URL",
-            required=True,
-            info="The URL to scrape or crawl",
-        ),
-        DropdownInput(
-            name="mode",
-            display_name="Mode",
-            required=True,
-            options=MODES,
-            value=MODES[0],
-            info="The mode of operation: scrape or crawl",
-        ),
-        IntInput(
-            name="limit",
-            display_name="Limit",
-            info="The maximum amount of pages allowed to crawl per website. Set to 0 to crawl all pages.",
-            advanced=True,
-        ),
-        IntInput(
-            name="depth",
-            display_name="Depth",
-            info="The crawl limit for maximum depth. If 0, no limit will be applied.",
-            advanced=True,
-        ),
-        StrInput(
-            name="blacklist",
-            display_name="Blacklist",
-            info="Blacklist paths that you do not want to crawl. Use Regex patterns.",
-            advanced=True,
-        ),
-        StrInput(
-            name="whitelist",
-            display_name="Whitelist",
-            info="Whitelist paths that you want to crawl, ignoring all other routes. Use Regex patterns.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="readability",
-            display_name="Use Readability",
-            info="Use readability to pre-process the content for reading.",
-            advanced=True,
-        ),
-        IntInput(
-            name="request_timeout",
-            display_name="Request Timeout",
-            info="Timeout for the request in seconds.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="metadata",
-            display_name="Metadata",
-            info="Include metadata in the response.",
-            advanced=True,
-        ),
-        DictInput(
-            name="params",
-            display_name="Additional Parameters",
-            info="Additional parameters to pass to the API. If provided, other inputs will be ignored.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Markdown", name="content", method="crawl"),
-    ]
-
-    def crawl(self) -> list[Data]:
-        if self.params:
-            parameters = self.params["data"]
-        else:
-            parameters = {
-                "limit": self.limit or None,
-                "depth": self.depth or None,
-                "blacklist": self.blacklist or None,
-                "whitelist": self.whitelist or None,
-                "readability": self.readability,
-                "request_timeout": self.request_timeout or None,
-                "metadata": self.metadata,
-                "return_format": "markdown",
-            }
-
-        app = Spider(api_key=self.spider_api_key)
-        if self.mode == "scrape":
-            parameters["limit"] = 1
-            result = app.scrape_url(self.url, parameters)
-        elif self.mode == "crawl":
-            result = app.crawl_url(self.url, parameters)
-        else:
-            msg = f"Invalid mode: {self.mode}. Must be 'scrape' or 'crawl'."
-            raise ValueError(msg)
-
-        records = []
-
-        for record in result:
-            if self.metadata:
-                records.append(
-                    Data(
-                        data={
-                            "content": record["content"],
-                            "url": record["url"],
-                            "metadata": record["metadata"],
-                        }
-                    )
-                )
-            else:
-                records.append(Data(data={"content": record["content"], "url": record["url"]}))
-        return records
-
-
-class SpiderToolError(Exception):
-    """SpiderTool error."""

langflow/components/langchain_utilities/sql.py

@@ -1,40 +0,0 @@
-from langchain.agents import AgentExecutor
-from langchain_community.agent_toolkits import SQLDatabaseToolkit
-from langchain_community.agent_toolkits.sql.base import create_sql_agent
-from langchain_community.utilities import SQLDatabase
-
-from langflow.base.agents.agent import LCAgentComponent
-from langflow.inputs.inputs import HandleInput, MessageTextInput
-from langflow.template.field.base import Output
-
-
-class SQLAgentComponent(LCAgentComponent):
-    display_name = "SQLAgent"
-    description = "Construct an SQL agent from an LLM and tools."
-    name = "SQLAgent"
-    icon = "LangChain"
-    inputs = [
-        *LCAgentComponent._base_inputs,
-        HandleInput(name="llm", display_name="Language Model", input_types=["LanguageModel"], required=True),
-        MessageTextInput(name="database_uri", display_name="Database URI", required=True),
-        HandleInput(
-            name="extra_tools",
-            display_name="Extra Tools",
-            input_types=["Tool"],
-            is_list=True,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Response", name="response", method="message_response"),
-        Output(display_name="Agent", name="agent", method="build_agent", tool_mode=False),
-    ]
-
-    def build_agent(self) -> AgentExecutor:
-        db = SQLDatabase.from_uri(self.database_uri)
-        toolkit = SQLDatabaseToolkit(db=db, llm=self.llm)
-        agent_args = self.get_agent_kwargs()
-        agent_args["max_iterations"] = agent_args["agent_executor_kwargs"]["max_iterations"]
-        del agent_args["agent_executor_kwargs"]["max_iterations"]
-        return create_sql_agent(llm=self.llm, toolkit=toolkit, extra_tools=self.extra_tools or [], **agent_args)

langflow/components/langchain_utilities/sql_database.py

@@ -1,35 +0,0 @@
-from langchain_community.utilities.sql_database import SQLDatabase
-from sqlalchemy import create_engine
-from sqlalchemy.pool import StaticPool
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import (
-    Output,
-    StrInput,
-)
-
-
-class SQLDatabaseComponent(Component):
-    display_name = "SQLDatabase"
-    description = "SQL Database"
-    name = "SQLDatabase"
-    icon = "LangChain"
-
-    inputs = [
-        StrInput(name="uri", display_name="URI", info="URI to the database.", required=True),
-    ]
-
-    outputs = [
-        Output(display_name="SQLDatabase", name="SQLDatabase", method="build_sqldatabase"),
-    ]
-
-    def clean_up_uri(self, uri: str) -> str:
-        if uri.startswith("postgres://"):
-            uri = uri.replace("postgres://", "postgresql://")
-        return uri.strip()
-
-    def build_sqldatabase(self) -> SQLDatabase:
-        uri = self.clean_up_uri(self.uri)
-        # Create an engine using SQLAlchemy with StaticPool
-        engine = create_engine(uri, poolclass=StaticPool)
-        return SQLDatabase(engine)