Merge branch 'dev' into python_function_tool

Makefile

@@ -59,7 +59,7 @@ lcserve_push:
 	make build_frontend
 	@version=$$(poetry version --short); \
 	lc-serve push --app langflow.lcserve:app --app-dir . \
-		--image-name langflow --image-tag $${version} --verbose
+		--image-name langflow --image-tag $${version} --verbose --public
 
 lcserve_deploy:
 	@:$(if $(uses),,$(error `uses` is not set. Please run `make uses=... lcserve_deploy`))

poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.4.0 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.4.2 and should not be changed by hand.
 
 [[package]]
 name = "aiofiles"
@@ -1096,7 +1096,9 @@ files = [
     {file = "duckdb-0.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b2707096d6df4321044fcde2c9f04da632d11a8be60957fd09d49a42fae71a29"},
     {file = "duckdb-0.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b27df1b70ae74d2c88efb5ffca8490954fdc678099509a9c4404ca30acc53426"},
     {file = "duckdb-0.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75a97c800271b52dd0f37696d074c50576dcb4b2750b6115932a98696a268070"},
+    {file = "duckdb-0.8.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:804cac261a5e016506a6d67838a65d19b06a237f7949f1704f0e800eb708286a"},
     {file = "duckdb-0.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6b9abca7fa6713e1d031c18485343b4de99742c7e1b85c10718aa2f31a4e2c6"},
+    {file = "duckdb-0.8.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:51aa6d606d49072abcfeb3be209eb559ac94c1b5e70f58ac3adbb94aca9cd69f"},
     {file = "duckdb-0.8.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7c8dc769aaf2be0a1c57995ca657e5b92c1c56fc8437edb720ca6cab571adf14"},
     {file = "duckdb-0.8.0-cp311-cp311-win32.whl", hash = "sha256:c4207d18b42387c4a035846d8878eb967070198be8ac26fd77797ce320d1a400"},
     {file = "duckdb-0.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:0c392257547c20794c3072fcbca99a49ef0a49974005d755e93893e2b4875267"},
@@ -2409,13 +2411,13 @@ text-helpers = ["chardet (>=5.1.0,<6.0.0)"]
 
 [[package]]
 name = "langchain-serve"
-version = "0.0.38"
+version = "0.0.40"
 description = "Langchain Serve - serve your langchain apps on Jina AI Cloud."
 category = "main"
 optional = true
 python-versions = "*"
 files = [
-    {file = "langchain-serve-0.0.38.tar.gz", hash = "sha256:649b8e26eebe6b33960c081b388fb7118acbfdc00f97dd935a580ab88aca53d6"},
+    {file = "langchain-serve-0.0.40.tar.gz", hash = "sha256:c60b173fcf0b682fbb70d34e8f485ce168e2229f55cb5c4ffbc26a5206af1c06"},
 ]
 
 [package.dependencies]

pyproject.toml

@@ -49,7 +49,7 @@ psycopg2-binary = "^2.9.6"
 pyarrow = "^11.0.0"
 tiktoken = "^0.3.3"
 wikipedia = "^1.4.0"
-langchain-serve = { version = "^0.0.38", optional = true }
+langchain-serve = { version = ">0.0.39", optional = true }
 qdrant-client = "^1.2.0"
 websockets = "^11.0.3"
 weaviate-client = "^3.19.2"

src/backend/langflow/api/validate.py

@@ -9,7 +9,7 @@ from langflow.api.base import (
     PromptValidationResponse,
     validate_prompt,
 )
-from langflow.graph.nodes import VectorStoreNode
+from langflow.graph.node.types import VectorStoreNode
 from langflow.interface.run import build_graph
 from langflow.utils.logger import logger
 from langflow.utils.validate import validate_code

src/backend/langflow/graph/__init__.py

@@ -1,4 +1,35 @@
-from langflow.graph.base import Edge, Node
-from langflow.graph.graph import Graph
+from langflow.graph.edge.base import Edge
+from langflow.graph.graph.base import Graph
+from langflow.graph.node.base import Node
+from langflow.graph.node.types import (
+    AgentNode,
+    ChainNode,
+    DocumentLoaderNode,
+    EmbeddingNode,
+    LLMNode,
+    MemoryNode,
+    PromptNode,
+    TextSplitterNode,
+    ToolNode,
+    ToolkitNode,
+    VectorStoreNode,
+    WrapperNode,
+)
 
-__all__ = ["Graph", "Node", "Edge"]
+__all__ = [
+    "Graph",
+    "Node",
+    "Edge",
+    "AgentNode",
+    "ChainNode",
+    "DocumentLoaderNode",
+    "EmbeddingNode",
+    "LLMNode",
+    "MemoryNode",
+    "PromptNode",
+    "TextSplitterNode",
+    "ToolNode",
+    "ToolkitNode",
+    "VectorStoreNode",
+    "WrapperNode",
+]

src/backend/langflow/graph/edge/base.py

@@ -0,0 +1,52 @@
+from langflow.utils.logger import logger
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langflow.graph.node.base import Node
+
+
+class Edge:
+    def __init__(self, source: "Node", target: "Node"):
+        self.source: "Node" = source
+        self.target: "Node" = target
+        self.validate_edge()
+
+    def validate_edge(self) -> None:
+        # Validate that the outputs of the source node are valid inputs
+        # for the target node
+        self.source_types = self.source.output
+        self.target_reqs = self.target.required_inputs + self.target.optional_inputs
+        # Both lists contain strings and sometimes a string contains the value we are
+        # looking for e.g. comgin_out=["Chain"] and target_reqs=["LLMChain"]
+        # so we need to check if any of the strings in source_types is in target_reqs
+        self.valid = any(
+            output in target_req
+            for output in self.source_types
+            for target_req in self.target_reqs
+        )
+        # Get what type of input the target node is expecting
+
+        self.matched_type = next(
+            (
+                output
+                for output in self.source_types
+                for target_req in self.target_reqs
+                if output in target_req
+            ),
+            None,
+        )
+        no_matched_type = self.matched_type is None
+        if no_matched_type:
+            logger.debug(self.source_types)
+            logger.debug(self.target_reqs)
+        if no_matched_type:
+            raise ValueError(
+                f"Edge between {self.source.node_type} and {self.target.node_type} "
+                f"has no matched type"
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"Edge(source={self.source.id}, target={self.target.id}, valid={self.valid}"
+            f", matched_type={self.matched_type})"
+        )

src/backend/langflow/graph/graph/base.py

@@ -0,0 +1,149 @@
+from typing import Dict, List, Type, Union
+
+from langflow.graph.edge.base import Edge
+from langflow.graph.graph.constants import NODE_TYPE_MAP
+from langflow.graph.node.base import Node
+from langflow.graph.node.types import (
+    FileToolNode,
+    LLMNode,
+    ToolkitNode,
+)
+from langflow.interface.tools.constants import FILE_TOOLS
+from langflow.utils import payload
+
+
+class Graph:
+    """A class representing a graph of nodes and edges."""
+
+    def __init__(
+        self,
+        nodes: List[Dict[str, Union[str, Dict[str, Union[str, List[str]]]]]],
+        edges: List[Dict[str, str]],
+    ) -> None:
+        self._nodes = nodes
+        self._edges = edges
+        self._build_graph()
+
+    def _build_graph(self) -> None:
+        """Builds the graph from the nodes and edges."""
+        self.nodes = self._build_nodes()
+        self.edges = self._build_edges()
+        for edge in self.edges:
+            edge.source.add_edge(edge)
+            edge.target.add_edge(edge)
+
+        # This is a hack to make sure that the LLM node is sent to
+        # the toolkit node
+        self._build_node_params()
+        # remove invalid nodes
+        self._remove_invalid_nodes()
+
+    def _build_node_params(self) -> None:
+        """Identifies and handles the LLM node within the graph."""
+        llm_node = None
+        for node in self.nodes:
+            node._build_params()
+            if isinstance(node, LLMNode):
+                llm_node = node
+
+        if llm_node:
+            for node in self.nodes:
+                if isinstance(node, ToolkitNode):
+                    node.params["llm"] = llm_node
+
+    def _remove_invalid_nodes(self) -> None:
+        """Removes invalid nodes from the graph."""
+        self.nodes = [
+            node
+            for node in self.nodes
+            if self._validate_node(node)
+            or (len(self.nodes) == 1 and len(self.edges) == 0)
+        ]
+
+    def _validate_node(self, node: Node) -> bool:
+        """Validates a node."""
+        # All nodes that do not have edges are invalid
+        return len(node.edges) > 0
+
+    def get_node(self, node_id: str) -> Union[None, Node]:
+        """Returns a node by id."""
+        return next((node for node in self.nodes if node.id == node_id), None)
+
+    def get_nodes_with_target(self, node: Node) -> List[Node]:
+        """Returns the nodes connected to a node."""
+        connected_nodes: List[Node] = [
+            edge.source for edge in self.edges if edge.target == node
+        ]
+        return connected_nodes
+
+    def build(self) -> List[Node]:
+        """Builds the graph."""
+        # Get root node
+        root_node = payload.get_root_node(self)
+        if root_node is None:
+            raise ValueError("No root node found")
+        return root_node.build()
+
+    def get_node_neighbors(self, node: Node) -> Dict[Node, int]:
+        """Returns the neighbors of a node."""
+        neighbors: Dict[Node, int] = {}
+        for edge in self.edges:
+            if edge.source == node:
+                neighbor = edge.target
+                if neighbor not in neighbors:
+                    neighbors[neighbor] = 0
+                neighbors[neighbor] += 1
+            elif edge.target == node:
+                neighbor = edge.source
+                if neighbor not in neighbors:
+                    neighbors[neighbor] = 0
+                neighbors[neighbor] += 1
+        return neighbors
+
+    def _build_edges(self) -> List[Edge]:
+        """Builds the edges of the graph."""
+        # Edge takes two nodes as arguments, so we need to build the nodes first
+        # and then build the edges
+        # if we can't find a node, we raise an error
+
+        edges: List[Edge] = []
+        for edge in self._edges:
+            source = self.get_node(edge["source"])
+            target = self.get_node(edge["target"])
+            if source is None:
+                raise ValueError(f"Source node {edge['source']} not found")
+            if target is None:
+                raise ValueError(f"Target node {edge['target']} not found")
+            edges.append(Edge(source, target))
+        return edges
+
+    def _get_node_class(self, node_type: str, node_lc_type: str) -> Type[Node]:
+        """Returns the node class based on the node type."""
+        if node_type in FILE_TOOLS:
+            return FileToolNode
+        if node_type in NODE_TYPE_MAP:
+            return NODE_TYPE_MAP[node_type]
+        return NODE_TYPE_MAP[node_lc_type] if node_lc_type in NODE_TYPE_MAP else Node
+
+    def _build_nodes(self) -> List[Node]:
+        """Builds the nodes of the graph."""
+        nodes: List[Node] = []
+        for node in self._nodes:
+            node_data = node["data"]
+            node_type: str = node_data["type"]  # type: ignore
+            node_lc_type: str = node_data["node"]["template"]["_type"]  # type: ignore
+
+            NodeClass = self._get_node_class(node_type, node_lc_type)
+            nodes.append(NodeClass(node))
+
+        return nodes
+
+    def get_children_by_node_type(self, node: Node, node_type: str) -> List[Node]:
+        """Returns the children of a node based on the node type."""
+        children = []
+        node_types = [node.data["type"]]
+        if "node" in node.data:
+            node_types += node.data["node"]["base_classes"]
+        if node_type in node_types:
+            children.append(node)
+        return children

src/backend/langflow/graph/graph/constants.py

@@ -0,0 +1,49 @@
+from langflow.graph.node.base import Node
+from langflow.graph.node.types import (
+    AgentNode,
+    ChainNode,
+    DocumentLoaderNode,
+    EmbeddingNode,
+    LLMNode,
+    MemoryNode,
+    PromptNode,
+    TextSplitterNode,
+    ToolNode,
+    ToolkitNode,
+    VectorStoreNode,
+    WrapperNode,
+)
+from langflow.interface.agents.base import agent_creator
+from langflow.interface.chains.base import chain_creator
+from langflow.interface.document_loaders.base import documentloader_creator
+from langflow.interface.embeddings.base import embedding_creator
+from langflow.interface.llms.base import llm_creator
+from langflow.interface.memories.base import memory_creator
+from langflow.interface.prompts.base import prompt_creator
+from langflow.interface.text_splitters.base import textsplitter_creator
+from langflow.interface.toolkits.base import toolkits_creator
+from langflow.interface.tools.base import tool_creator
+from langflow.interface.vector_store.base import vectorstore_creator
+from langflow.interface.wrappers.base import wrapper_creator
+
+
+from typing import Dict, Type
+
+
+DIRECT_TYPES = ["str", "bool", "code", "int", "float", "Any", "prompt"]
+
+
+NODE_TYPE_MAP: Dict[str, Type[Node]] = {
+    **{t: PromptNode for t in prompt_creator.to_list()},
+    **{t: AgentNode for t in agent_creator.to_list()},
+    **{t: ChainNode for t in chain_creator.to_list()},
+    **{t: ToolNode for t in tool_creator.to_list()},
+    **{t: ToolkitNode for t in toolkits_creator.to_list()},
+    **{t: WrapperNode for t in wrapper_creator.to_list()},
+    **{t: LLMNode for t in llm_creator.to_list()},
+    **{t: MemoryNode for t in memory_creator.to_list()},
+    **{t: EmbeddingNode for t in embedding_creator.to_list()},
+    **{t: VectorStoreNode for t in vectorstore_creator.to_list()},
+    **{t: DocumentLoaderNode for t in documentloader_creator.to_list()},
+    **{t: TextSplitterNode for t in textsplitter_creator.to_list()},
+}

src/backend/langflow/graph/node/base.py

@@ -0,0 +1,229 @@
+from langflow.cache import base as cache_utils
+from langflow.graph.node.constants import DIRECT_TYPES
+from langflow.interface import loading
+from langflow.interface.listing import ALL_TYPES_DICT
+from langflow.utils.logger import logger
+from langflow.utils.util import sync_to_async
+
+
+import contextlib
+import inspect
+import types
+import warnings
+from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langflow.graph.edge.base import Edge
+
+
+class Node:
+    def __init__(self, data: Dict, base_type: Optional[str] = None) -> None:
+        self.id: str = data["id"]
+        self._data = data
+        self.edges: List["Edge"] = []
+        self.base_type: Optional[str] = base_type
+        self._parse_data()
+        self._built_object = None
+        self._built = False
+
+    def _parse_data(self) -> None:
+        self.data = self._data["data"]
+        self.output = self.data["node"]["base_classes"]
+        template_dicts = {
+            key: value
+            for key, value in self.data["node"]["template"].items()
+            if isinstance(value, dict)
+        }
+
+        self.required_inputs = [
+            template_dicts[key]["type"]
+            for key, value in template_dicts.items()
+            if value["required"]
+        ]
+        self.optional_inputs = [
+            template_dicts[key]["type"]
+            for key, value in template_dicts.items()
+            if not value["required"]
+        ]
+
+        template_dict = self.data["node"]["template"]
+        self.node_type = (
+            self.data["type"] if "Tool" not in self.output else template_dict["_type"]
+        )
+        if self.base_type is None:
+            for base_type, value in ALL_TYPES_DICT.items():
+                if self.node_type in value:
+                    self.base_type = base_type
+                    break
+
+    def _build_params(self):
+        # Some params are required, some are optional
+        # but most importantly, some params are python base classes
+        # like str and others are LangChain objects like LLMChain, BasePromptTemplate
+        # so we need to be able to distinguish between the two
+
+        # The dicts with "type" == "str" are the ones that are python base classes
+        # and most likely have a "value" key
+
+        # So for each key besides "_type" in the template dict, we have a dict
+        # with a "type" key. If the type is not "str", then we need to get the
+        # edge that connects to that node and get the Node with the required data
+        # and use that as the value for the param
+        # If the type is "str", then we need to get the value of the "value" key
+        # and use that as the value for the param
+        template_dict = {
+            key: value
+            for key, value in self.data["node"]["template"].items()
+            if isinstance(value, dict)
+        }
+        params = {}
+        for key, value in template_dict.items():
+            if key == "_type":
+                continue
+            # If the type is not transformable to a python base class
+            # then we need to get the edge that connects to this node
+            if value.get("type") == "file":
+                # Load the type in value.get('suffixes') using
+                # what is inside value.get('content')
+                # value.get('value') is the file name
+                file_name = value.get("value")
+                content = value.get("content")
+                type_to_load = value.get("suffixes")
+                file_path = cache_utils.save_binary_file(
+                    content=content, file_name=file_name, accepted_types=type_to_load
+                )
+
+                params[key] = file_path
+
+            elif value.get("type") not in DIRECT_TYPES:
+                # Get the edge that connects to this node
+                edges = [
+                    edge
+                    for edge in self.edges
+                    if edge.target == self and edge.matched_type in value["type"]
+                ]
+
+                # Get the output of the node that the edge connects to
+                # if the value['list'] is True, then there will be more
+                # than one time setting to params[key]
+                # so we need to append to a list if it exists
+                # or create a new list if it doesn't
+
+                if value["required"] and not edges:
+                    # If a required parameter is not found, raise an error
+                    raise ValueError(
+                        f"Required input {key} for module {self.node_type} not found"
+                    )
+                elif value["list"]:
+                    # If this is a list parameter, append all sources to a list
+                    params[key] = [edge.source for edge in edges]
+                elif edges:
+                    # If a single parameter is found, use its source
+                    params[key] = edges[0].source
+
+            elif value["required"] or value.get("value"):
+                # If value does not have value this still passes
+                # but then gives a keyError
+                # so we need to check if value has value
+                new_value = value.get("value")
+                if new_value is None:
+                    warnings.warn(f"Value for {key} in {self.node_type} is None. ")
+                if value.get("type") == "int":
+                    with contextlib.suppress(TypeError, ValueError):
+                        new_value = int(new_value)  # type: ignore
+                params[key] = new_value
+
+        # Add _type to params
+        self.params = params
+
+    def _build(self):
+        # The params dict is used to build the module
+        # it contains values and keys that point to nodes which
+        # have their own params dict
+        # When build is called, we iterate through the params dict
+        # and if the value is a node, we call build on that node
+        # and use the output of that build as the value for the param
+        # if the value is not a node, then we use the value as the param
+        # and continue
+        # Another aspect is that the node_type is the class that we need to import
+        # and instantiate with these built params
+        logger.debug(f"Building {self.node_type}")
+        # Build each node in the params dict
+        for key, value in self.params.copy().items():
+            # Check if Node or list of Nodes and not self
+            # to avoid recursion
+            if isinstance(value, Node):
+                if value == self:
+                    del self.params[key]
+                    continue
+                result = value.build()
+                # If the key is "func", then we need to use the run method
+                if key == "func":
+                    if not isinstance(result, types.FunctionType):
+                        # func can be
+                        # PythonFunction(code='\ndef upper_case(text: str) -> str:\n    return text.upper()\n')
+                        # so we need to check if there is an attribute called run
+                        if hasattr(result, "run"):
+                            result = result.run  # type: ignore
+                        elif hasattr(result, "get_function"):
+                            result = result.get_function()  # type: ignore
+                    elif inspect.iscoroutinefunction(result):
+                        self.params["coroutine"] = result
+                    else:
+                        # turn result which is a function into a coroutine
+                        # so that it can be awaited
+                        self.params["coroutine"] = sync_to_async(result)
+
+                self.params[key] = result
+            elif isinstance(value, list) and all(
+                isinstance(node, Node) for node in value
+            ):
+                self.params[key] = []
+                for node in value:
+                    built = node.build()
+                    if isinstance(built, list):
+                        self.params[key].extend(built)
+                    else:
+                        self.params[key].append(built)
+
+        # Get the class from LANGCHAIN_TYPES_DICT
+        # and instantiate it with the params
+        # and return the instance
+
+        try:
+            self._built_object = loading.instantiate_class(
+                node_type=self.node_type,
+                base_type=self.base_type,
+                params=self.params,
+            )
+        except Exception as exc:
+            raise ValueError(
+                f"Error building node {self.node_type}: {str(exc)}"
+            ) from exc
+
+        if self._built_object is None:
+            raise ValueError(f"Node type {self.node_type} not found")
+
+        self._built = True
+
+    def build(self, force: bool = False) -> Any:
+        if not self._built or force:
+            self._build()
+
+        return self._built_object
+
+    def add_edge(self, edge: "Edge") -> None:
+        self.edges.append(edge)
+
+    def __repr__(self) -> str:
+        return f"Node(id={self.id}, data={self.data})"
+
+    def __eq__(self, __o: object) -> bool:
+        return self.id == __o.id if isinstance(__o, Node) else False
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    def _built_object_repr(self):
+        return repr(self._built_object)

src/backend/langflow/graph/node/constants.py

@@ -0,0 +1 @@
+DIRECT_TYPES = ["str", "bool", "code", "int", "float", "Any", "prompt"]

src/backend/langflow/graph/node/types.py

@@ -0,0 +1,193 @@
+from typing import Any, Dict, List, Optional, Union
+
+from langflow.graph.node.base import Node
+from langflow.graph.utils import extract_input_variables_from_prompt
+
+
+class AgentNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="agents")
+
+        self.tools: List[ToolNode] = []
+        self.chains: List[ChainNode] = []
+
+    def _set_tools_and_chains(self) -> None:
+        for edge in self.edges:
+            source_node = edge.source
+            if isinstance(source_node, ToolNode):
+                self.tools.append(source_node)
+            elif isinstance(source_node, ChainNode):
+                self.chains.append(source_node)
+
+    def build(self, force: bool = False) -> Any:
+        if not self._built or force:
+            self._set_tools_and_chains()
+            # First, build the tools
+            for tool_node in self.tools:
+                tool_node.build()
+
+            # Next, build the chains and the rest
+            for chain_node in self.chains:
+                chain_node.build(tools=self.tools)
+
+            self._build()
+
+        #! Cannot deepcopy VectorStore, VectorStoreRouter, or SQL agents
+        if self.node_type in ["VectorStoreAgent", "VectorStoreRouterAgent", "SQLAgent"]:
+            return self._built_object
+        return self._built_object
+
+
+class ToolNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="tools")
+
+
+class PromptNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="prompts")
+
+    def build(
+        self,
+        force: bool = False,
+        tools: Optional[Union[List[Node], List[ToolNode]]] = None,
+    ) -> Any:
+        if not self._built or force:
+            if (
+                "input_variables" not in self.params
+                or self.params["input_variables"] is None
+            ):
+                self.params["input_variables"] = []
+            # Check if it is a ZeroShotPrompt and needs a tool
+            if "ShotPrompt" in self.node_type:
+                tools = (
+                    [tool_node.build() for tool_node in tools]
+                    if tools is not None
+                    else []
+                )
+                self.params["tools"] = tools
+                prompt_params = [
+                    key
+                    for key, value in self.params.items()
+                    if isinstance(value, str) and key != "format_instructions"
+                ]
+            else:
+                prompt_params = ["template"]
+            for param in prompt_params:
+                prompt_text = self.params[param]
+                variables = extract_input_variables_from_prompt(prompt_text)
+                self.params["input_variables"].extend(variables)
+            self.params["input_variables"] = list(set(self.params["input_variables"]))
+
+            self._build()
+        return self._built_object
+
+
+class ChainNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="chains")
+
+    def build(
+        self,
+        force: bool = False,
+        tools: Optional[Union[List[Node], List[ToolNode]]] = None,
+    ) -> Any:
+        if not self._built or force:
+            # Check if the chain requires a PromptNode
+            for key, value in self.params.items():
+                if isinstance(value, PromptNode):
+                    # Build the PromptNode, passing the tools if available
+                    self.params[key] = value.build(tools=tools, force=force)
+
+            self._build()
+
+        #! Cannot deepcopy SQLDatabaseChain
+        if self.node_type in ["SQLDatabaseChain"]:
+            return self._built_object
+        return self._built_object
+
+
+class LLMNode(Node):
+    built_node_type = None
+    class_built_object = None
+
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="llms")
+
+    def build(self, force: bool = False) -> Any:
+        # LLM is different because some models might take up too much memory
+        # or time to load. So we only load them when we need them.ß
+        if self.node_type == self.built_node_type:
+            return self.class_built_object
+        if not self._built or force:
+            self._build()
+            self.built_node_type = self.node_type
+            self.class_built_object = self._built_object
+        # Avoid deepcopying the LLM
+        # that are loaded from a file
+        return self._built_object
+
+
+class ToolkitNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="toolkits")
+
+
+class FileToolNode(ToolNode):
+    def __init__(self, data: Dict):
+        super().__init__(data)
+
+
+class WrapperNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="wrappers")
+
+    def build(self, force: bool = False) -> Any:
+        if not self._built or force:
+            if "headers" in self.params:
+                self.params["headers"] = eval(self.params["headers"])
+            self._build()
+        return self._built_object
+
+
+class DocumentLoaderNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="documentloaders")
+
+    def _built_object_repr(self):
+        # This built_object is a list of documents. Maybe we should
+        # show how many documents are in the list?
+        if self._built_object:
+            return f"""{self.node_type}({len(self._built_object)} documents)
+            Documents: {self._built_object[:3]}..."""
+        return f"{self.node_type}()"
+
+
+class EmbeddingNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="embeddings")
+
+
+class VectorStoreNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="vectorstores")
+
+    def _built_object_repr(self):
+        return "Vector stores can take time to build. It will build on the first query."
+
+
+class MemoryNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="memory")
+
+
+class TextSplitterNode(Node):
+    def __init__(self, data: Dict):
+        super().__init__(data, base_type="textsplitters")
+
+    def _built_object_repr(self):
+        # This built_object is a list of documents. Maybe we should
+        # show how many documents are in the list?
+        if self._built_object:
+            return f"""{self.node_type}({len(self._built_object)} documents)\nDocuments: {self._built_object[:3]}..."""
+        return f"{self.node_type}()"

src/backend/langflow/interface/loading.py

@@ -12,6 +12,7 @@ from langchain.agents.load_tools import (
     _LLM_TOOLS,
 )
 from langchain.agents.loading import load_agent_from_config
+from langflow.graph import Graph
 from langchain.agents.tools import Tool
 from langchain.base_language import BaseLanguageModel
 from langchain.callbacks.base import BaseCallbackManager
@@ -162,7 +163,6 @@ def instantiate_utility(node_type, class_object, params):
 def load_flow_from_json(path: str, build=True):
     """Load flow from json file"""
     # This is done to avoid circular imports
-    from langflow.graph import Graph
 
     with open(path, "r", encoding="utf-8") as f:
         flow_graph = json.load(f)

src/backend/langflow/interface/run.py

@@ -6,7 +6,7 @@ from langchain.schema import AgentAction
 
 from langflow.api.callback import AsyncStreamingLLMCallbackHandler, StreamingLLMCallbackHandler  # type: ignore
 from langflow.cache.base import compute_dict_hash, load_cache, memoize_dict
-from langflow.graph.graph import Graph
+from langflow.graph import Graph
 from langflow.utils.logger import logger
 
 

src/frontend/src/index.css

@@ -15,3 +15,9 @@ code {
 	font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New",
 		monospace;
 }
+
+/* The style below sets the cursor property of the element with the class .react-flow__pane to the default cursor.
+The cursor: default; property value restores the browser's default cursor style for the targeted element. By applying this style, the element will no longer have a custom cursor appearance such as "grab" or any other custom cursor defined elsewhere in the application. Instead, it will revert to the default cursor style determined by the browser, typically an arrow-shaped cursor. */
+.react-flow__pane {
+  cursor: default;
+}

src/frontend/src/modals/chatModal/chatMessage/index.tsx

@@ -16,9 +16,11 @@ import Convert from "ansi-to-html";
 export default function ChatMessage({
   chat,
   lockChat,
+  lastMessage,
 }: {
   chat: ChatMessageType;
   lockChat: boolean;
+  lastMessage: boolean;
 }) {
   const convert = new Convert({ newline: true });
   const [message, setMessage] = useState("");
@@ -48,7 +50,7 @@ export default function ChatMessage({
                 "absolute transition-opacity duration-500 scale-150 " +
                 (lockChat ? "opacity-100" : "opacity-0")
               }
-              src={AiIcon}
+              src={lastMessage ? AiIcon : AiIconStill}
             />
             <img
               className={

src/frontend/src/modals/chatModal/index.tsx

@@ -290,7 +290,9 @@ export default function ChatModal({
         errors.concat(
           template[t].required &&
             template[t].show &&
-            (!template[t].value || template[t].value === "") &&
+            (template[t].value === undefined ||
+              template[t].value === null ||
+              template[t].value === "") &&
             !reactFlowInstance
               .getEdges()
               .some(
@@ -414,7 +416,12 @@ export default function ChatModal({
                 >
                   {chatHistory.length > 0 ? (
                     chatHistory.map((c, i) => (
-                      <ChatMessage lockChat={lockChat} chat={c} key={i} />
+                      <ChatMessage
+                        lockChat={lockChat}
+                        chat={c}
+                        lastMessage={chatHistory.length - 1 == i ? true : false}
+                        key={i}
+                      />
                     ))
                   ) : (
                     <div className="flex flex-col h-full text-center justify-center w-full items-center align-middle">

src/frontend/src/pages/FlowPage/components/DisclosureComponent/index.tsx

@@ -5,6 +5,7 @@ import { DisclosureComponentType } from "../../../../types/components";
 export default function DisclosureComponent({
   button: { title, Icon, buttons = [] },
   children,
+  openDisc,
 }: DisclosureComponentType) {
   return (
     <Disclosure as="div" key={title}>
@@ -27,14 +28,14 @@ export default function DisclosureComponent({
                 <div>
                   <ChevronRightIcon
                     className={`${
-                      open ? "rotate-90 transform" : ""
+                      open || openDisc ? "rotate-90 transform" : ""
                     } h-4 w-4 text-gray-800 dark:text-white`}
                   />
                 </div>
               </div>
             </Disclosure.Button>
           </div>
-          <Disclosure.Panel as="div" className="-mt-px">
+          <Disclosure.Panel as="div" className="-mt-px" static={openDisc}>
             {children}
           </Disclosure.Panel>
         </>