Merge branch 'dev' into new_icons

src/backend/langflow/api/chat_manager.py

@@ -29,10 +29,10 @@ class ChatHistory(Subject):
         if not isinstance(message, FileResponse):
             self.notify()
 
-    def get_history(self, client_id: str, filter=True) -> List[ChatMessage]:
+    def get_history(self, client_id: str, filter_messages=True) -> List[ChatMessage]:
         """Get the chat history for a client."""
         if history := self.history.get(client_id, []):
-            if filter:
+            if filter_messages:
                 return [msg for msg in history if msg.type not in ["start", "stream"]]
             return history
         else:
@@ -54,7 +54,9 @@ class ChatManager:
         """Send the last chat message to the client."""
         client_id = self.cache_manager.current_client_id
         if client_id in self.active_connections:
-            chat_response = self.chat_history.get_history(client_id, filter=False)[-1]
+            chat_response = self.chat_history.get_history(
+                client_id, filter_messages=False
+            )[-1]
             if chat_response.is_bot:
                 # Process FileResponse
                 if isinstance(chat_response, FileResponse):
@@ -128,7 +130,7 @@ class ChatManager:
             raise e
         # Send a response back to the frontend, if needed
         intermediate_steps = intermediate_steps or ""
-        history = self.chat_history.get_history(client_id, filter=False)
+        history = self.chat_history.get_history(client_id, filter_messages=False)
         file_responses = []
         if history:
             # Iterate backwards through the history

src/backend/langflow/cache/base.py

@@ -120,7 +120,7 @@ def save_binary_file(content: str, file_name: str, accepted_types: list[str]) ->
 
     # Get the destination folder
     cache_path = Path(tempfile.gettempdir()) / PREFIX
-    if content is None:
+    if not content:
         raise ValueError("Please, reload the file in the loader.")
     data = content.split(",")[1]
     decoded_bytes = base64.b64decode(data)

src/backend/langflow/config.yaml

@@ -42,8 +42,11 @@ documentloaders:
   - IMSDbLoader
   - GitbookLoader
   - ReadTheDocsLoader
+  - NotionDirectoryLoader
 embeddings:
   - OpenAIEmbeddings
+  - HuggingFaceEmbeddings
+
 llms:
   - OpenAI
   # - AzureOpenAI
@@ -60,6 +63,9 @@ prompts:
   - ZeroShotPrompt
 textsplitters:
   - CharacterTextSplitter
+  - RecursiveCharacterTextSplitter
+  - LatexTextSplitter
+  - PythonCodeTextSplitter
 toolkits:
   - OpenAPIToolkit
   - JsonToolkit

src/backend/langflow/custom/customs.py

@@ -1,24 +1,27 @@
-from langflow.template import nodes
+from langflow.template import frontend_node
 
 # These should always be instantiated
 CUSTOM_NODES = {
-    "prompts": {"ZeroShotPrompt": nodes.ZeroShotPromptNode()},
-    "tools": {"PythonFunction": nodes.PythonFunctionNode(), "Tool": nodes.ToolNode()},
+    "prompts": {"ZeroShotPrompt": frontend_node.prompts.ZeroShotPromptNode()},
+    "tools": {
+        "PythonFunction": frontend_node.tools.PythonFunctionNode(),
+        "Tool": frontend_node.tools.ToolNode(),
+    },
     "agents": {
-        "JsonAgent": nodes.JsonAgentNode(),
-        "CSVAgent": nodes.CSVAgentNode(),
-        "initialize_agent": nodes.InitializeAgentNode(),
-        "VectorStoreAgent": nodes.VectorStoreAgentNode(),
-        "VectorStoreRouterAgent": nodes.VectorStoreRouterAgentNode(),
-        "SQLAgent": nodes.SQLAgentNode(),
+        "JsonAgent": frontend_node.agents.JsonAgentNode(),
+        "CSVAgent": frontend_node.agents.CSVAgentNode(),
+        "initialize_agent": frontend_node.agents.InitializeAgentNode(),
+        "VectorStoreAgent": frontend_node.agents.VectorStoreAgentNode(),
+        "VectorStoreRouterAgent": frontend_node.agents.VectorStoreRouterAgentNode(),
+        "SQLAgent": frontend_node.agents.SQLAgentNode(),
     },
     "utilities": {
-        "SQLDatabase": nodes.SQLDatabaseNode(),
+        "SQLDatabase": frontend_node.agents.SQLDatabaseNode(),
     },
     "chains": {
-        "SeriesCharacterChain": nodes.SeriesCharacterChainNode(),
-        "TimeTravelGuideChain": nodes.TimeTravelGuideChainNode(),
-        "MidJourneyPromptChain": nodes.MidJourneyPromptChainNode(),
+        "SeriesCharacterChain": frontend_node.chains.SeriesCharacterChainNode(),
+        "TimeTravelGuideChain": frontend_node.chains.TimeTravelGuideChainNode(),
+        "MidJourneyPromptChain": frontend_node.chains.MidJourneyPromptChainNode(),
     },
 }
 

src/backend/langflow/interface/agents/custom.py

@@ -28,7 +28,6 @@ from langchain.agents.agent_toolkits.vectorstore.prompt import (
     ROUTER_PREFIX as VECTORSTORE_ROUTER_PREFIX,
 )
 from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
-from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS as SQL_FORMAT_INSTRUCTIONS
 from langchain.base_language import BaseLanguageModel
 from langchain.memory.chat_memory import BaseChatMemory
 from langchain.sql_database import SQLDatabase
@@ -220,7 +219,7 @@ class SQLAgent(CustomAgentExecutor):
             QuerySQLDataBaseTool(db=db),  # type: ignore
             InfoSQLDatabaseTool(db=db),  # type: ignore
             ListSQLDatabaseTool(db=db),  # type: ignore
-            QueryCheckerTool(db=db, llm_chain=llmchain),  # type: ignore
+            QueryCheckerTool(db=db, llm_chain=llmchain, llm=llm),  # type: ignore
         ]
 
         prefix = SQL_PREFIX.format(dialect=toolkit.dialect, top_k=10)
@@ -228,7 +227,7 @@ class SQLAgent(CustomAgentExecutor):
             tools=tools,  # type: ignore
             prefix=prefix,
             suffix=SQL_SUFFIX,
-            format_instructions=SQL_FORMAT_INSTRUCTIONS,
+            format_instructions=FORMAT_INSTRUCTIONS,
         )
         llm_chain = LLMChain(
             llm=llm,

src/backend/langflow/interface/base.py

@@ -3,7 +3,9 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel
 
-from langflow.template.base import FrontendNode, Template, TemplateField
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.template.base import Template
 from langflow.utils.logger import logger
 
 # Assuming necessary imports for Field, Template, and FrontendNode classes

src/backend/langflow/interface/chains/base.py

@@ -4,7 +4,7 @@ from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import chain_type_to_cls_dict
 from langflow.settings import settings
-from langflow.template.nodes import ChainFrontendNode
+from langflow.template.frontend_node.chains import ChainFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/custom_lists.py

@@ -9,11 +9,9 @@ from langchain import (
     memory,
     requests,
     text_splitter,
-    utilities,
 )
 from langchain.agents import agent_toolkits
 from langchain.chat_models import ChatOpenAI
-from langchain.sql_database import SQLDatabase
 
 from langflow.interface.importing.utils import import_class
 
@@ -72,9 +70,3 @@ documentloaders_type_to_cls_dict: dict[str, Any] = {
 textsplitter_type_to_cls_dict: dict[str, Any] = dict(
     inspect.getmembers(text_splitter, inspect.isclass)
 )
-
-## Utilities
-utility_type_to_cls_dict: dict[str, Any] = dict(
-    inspect.getmembers(utilities, inspect.isclass)
-)
-utility_type_to_cls_dict["SQLDatabase"] = SQLDatabase

src/backend/langflow/interface/document_loaders/base.py

@@ -118,7 +118,7 @@ class DocumentLoaderCreator(LangChainTypeCreator):
                     "value": "",
                     "display_name": "Web Page",
                 }
-            elif name in {"ReadTheDocsLoader"}:
+            elif name in {"ReadTheDocsLoader", "NotionDirectoryLoader"}:
                 signature["template"]["path"] = {
                     "type": "str",
                     "required": True,

src/backend/langflow/interface/embeddings/base.py

@@ -3,8 +3,8 @@ from typing import Dict, List, Optional, Type
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import embedding_type_to_cls_dict
 from langflow.settings import settings
-from langflow.template.base import FrontendNode
-from langflow.template.nodes import EmbeddingFrontendNode
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.frontend_node.embeddings import EmbeddingFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/importing/utils.py

@@ -71,9 +71,9 @@ def import_class(class_path: str) -> Any:
 
 
 def import_prompt(prompt: str) -> Type[PromptTemplate]:
+    """Import prompt from prompt name"""
     from langflow.interface.prompts.custom import CUSTOM_PROMPTS
 
-    """Import prompt from prompt name"""
     if prompt == "ZeroShotPrompt":
         return import_class("langchain.prompts.PromptTemplate")
     elif prompt in CUSTOM_PROMPTS:

src/backend/langflow/interface/llms/base.py

@@ -3,7 +3,7 @@ from typing import Dict, List, Optional, Type
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import llm_type_to_cls_dict
 from langflow.settings import settings
-from langflow.template.nodes import LLMFrontendNode
+from langflow.template.frontend_node.llms import LLMFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/loading.py

@@ -152,10 +152,10 @@ 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
 
-    """Load flow from json file"""
     with open(path, "r", encoding="utf-8") as f:
         flow_graph = json.load(f)
     data_graph = flow_graph["data"]

src/backend/langflow/interface/memories/base.py

@@ -3,8 +3,8 @@ from typing import Dict, List, Optional, Type
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import memory_type_to_cls_dict
 from langflow.settings import settings
-from langflow.template.base import FrontendNode
-from langflow.template.nodes import MemoryFrontendNode
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.frontend_node.memories import MemoryFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/prompts/base.py

@@ -6,7 +6,7 @@ from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
 from langflow.settings import settings
-from langflow.template.nodes import PromptFrontendNode
+from langflow.template.frontend_node.prompts import PromptFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/tools/base.py

@@ -16,7 +16,8 @@ from langflow.interface.tools.constants import (
 )
 from langflow.interface.tools.util import get_tool_params
 from langflow.settings import settings
-from langflow.template.base import Template, TemplateField
+from langflow.template.field.base import TemplateField
+from langflow.template.template.base import Template
 from langflow.utils import util
 from langflow.utils.util import build_template_from_class
 

src/backend/langflow/interface/utilities/base.py

@@ -1,9 +1,12 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Type
+
+from langchain import SQLDatabase, utilities
 
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
-from langflow.interface.custom_lists import utility_type_to_cls_dict
+from langflow.interface.importing.utils import import_class
 from langflow.settings import settings
+from langflow.template.frontend_node.utilities import UtilitiesFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
 
@@ -11,16 +14,39 @@ from langflow.utils.util import build_template_from_class
 class UtilityCreator(LangChainTypeCreator):
     type_name: str = "utilities"
 
+    @property
+    def frontend_node_class(self) -> Type[UtilitiesFrontendNode]:
+        return UtilitiesFrontendNode
+
     @property
     def type_to_loader_dict(self) -> Dict:
-        return utility_type_to_cls_dict
+        """
+        Returns a dictionary mapping utility names to their corresponding loader classes.
+        If the dictionary has not been created yet, it is created by importing all utility classes
+        from the langchain.chains module and filtering them according to the settings.utilities list.
+        """
+        if self.type_dict is None:
+            self.type_dict = {
+                utility_name: import_class(f"langchain.utilities.{utility_name}")
+                for utility_name in utilities.__all__
+            }
+            self.type_dict["SQLDatabase"] = SQLDatabase
+            # Filter according to settings.utilities
+            self.type_dict = {
+                name: utility
+                for name, utility in self.type_dict.items()
+                if name in settings.utilities or settings.dev
+            }
+
+        return self.type_dict
 
     def get_signature(self, name: str) -> Optional[Dict]:
         """Get the signature of a utility."""
         try:
-            if name in get_custom_nodes(self.type_name).keys():
-                return get_custom_nodes(self.type_name)[name]
-            return build_template_from_class(name, utility_type_to_cls_dict)
+            custom_nodes = get_custom_nodes(self.type_name)
+            if name in custom_nodes.keys():
+                return custom_nodes[name]
+            return build_template_from_class(name, self.type_to_loader_dict)
         except ValueError as exc:
             raise ValueError(f"Utility {name} not found") from exc
 
@@ -29,11 +55,7 @@ class UtilityCreator(LangChainTypeCreator):
             return None
 
     def to_list(self) -> List[str]:
-        return [
-            utility.__name__
-            for utility in self.type_to_loader_dict.values()
-            if utility.__name__ in settings.utilities or settings.dev
-        ]
+        return list(self.type_to_loader_dict.keys())
 
 
 utility_creator = UtilityCreator()

src/backend/langflow/interface/utils.py

@@ -44,7 +44,7 @@ def try_setting_streaming_options(langchain_object, websocket):
         langchain_object.llm_chain, "llm"
     ):
         llm = langchain_object.llm_chain.llm
-    if isinstance(llm, BaseLanguageModel):
-        llm.streaming = bool(hasattr(llm, "streaming"))
+    if isinstance(llm, BaseLanguageModel) and hasattr(llm, "streaming"):
+        llm.streaming = True
 
     return langchain_object

src/backend/langflow/interface/vector_store/base.py

@@ -5,7 +5,7 @@ from langchain import vectorstores
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
 from langflow.settings import settings
-from langflow.template.nodes import VectorStoreFrontendNode
+from langflow.template.frontend_node.vectorstores import VectorStoreFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_method
 

src/backend/langflow/template/base.py

@@ -1,255 +1 @@
-import re
-from abc import ABC
-from typing import Any, Callable, List, Optional, Union
 
-from pydantic import BaseModel
-
-from langflow.template.constants import FORCE_SHOW_FIELDS
-from langflow.utils import constants
-
-
-class TemplateFieldCreator(BaseModel, ABC):
-    field_type: str = "str"
-    required: bool = False
-    placeholder: str = ""
-    is_list: bool = False
-    show: bool = True
-    multiline: bool = False
-    value: Any = None
-    suffixes: list[str] = []
-    fileTypes: list[str] = []
-    file_types: list[str] = []
-    content: Union[str, None] = None
-    password: bool = False
-    options: list[str] = []
-    name: str = ""
-    display_name: Optional[str] = None
-    advanced: bool = False
-
-    def to_dict(self):
-        result = self.dict()
-        # Remove key if it is None
-        for key in list(result.keys()):
-            if result[key] is None or result[key] == []:
-                del result[key]
-        result["type"] = result.pop("field_type")
-        result["list"] = result.pop("is_list")
-
-        if result.get("file_types"):
-            result["fileTypes"] = result.pop("file_types")
-
-        if self.field_type == "file":
-            result["content"] = self.content
-        return result
-
-
-class TemplateField(TemplateFieldCreator):
-    pass
-
-
-class Template(BaseModel):
-    type_name: str
-    fields: list[TemplateField]
-
-    def process_fields(
-        self,
-        name: Optional[str] = None,
-        format_field_func: Union[Callable, None] = None,
-    ):
-        if format_field_func:
-            for field in self.fields:
-                format_field_func(field, name)
-
-    def to_dict(self, format_field_func=None):
-        self.process_fields(self.type_name, format_field_func)
-        result = {field.name: field.to_dict() for field in self.fields}
-        result["_type"] = self.type_name  # type: ignore
-        return result
-
-
-class FrontendNode(BaseModel):
-    template: Template
-    description: str
-    base_classes: List[str]
-    name: str = ""
-
-    def to_dict(self) -> dict:
-        return {
-            self.name: {
-                "template": self.template.to_dict(self.format_field),
-                "description": self.description,
-                "base_classes": self.base_classes,
-            }
-        }
-
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        """Formats a given field based on its attributes and value."""
-        SPECIAL_FIELD_HANDLERS = {
-            "allowed_tools": lambda field: "Tool",
-            "max_value_length": lambda field: "int",
-        }
-
-        key = field.name
-        value = field.to_dict()
-        _type = value["type"]
-
-        _type = FrontendNode.remove_optional(_type)
-        _type, is_list = FrontendNode.check_for_list_type(_type)
-        field.is_list = is_list or field.is_list
-        _type = FrontendNode.replace_mapping_with_dict(_type)
-        _type = FrontendNode.handle_union_type(_type)
-
-        field.field_type = FrontendNode.handle_special_field(
-            field, key, _type, SPECIAL_FIELD_HANDLERS
-        )
-        field.field_type = FrontendNode.handle_dict_type(field, _type)
-        field.show = FrontendNode.should_show_field(key, field.required)
-        field.password = FrontendNode.should_be_password(key, field.show)
-        field.multiline = FrontendNode.should_be_multiline(key)
-
-        FrontendNode.replace_default_value(field, value)
-        FrontendNode.handle_specific_field_values(field, key, name)
-        FrontendNode.handle_kwargs_field(field)
-        FrontendNode.handle_api_key_field(field, key)
-
-    @staticmethod
-    def remove_optional(_type: str) -> str:
-        """Removes 'Optional' wrapper from the type if present."""
-        return re.sub(r"Optional\[(.*)\]", r"\1", _type)
-
-    @staticmethod
-    def check_for_list_type(_type: str) -> tuple:
-        """Checks for list type and returns the modified type and a boolean indicating if it's a list."""
-        is_list = "List" in _type or "Sequence" in _type
-        if is_list:
-            _type = re.sub(r"(List|Sequence)\[(.*)\]", r"\2", _type)
-        return _type, is_list
-
-    @staticmethod
-    def replace_mapping_with_dict(_type: str) -> str:
-        """Replaces 'Mapping' with 'dict'."""
-        return _type.replace("Mapping", "dict")
-
-    @staticmethod
-    def handle_union_type(_type: str) -> str:
-        """Simplifies the 'Union' type to the first type in the Union."""
-        if "Union" in _type:
-            _type = _type.replace("Union[", "")[:-1]
-            _type = _type.split(",")[0]
-            _type = _type.replace("]", "").replace("[", "")
-        return _type
-
-    @staticmethod
-    def handle_special_field(
-        field, key: str, _type: str, SPECIAL_FIELD_HANDLERS
-    ) -> str:
-        """Handles special field by using the respective handler if present."""
-        handler = SPECIAL_FIELD_HANDLERS.get(key)
-        return handler(field) if handler else _type
-
-    @staticmethod
-    def handle_dict_type(field: TemplateField, _type: str) -> str:
-        """Handles 'dict' type by replacing it with 'code' or 'file' based on the field name."""
-        if "dict" in _type.lower():
-            if field.name == "dict_":
-                field.field_type = "file"
-                field.suffixes = [".json", ".yaml", ".yml"]
-                field.file_types = ["json", "yaml", "yml"]
-            else:
-                field.field_type = "code"
-        return _type
-
-    @staticmethod
-    def replace_default_value(field: TemplateField, value: dict) -> None:
-        """Replaces default value with actual value if 'default' is present in value."""
-        if "default" in value:
-            field.value = value["default"]
-
-    @staticmethod
-    def handle_specific_field_values(
-        field: TemplateField, key: str, name: Optional[str] = None
-    ) -> None:
-        """Handles specific field values for certain fields."""
-        if key == "headers":
-            field.value = """{'Authorization':
-            'Bearer <token>'}"""
-        if name == "OpenAI" and key == "model_name":
-            field.options = constants.OPENAI_MODELS
-            field.is_list = True
-        elif name == "ChatOpenAI" and key == "model_name":
-            field.options = constants.CHAT_OPENAI_MODELS
-            field.is_list = True
-        if "api_key" in key and "OpenAI" in str(name):
-            field.display_name = "OpenAI API Key"
-            field.required = False
-            if field.value is None:
-                field.value = ""
-
-    @staticmethod
-    def handle_kwargs_field(field: TemplateField) -> None:
-        """Handles kwargs field by setting certain attributes."""
-        if "kwargs" in field.name.lower():
-            field.advanced = True
-            field.required = False
-            field.show = False
-
-    @staticmethod
-    def handle_api_key_field(field: TemplateField, key: str) -> None:
-        """Handles api key field by setting certain attributes."""
-        if "api" in key.lower() and "key" in key.lower():
-            field.required = False
-            field.advanced = False
-
-    @staticmethod
-    def should_show_field(key: str, required: bool) -> bool:
-        """Determines whether the field should be shown."""
-        return (
-            (required and key not in ["input_variables"])
-            or key in FORCE_SHOW_FIELDS
-            or "api" in key
-            or ("key" in key and "input" not in key and "output" not in key)
-        )
-
-    @staticmethod
-    def should_be_password(key: str, show: bool) -> bool:
-        """Determines whether the field should be a password field."""
-        return (
-            any(text in key.lower() for text in {"password", "token", "api", "key"})
-            and show
-        )
-
-    @staticmethod
-    def should_be_multiline(key: str) -> bool:
-        """Determines whether the field should be multiline."""
-        return key in {
-            "suffix",
-            "prefix",
-            "template",
-            "examples",
-            "code",
-            "headers",
-            "description",
-        }
-
-    @staticmethod
-    def replace_dict_with_code_or_file(
-        field: TemplateField, _type: str, key: str
-    ) -> str:
-        """Replaces 'dict' type with 'code' or 'file'."""
-        if "dict" in _type.lower():
-            if key == "dict_":
-                field.field_type = "file"
-                field.suffixes = [".json", ".yaml", ".yml"]
-                field.file_types = ["json", "yaml", "yml"]
-            else:
-                field.field_type = "code"
-        return field.field_type
-
-    @staticmethod
-    def set_field_default_value(field: TemplateField, value: dict, key: str) -> None:
-        """Sets the field value with the default value if present."""
-        if "default" in value:
-            field.value = value["default"]
-        if key == "headers":
-            field.value = """{'Authorization': 'Bearer <token>'}"""

src/backend/langflow/template/field/base.py

@@ -0,0 +1,43 @@
+from abc import ABC
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel
+
+
+class TemplateFieldCreator(BaseModel, ABC):
+    field_type: str = "str"
+    required: bool = False
+    placeholder: str = ""
+    is_list: bool = False
+    show: bool = True
+    multiline: bool = False
+    value: Any = None
+    suffixes: list[str] = []
+    fileTypes: list[str] = []
+    file_types: list[str] = []
+    content: Union[str, None] = None
+    password: bool = False
+    options: list[str] = []
+    name: str = ""
+    display_name: Optional[str] = None
+    advanced: bool = False
+
+    def to_dict(self):
+        result = self.dict()
+        # Remove key if it is None
+        for key in list(result.keys()):
+            if result[key] is None or result[key] == []:
+                del result[key]
+        result["type"] = result.pop("field_type")
+        result["list"] = result.pop("is_list")
+
+        if result.get("file_types"):
+            result["fileTypes"] = result.pop("file_types")
+
+        if self.field_type == "file":
+            result["content"] = self.content
+        return result
+
+
+class TemplateField(TemplateFieldCreator):
+    pass

src/backend/langflow/template/frontend_node/__init__.py

@@ -0,0 +1,21 @@
+from langflow.template.frontend_node import (
+    agents,
+    chains,
+    embeddings,
+    llms,
+    memories,
+    prompts,
+    tools,
+    vectorstores,
+)
+
+__all__ = [
+    "agents",
+    "chains",
+    "embeddings",
+    "memories",
+    "tools",
+    "llms",
+    "prompts",
+    "vectorstores",
+]

src/backend/langflow/template/frontend_node/agents.py

@@ -0,0 +1,233 @@
+from typing import Optional
+
+from langchain.agents import types
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.template.base import Template
+
+NON_CHAT_AGENTS = {
+    agent_type: agent_class
+    for agent_type, agent_class in types.AGENT_TO_CLASS.items()
+    if "chat" not in agent_type.value
+}
+
+
+class SQLAgentNode(FrontendNode):
+    name: str = "SQLAgent"
+    template: Template = Template(
+        type_name="sql_agent",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=False,
+                value="",
+                name="database_uri",
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = """Construct a sql agent from an LLM and tools."""
+    base_classes: list[str] = ["AgentExecutor"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class VectorStoreRouterAgentNode(FrontendNode):
+    name: str = "VectorStoreRouterAgent"
+    template: Template = Template(
+        type_name="vectorstorerouter_agent",
+        fields=[
+            TemplateField(
+                field_type="VectorStoreRouterToolkit",
+                required=True,
+                show=True,
+                name="vectorstoreroutertoolkit",
+                display_name="Vector Store Router Toolkit",
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = """Construct an agent from a Vector Store Router."""
+    base_classes: list[str] = ["AgentExecutor"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class VectorStoreAgentNode(FrontendNode):
+    name: str = "VectorStoreAgent"
+    template: Template = Template(
+        type_name="vectorstore_agent",
+        fields=[
+            TemplateField(
+                field_type="VectorStoreInfo",
+                required=True,
+                show=True,
+                name="vectorstoreinfo",
+                display_name="Vector Store Info",
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = """Construct an agent from a Vector Store."""
+    base_classes: list[str] = ["AgentExecutor"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class SQLDatabaseNode(FrontendNode):
+    name: str = "SQLDatabase"
+    template: Template = Template(
+        type_name="sql_database",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=True,
+                is_list=False,
+                show=True,
+                multiline=False,
+                value="",
+                name="uri",
+            ),
+        ],
+    )
+    description: str = """SQLAlchemy wrapper around a database."""
+    base_classes: list[str] = ["SQLDatabase"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class CSVAgentNode(FrontendNode):
+    name: str = "CSVAgent"
+    template: Template = Template(
+        type_name="csv_agent",
+        fields=[
+            TemplateField(
+                field_type="file",
+                required=True,
+                show=True,
+                name="path",
+                value="",
+                suffixes=[".csv"],
+                fileTypes=["csv"],
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = """Construct a json agent from a CSV and tools."""
+    base_classes: list[str] = ["AgentExecutor"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class InitializeAgentNode(FrontendNode):
+    name: str = "initialize_agent"
+    template: Template = Template(
+        type_name="initailize_agent",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=True,
+                is_list=True,
+                show=True,
+                multiline=False,
+                options=list(NON_CHAT_AGENTS.keys()),
+                value=list(NON_CHAT_AGENTS.keys())[0],
+                name="agent",
+                advanced=False,
+            ),
+            TemplateField(
+                field_type="BaseChatMemory",
+                required=False,
+                show=True,
+                name="memory",
+                advanced=False,
+            ),
+            TemplateField(
+                field_type="Tool",
+                required=False,
+                show=True,
+                name="tools",
+                is_list=True,
+                advanced=False,
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+                advanced=False,
+            ),
+        ],
+    )
+    description: str = """Construct a json agent from an LLM and tools."""
+    base_classes: list[str] = ["AgentExecutor", "function"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        # do nothing and don't return anything
+        pass
+
+
+class JsonAgentNode(FrontendNode):
+    name: str = "JsonAgent"
+    template: Template = Template(
+        type_name="json_agent",
+        fields=[
+            TemplateField(
+                field_type="BaseToolkit",
+                required=True,
+                show=True,
+                name="toolkit",
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                show=True,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = """Construct a json agent from an LLM and tools."""
+    base_classes: list[str] = ["AgentExecutor"]
+
+    def to_dict(self):
+        return super().to_dict()

src/backend/langflow/template/frontend_node/base.py

@@ -0,0 +1,200 @@
+import re
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+from langflow.template.constants import FORCE_SHOW_FIELDS
+from langflow.template.field.base import TemplateField
+from langflow.template.template.base import Template
+from langflow.utils import constants
+
+
+class FrontendNode(BaseModel):
+    template: Template
+    description: str
+    base_classes: List[str]
+    name: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            self.name: {
+                "template": self.template.to_dict(self.format_field),
+                "description": self.description,
+                "base_classes": self.base_classes,
+            }
+        }
+
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        """Formats a given field based on its attributes and value."""
+        SPECIAL_FIELD_HANDLERS = {
+            "allowed_tools": lambda field: "Tool",
+            "max_value_length": lambda field: "int",
+        }
+
+        key = field.name
+        value = field.to_dict()
+        _type = value["type"]
+
+        _type = FrontendNode.remove_optional(_type)
+        _type, is_list = FrontendNode.check_for_list_type(_type)
+        field.is_list = is_list or field.is_list
+        _type = FrontendNode.replace_mapping_with_dict(_type)
+        _type = FrontendNode.handle_union_type(_type)
+
+        field.field_type = FrontendNode.handle_special_field(
+            field, key, _type, SPECIAL_FIELD_HANDLERS
+        )
+        field.field_type = FrontendNode.handle_dict_type(field, _type)
+        field.show = FrontendNode.should_show_field(key, field.required)
+        field.password = FrontendNode.should_be_password(key, field.show)
+        field.multiline = FrontendNode.should_be_multiline(key)
+
+        FrontendNode.replace_default_value(field, value)
+        FrontendNode.handle_specific_field_values(field, key, name)
+        FrontendNode.handle_kwargs_field(field)
+        FrontendNode.handle_api_key_field(field, key)
+
+    @staticmethod
+    def remove_optional(_type: str) -> str:
+        """Removes 'Optional' wrapper from the type if present."""
+        return re.sub(r"Optional\[(.*)\]", r"\1", _type)
+
+    @staticmethod
+    def check_for_list_type(_type: str) -> tuple:
+        """Checks for list type and returns the modified type and a boolean indicating if it's a list."""
+        is_list = "List" in _type or "Sequence" in _type
+        if is_list:
+            _type = re.sub(r"(List|Sequence)\[(.*)\]", r"\2", _type)
+        return _type, is_list
+
+    @staticmethod
+    def replace_mapping_with_dict(_type: str) -> str:
+        """Replaces 'Mapping' with 'dict'."""
+        return _type.replace("Mapping", "dict")
+
+    @staticmethod
+    def handle_union_type(_type: str) -> str:
+        """Simplifies the 'Union' type to the first type in the Union."""
+        if "Union" in _type:
+            _type = _type.replace("Union[", "")[:-1]
+            _type = _type.split(",")[0]
+            _type = _type.replace("]", "").replace("[", "")
+        return _type
+
+    @staticmethod
+    def handle_special_field(
+        field, key: str, _type: str, SPECIAL_FIELD_HANDLERS
+    ) -> str:
+        """Handles special field by using the respective handler if present."""
+        handler = SPECIAL_FIELD_HANDLERS.get(key)
+        return handler(field) if handler else _type
+
+    @staticmethod
+    def handle_dict_type(field: TemplateField, _type: str) -> str:
+        """Handles 'dict' type by replacing it with 'code' or 'file' based on the field name."""
+        if "dict" in _type.lower():
+            if field.name == "dict_":
+                field.field_type = "file"
+                field.suffixes = [".json", ".yaml", ".yml"]
+                field.file_types = ["json", "yaml", "yml"]
+            else:
+                field.field_type = "code"
+        return _type
+
+    @staticmethod
+    def replace_default_value(field: TemplateField, value: dict) -> None:
+        """Replaces default value with actual value if 'default' is present in value."""
+        if "default" in value:
+            field.value = value["default"]
+
+    @staticmethod
+    def handle_specific_field_values(
+        field: TemplateField, key: str, name: Optional[str] = None
+    ) -> None:
+        """Handles specific field values for certain fields."""
+        if key == "headers":
+            field.value = """{'Authorization':
+            'Bearer <token>'}"""
+        if name == "OpenAI" and key == "model_name":
+            field.options = constants.OPENAI_MODELS
+            field.is_list = True
+        elif name == "ChatOpenAI" and key == "model_name":
+            field.options = constants.CHAT_OPENAI_MODELS
+            field.is_list = True
+        if "api_key" in key and "OpenAI" in str(name):
+            field.display_name = "OpenAI API Key"
+            field.required = False
+            if field.value is None:
+                field.value = ""
+
+    @staticmethod
+    def handle_kwargs_field(field: TemplateField) -> None:
+        """Handles kwargs field by setting certain attributes."""
+        if "kwargs" in field.name.lower():
+            field.advanced = True
+            field.required = False
+            field.show = False
+
+    @staticmethod
+    def handle_api_key_field(field: TemplateField, key: str) -> None:
+        """Handles api key field by setting certain attributes."""
+        if "api" in key.lower() and "key" in key.lower():
+            field.required = False
+            field.advanced = False
+
+            field.display_name = key.replace("_", " ").title()
+            field.display_name = field.display_name.replace("Api", "API")
+
+    @staticmethod
+    def should_show_field(key: str, required: bool) -> bool:
+        """Determines whether the field should be shown."""
+        return (
+            (required and key not in ["input_variables"])
+            or key in FORCE_SHOW_FIELDS
+            or "api" in key
+            or ("key" in key and "input" not in key and "output" not in key)
+        )
+
+    @staticmethod
+    def should_be_password(key: str, show: bool) -> bool:
+        """Determines whether the field should be a password field."""
+        return (
+            any(text in key.lower() for text in {"password", "token", "api", "key"})
+            and show
+        )
+
+    @staticmethod
+    def should_be_multiline(key: str) -> bool:
+        """Determines whether the field should be multiline."""
+        return key in {
+            "suffix",
+            "prefix",
+            "template",
+            "examples",
+            "code",
+            "headers",
+            "description",
+        }
+
+    @staticmethod
+    def replace_dict_with_code_or_file(
+        field: TemplateField, _type: str, key: str
+    ) -> str:
+        """Replaces 'dict' type with 'code' or 'file'."""
+        if "dict" in _type.lower():
+            if key == "dict_":
+                field.field_type = "file"
+                field.suffixes = [".json", ".yaml", ".yml"]
+                field.file_types = ["json", "yaml", "yml"]
+            else:
+                field.field_type = "code"
+        return field.field_type
+
+    @staticmethod
+    def set_field_default_value(field: TemplateField, value: dict, key: str) -> None:
+        """Sets the field value with the default value if present."""
+        if "default" in value:
+            field.value = value["default"]
+        if key == "headers":
+            field.value = """{'Authorization': 'Bearer <token>'}"""

src/backend/langflow/template/frontend_node/chains.py

@@ -0,0 +1,157 @@
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.template.base import Template
+
+
+class ChainFrontendNode(FrontendNode):
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+
+        field.advanced = False
+        if "key" in field.name:
+            field.password = False
+            field.show = False
+        if field.name in ["input_key", "output_key"]:
+            field.required = True
+            field.show = True
+            field.advanced = True
+
+        # Separated for possible future changes
+        if field.name == "prompt" and field.value is None:
+            field.required = True
+            field.show = True
+            field.advanced = False
+        if field.name == "memory":
+            field.required = False
+            field.show = True
+            field.advanced = False
+        if field.name == "verbose":
+            field.required = False
+            field.show = True
+            field.advanced = True
+        if field.name == "llm":
+            field.required = True
+            field.show = True
+            field.advanced = False
+
+
+class SeriesCharacterChainNode(FrontendNode):
+    name: str = "SeriesCharacterChain"
+    template: Template = Template(
+        type_name="SeriesCharacterChain",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                advanced=False,
+                multiline=False,
+                name="character",
+            ),
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                advanced=False,
+                multiline=False,
+                name="series",
+            ),
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                advanced=False,
+                multiline=False,
+                name="llm",
+                display_name="LLM",
+            ),
+        ],
+    )
+    description: str = "SeriesCharacterChain is a chain you can use to have a conversation with a character from a series."  # noqa
+    base_classes: list[str] = [
+        "LLMChain",
+        "BaseCustomChain",
+        "Chain",
+        "ConversationChain",
+        "SeriesCharacterChain",
+        "function",
+    ]
+
+
+class TimeTravelGuideChainNode(FrontendNode):
+    name: str = "TimeTravelGuideChain"
+    template: Template = Template(
+        type_name="TimeTravelGuideChain",
+        fields=[
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                advanced=False,
+                multiline=False,
+                name="llm",
+                display_name="LLM",
+            ),
+            TemplateField(
+                field_type="BaseChatMemory",
+                required=False,
+                show=True,
+                name="memory",
+                advanced=False,
+            ),
+        ],
+    )
+    description: str = "Time travel guide chain to be used in the flow."
+    base_classes: list[str] = [
+        "LLMChain",
+        "BaseCustomChain",
+        "TimeTravelGuideChain",
+        "Chain",
+        "ConversationChain",
+    ]
+
+
+class MidJourneyPromptChainNode(FrontendNode):
+    name: str = "MidJourneyPromptChain"
+    template: Template = Template(
+        type_name="MidJourneyPromptChain",
+        fields=[
+            TemplateField(
+                field_type="BaseLanguageModel",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                advanced=False,
+                multiline=False,
+                name="llm",
+                display_name="LLM",
+            ),
+            TemplateField(
+                field_type="BaseChatMemory",
+                required=False,
+                show=True,
+                name="memory",
+                advanced=False,
+            ),
+        ],
+    )
+    description: str = "MidJourneyPromptChain is a chain you can use to generate new MidJourney prompts."
+    base_classes: list[str] = [
+        "LLMChain",
+        "BaseCustomChain",
+        "Chain",
+        "ConversationChain",
+        "MidJourneyPromptChain",
+    ]

src/backend/langflow/template/frontend_node/embeddings.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+
+
+class EmbeddingFrontendNode(FrontendNode):
+    @staticmethod
+    def format_jina_fields(field: TemplateField):
+        if "jina" in field.name:
+            field.show = True
+            field.advanced = False
+
+        if "auth" in field.name or "token" in field.name:
+            field.password = True
+            field.show = True
+            field.advanced = False
+
+        if field.name == "jina_api_url":
+            field.show = True
+            field.advanced = True
+            field.display_name = "Jina API URL"
+            field.password = False
+
+    @staticmethod
+    def format_openai_fields(field: TemplateField):
+        if "openai" in field.name:
+            field.show = True
+            field.advanced = True
+            split_name = field.name.split("_")
+            title_name = " ".join([s.capitalize() for s in split_name])
+            field.display_name = title_name.replace("Openai", "OpenAI").replace(
+                "Api", "API"
+            )
+
+        if "api_key" in field.name:
+            field.password = True
+            field.show = True
+            field.advanced = False
+
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+        field.advanced = not field.required
+        field.show = True
+        if field.name == "headers":
+            field.show = False
+
+        # Format Jina fields
+        EmbeddingFrontendNode.format_jina_fields(field)
+        EmbeddingFrontendNode.format_openai_fields(field)

src/backend/langflow/template/frontend_node/llms.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+
+
+class LLMFrontendNode(FrontendNode):
+    @staticmethod
+    def format_openai_field(field: TemplateField):
+        if "openai" in field.name.lower():
+            field.display_name = (
+                field.name.title().replace("Openai", "OpenAI").replace("_", " ")
+            ).replace("Api", "API")
+
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        display_names_dict = {
+            "huggingfacehub_api_token": "HuggingFace Hub API Token",
+        }
+        FrontendNode.format_field(field, name)
+        SHOW_FIELDS = ["repo_id"]
+        if field.name in SHOW_FIELDS:
+            field.show = True
+
+        if "api" in field.name and ("key" in field.name or "token" in field.name):
+            field.password = True
+            field.show = True
+            # Required should be False to support
+            # loading the API key from environment variables
+            field.required = False
+            field.advanced = False
+
+        if field.name == "task":
+            field.required = True
+            field.show = True
+            field.is_list = True
+            field.options = ["text-generation", "text2text-generation"]
+            field.advanced = True
+
+        if display_name := display_names_dict.get(field.name):
+            field.display_name = display_name
+        if field.name == "model_kwargs":
+            field.field_type = "code"
+            field.advanced = True
+            field.show = True
+        elif field.name in ["model_name", "temperature"]:
+            field.advanced = False
+            field.show = True
+
+        LLMFrontendNode.format_openai_field(field)

src/backend/langflow/template/frontend_node/memories.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+
+
+class MemoryFrontendNode(FrontendNode):
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+
+        if not isinstance(field.value, str):
+            field.value = None
+        if field.name == "k":
+            field.required = True
+            field.show = True
+            field.field_type = "int"
+            field.value = 10
+            field.display_name = "Memory Size"
+        field.password = False

src/backend/langflow/template/frontend_node/prompts.py

@@ -0,0 +1,111 @@
+from typing import Optional
+
+from langchain.agents.mrkl import prompt
+
+from langflow.template.constants import DEFAULT_PROMPT, HUMAN_PROMPT, SYSTEM_PROMPT
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.template.base import Template
+
+
+class PromptFrontendNode(FrontendNode):
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        # if field.field_type  == "StringPromptTemplate"
+        # change it to str
+        PROMPT_FIELDS = [
+            "template",
+            "suffix",
+            "prefix",
+            "examples",
+            "format_instructions",
+        ]
+        if field.field_type == "StringPromptTemplate" and "Message" in str(name):
+            field.field_type = "prompt"
+            field.multiline = True
+            field.value = HUMAN_PROMPT if "Human" in field.name else SYSTEM_PROMPT
+        if field.name == "template" and field.value == "":
+            field.value = DEFAULT_PROMPT
+
+        if field.name in PROMPT_FIELDS:
+            field.field_type = "prompt"
+            field.advanced = False
+
+        if (
+            "Union" in field.field_type
+            and "BaseMessagePromptTemplate" in field.field_type
+        ):
+            field.field_type = "BaseMessagePromptTemplate"
+
+        # All prompt fields should be password=False
+        field.password = False
+
+
+class PromptTemplateNode(FrontendNode):
+    name: str = "PromptTemplate"
+    template: Template
+    description: str
+    base_classes: list[str] = ["BasePromptTemplate"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+        if field.name == "examples":
+            field.advanced = False
+
+
+class BasePromptFrontendNode(FrontendNode):
+    name: str
+    template: Template
+    description: str
+    base_classes: list[str]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class ZeroShotPromptNode(BasePromptFrontendNode):
+    name: str = "ZeroShotPrompt"
+    template: Template = Template(
+        type_name="zero_shot",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=False,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=True,
+                value=prompt.PREFIX,
+                name="prefix",
+            ),
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=True,
+                value=prompt.SUFFIX,
+                name="suffix",
+            ),
+            TemplateField(
+                field_type="str",
+                required=False,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=True,
+                value=prompt.FORMAT_INSTRUCTIONS,
+                name="format_instructions",
+            ),
+        ],
+    )
+    description: str = "Prompt template for Zero Shot Agent."
+    base_classes: list[str] = ["BasePromptTemplate"]
+
+    def to_dict(self):
+        return super().to_dict()

src/backend/langflow/template/frontend_node/tools.py

@@ -0,0 +1,83 @@
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+from langflow.template.template.base import Template
+from langflow.utils.constants import DEFAULT_PYTHON_FUNCTION
+
+
+class ToolNode(FrontendNode):
+    name: str = "Tool"
+    template: Template = Template(
+        type_name="Tool",
+        fields=[
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=True,
+                value="",
+                name="name",
+                advanced=False,
+            ),
+            TemplateField(
+                field_type="str",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=True,
+                value="",
+                name="description",
+                advanced=False,
+            ),
+            TemplateField(
+                name="func",
+                field_type="function",
+                required=True,
+                is_list=False,
+                show=True,
+                multiline=True,
+                advanced=False,
+            ),
+            TemplateField(
+                field_type="bool",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                multiline=False,
+                value=False,
+                name="return_direct",
+            ),
+        ],
+    )
+    description: str = "Tool to be used in the flow."
+    base_classes: list[str] = ["Tool"]
+
+    def to_dict(self):
+        return super().to_dict()
+
+
+class PythonFunctionNode(FrontendNode):
+    name: str = "PythonFunction"
+    template: Template = Template(
+        type_name="python_function",
+        fields=[
+            TemplateField(
+                field_type="code",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                value=DEFAULT_PYTHON_FUNCTION,
+                name="code",
+                advanced=False,
+            )
+        ],
+    )
+    description: str = "Python function to be executed."
+    base_classes: list[str] = ["function"]
+
+    def to_dict(self):
+        return super().to_dict()

src/backend/langflow/template/frontend_node/utilities.py

@@ -0,0 +1,21 @@
+import json
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+
+
+class UtilitiesFrontendNode(FrontendNode):
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+        # field.field_type could be "Literal['news', 'search', 'places', 'images']
+        # we need to convert it to a list
+        if "Literal" in field.field_type:
+            field.options = eval(field.field_type.replace("Literal", ""))
+            field.is_list = True
+            field.field_type = "str"
+
+        if isinstance(field.value, dict):
+            field.field_type = "code"
+            field.value = json.dumps(field.value, indent=4)

src/backend/langflow/template/frontend_node/vectorstores.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from langflow.template.field.base import TemplateField
+from langflow.template.frontend_node.base import FrontendNode
+
+
+class VectorStoreFrontendNode(FrontendNode):
+    @staticmethod
+    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
+        FrontendNode.format_field(field, name)
+        # Define common field attributes
+        basic_fields = ["work_dir", "collection_name", "api_key", "location"]
+        advanced_fields = [
+            "n_dim",
+            "key",
+            "prefix",
+            "distance_func",
+            "content_payload_key",
+            "metadata_payload_key",
+            "timeout",
+            "host",
+            "path",
+            "url",
+            "port",
+            "https",
+            "prefer_grpc",
+            "grpc_port",
+        ]
+
+        # Check and set field attributes
+        if field.name == "texts":
+            field.name = "documents"
+            field.field_type = "TextSplitter"
+            field.display_name = "Text Splitter"
+            field.required = True
+            field.show = True
+            field.advanced = False
+
+        elif "embedding" in field.name:
+            # for backwards compatibility
+            field.name = "embedding"
+            field.required = True
+            field.show = True
+            field.advanced = False
+            field.display_name = "Embedding"
+            field.field_type = "Embeddings"
+
+        elif field.name in basic_fields:
+            field.show = True
+            field.advanced = False
+            if field.name == "api_key":
+                field.display_name = "API Key"
+                field.password = True
+            elif field.name == "location":
+                field.value = ":memory:"
+                field.placeholder = ":memory:"
+
+        elif field.name in advanced_fields:
+            field.show = True
+            field.advanced = True
+            if "key" in field.name:
+                field.password = False
+        # TODO: Weaviate requires weaviate_url to be passed as it is not part of
+        # the class or from_texts method. We need the add_extra_fields to fix this

src/backend/langflow/template/nodes.py

@@ -1,691 +1 @@
-from typing import Optional
 
-from langchain.agents import loading
-from langchain.agents.mrkl import prompt
-
-from langflow.template.base import FrontendNode, Template, TemplateField
-from langflow.template.constants import DEFAULT_PROMPT, HUMAN_PROMPT, SYSTEM_PROMPT
-from langflow.utils.constants import DEFAULT_PYTHON_FUNCTION
-
-NON_CHAT_AGENTS = {
-    agent_type: agent_class
-    for agent_type, agent_class in loading.AGENT_TO_CLASS.items()
-    if "chat" not in agent_type.value
-}
-
-
-class BasePromptFrontendNode(FrontendNode):
-    name: str
-    template: Template
-    description: str
-    base_classes: list[str]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class ZeroShotPromptNode(BasePromptFrontendNode):
-    name: str = "ZeroShotPrompt"
-    template: Template = Template(
-        type_name="zero_shot",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=False,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=True,
-                value=prompt.PREFIX,
-                name="prefix",
-            ),
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=True,
-                value=prompt.SUFFIX,
-                name="suffix",
-            ),
-            TemplateField(
-                field_type="str",
-                required=False,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=True,
-                value=prompt.FORMAT_INSTRUCTIONS,
-                name="format_instructions",
-            ),
-        ],
-    )
-    description: str = "Prompt template for Zero Shot Agent."
-    base_classes: list[str] = ["BasePromptTemplate"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class PromptTemplateNode(FrontendNode):
-    name: str = "PromptTemplate"
-    template: Template
-    description: str
-    base_classes: list[str] = ["BasePromptTemplate"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        FrontendNode.format_field(field, name)
-        if field.name == "examples":
-            field.advanced = False
-
-
-class PythonFunctionNode(FrontendNode):
-    name: str = "PythonFunction"
-    template: Template = Template(
-        type_name="python_function",
-        fields=[
-            TemplateField(
-                field_type="code",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                value=DEFAULT_PYTHON_FUNCTION,
-                name="code",
-                advanced=False,
-            )
-        ],
-    )
-    description: str = "Python function to be executed."
-    base_classes: list[str] = ["function"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class MidJourneyPromptChainNode(FrontendNode):
-    name: str = "MidJourneyPromptChain"
-    template: Template = Template(
-        type_name="MidJourneyPromptChain",
-        fields=[
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                advanced=False,
-                multiline=False,
-                name="llm",
-                display_name="LLM",
-            ),
-            TemplateField(
-                field_type="BaseChatMemory",
-                required=False,
-                show=True,
-                name="memory",
-                advanced=False,
-            ),
-        ],
-    )
-    description: str = "MidJourneyPromptChain is a chain you can use to generate new MidJourney prompts."
-    base_classes: list[str] = [
-        "LLMChain",
-        "BaseCustomChain",
-        "Chain",
-        "ConversationChain",
-        "MidJourneyPromptChain",
-    ]
-
-
-class TimeTravelGuideChainNode(FrontendNode):
-    name: str = "TimeTravelGuideChain"
-    template: Template = Template(
-        type_name="TimeTravelGuideChain",
-        fields=[
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                advanced=False,
-                multiline=False,
-                name="llm",
-                display_name="LLM",
-            ),
-            TemplateField(
-                field_type="BaseChatMemory",
-                required=False,
-                show=True,
-                name="memory",
-                advanced=False,
-            ),
-        ],
-    )
-    description: str = "Time travel guide chain to be used in the flow."
-    base_classes: list[str] = [
-        "LLMChain",
-        "BaseCustomChain",
-        "TimeTravelGuideChain",
-        "Chain",
-        "ConversationChain",
-    ]
-
-
-class SeriesCharacterChainNode(FrontendNode):
-    name: str = "SeriesCharacterChain"
-    template: Template = Template(
-        type_name="SeriesCharacterChain",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                advanced=False,
-                multiline=False,
-                name="character",
-            ),
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                advanced=False,
-                multiline=False,
-                name="series",
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                advanced=False,
-                multiline=False,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = "SeriesCharacterChain is a chain you can use to have a conversation with a character from a series."  # noqa
-    base_classes: list[str] = [
-        "LLMChain",
-        "BaseCustomChain",
-        "Chain",
-        "ConversationChain",
-        "SeriesCharacterChain",
-        "function",
-    ]
-
-
-class ToolNode(FrontendNode):
-    name: str = "Tool"
-    template: Template = Template(
-        type_name="Tool",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=True,
-                value="",
-                name="name",
-                advanced=False,
-            ),
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=True,
-                value="",
-                name="description",
-                advanced=False,
-            ),
-            TemplateField(
-                name="func",
-                field_type="function",
-                required=True,
-                is_list=False,
-                show=True,
-                multiline=True,
-                advanced=False,
-            ),
-            TemplateField(
-                field_type="bool",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=False,
-                value=False,
-                name="return_direct",
-            ),
-        ],
-    )
-    description: str = "Tool to be used in the flow."
-    base_classes: list[str] = ["Tool"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class JsonAgentNode(FrontendNode):
-    name: str = "JsonAgent"
-    template: Template = Template(
-        type_name="json_agent",
-        fields=[
-            TemplateField(
-                field_type="BaseToolkit",
-                required=True,
-                show=True,
-                name="toolkit",
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = """Construct a json agent from an LLM and tools."""
-    base_classes: list[str] = ["AgentExecutor"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class InitializeAgentNode(FrontendNode):
-    name: str = "initialize_agent"
-    template: Template = Template(
-        type_name="initailize_agent",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=True,
-                is_list=True,
-                show=True,
-                multiline=False,
-                options=list(NON_CHAT_AGENTS.keys()),
-                value=list(NON_CHAT_AGENTS.keys())[0],
-                name="agent",
-                advanced=False,
-            ),
-            TemplateField(
-                field_type="BaseChatMemory",
-                required=False,
-                show=True,
-                name="memory",
-                advanced=False,
-            ),
-            TemplateField(
-                field_type="Tool",
-                required=False,
-                show=True,
-                name="tools",
-                is_list=True,
-                advanced=False,
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-                advanced=False,
-            ),
-        ],
-    )
-    description: str = """Construct a json agent from an LLM and tools."""
-    base_classes: list[str] = ["AgentExecutor", "function"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        # do nothing and don't return anything
-        pass
-
-
-class CSVAgentNode(FrontendNode):
-    name: str = "CSVAgent"
-    template: Template = Template(
-        type_name="csv_agent",
-        fields=[
-            TemplateField(
-                field_type="file",
-                required=True,
-                show=True,
-                name="path",
-                value="",
-                suffixes=[".csv"],
-                fileTypes=["csv"],
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = """Construct a json agent from a CSV and tools."""
-    base_classes: list[str] = ["AgentExecutor"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class SQLDatabaseNode(FrontendNode):
-    name: str = "SQLDatabase"
-    template: Template = Template(
-        type_name="sql_database",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=True,
-                is_list=False,
-                show=True,
-                multiline=False,
-                value="",
-                name="uri",
-            ),
-        ],
-    )
-    description: str = """SQLAlchemy wrapper around a database."""
-    base_classes: list[str] = ["SQLDatabase"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class VectorStoreAgentNode(FrontendNode):
-    name: str = "VectorStoreAgent"
-    template: Template = Template(
-        type_name="vectorstore_agent",
-        fields=[
-            TemplateField(
-                field_type="VectorStoreInfo",
-                required=True,
-                show=True,
-                name="vectorstoreinfo",
-                display_name="Vector Store Info",
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = """Construct an agent from a Vector Store."""
-    base_classes: list[str] = ["AgentExecutor"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class VectorStoreRouterAgentNode(FrontendNode):
-    name: str = "VectorStoreRouterAgent"
-    template: Template = Template(
-        type_name="vectorstorerouter_agent",
-        fields=[
-            TemplateField(
-                field_type="VectorStoreRouterToolkit",
-                required=True,
-                show=True,
-                name="vectorstoreroutertoolkit",
-                display_name="Vector Store Router Toolkit",
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = """Construct an agent from a Vector Store Router."""
-    base_classes: list[str] = ["AgentExecutor"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class SQLAgentNode(FrontendNode):
-    name: str = "SQLAgent"
-    template: Template = Template(
-        type_name="sql_agent",
-        fields=[
-            TemplateField(
-                field_type="str",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                multiline=False,
-                value="",
-                name="database_uri",
-            ),
-            TemplateField(
-                field_type="BaseLanguageModel",
-                required=True,
-                show=True,
-                name="llm",
-                display_name="LLM",
-            ),
-        ],
-    )
-    description: str = """Construct an agent from a Vector Store Router."""
-    base_classes: list[str] = ["AgentExecutor"]
-
-    def to_dict(self):
-        return super().to_dict()
-
-
-class PromptFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        # if field.field_type  == "StringPromptTemplate"
-        # change it to str
-        PROMPT_FIELDS = [
-            "template",
-            "suffix",
-            "prefix",
-            "examples",
-            "format_instructions",
-        ]
-        if field.field_type == "StringPromptTemplate" and "Message" in str(name):
-            field.field_type = "prompt"
-            field.multiline = True
-            field.value = HUMAN_PROMPT if "Human" in field.name else SYSTEM_PROMPT
-        if field.name == "template" and field.value == "":
-            field.value = DEFAULT_PROMPT
-
-        if field.name in PROMPT_FIELDS:
-            field.field_type = "prompt"
-            field.advanced = False
-
-        if (
-            "Union" in field.field_type
-            and "BaseMessagePromptTemplate" in field.field_type
-        ):
-            field.field_type = "BaseMessagePromptTemplate"
-
-        # All prompt fields should be password=False
-        field.password = False
-
-
-class MemoryFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        FrontendNode.format_field(field, name)
-
-        if not isinstance(field.value, str):
-            field.value = None
-        if field.name == "k":
-            field.required = True
-            field.show = True
-            field.field_type = "int"
-            field.value = 10
-            field.display_name = "Memory Size"
-        field.password = False
-
-
-class ChainFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        FrontendNode.format_field(field, name)
-
-        field.advanced = False
-        if "key" in field.name:
-            field.password = False
-            field.show = False
-        if field.name in ["input_key", "output_key"]:
-            field.required = True
-            field.show = True
-            field.advanced = True
-
-        # Separated for possible future changes
-        if field.name == "prompt" and field.value is None:
-            # if no prompt is provided, use the default prompt
-            field.required = False
-            field.show = True
-            field.advanced = False
-        if field.name == "memory":
-            field.required = False
-            field.show = True
-            field.advanced = False
-        if field.name == "verbose":
-            field.required = False
-            field.show = True
-            field.advanced = True
-        if field.name == "llm":
-            field.required = True
-            field.show = True
-            field.advanced = False
-
-
-class LLMFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        display_names_dict = {
-            "huggingfacehub_api_token": "HuggingFace Hub API Token",
-        }
-        FrontendNode.format_field(field, name)
-        SHOW_FIELDS = ["repo_id"]
-        if field.name in SHOW_FIELDS:
-            field.show = True
-
-        if "api" in field.name and ("key" in field.name or "token" in field.name):
-            field.password = True
-            field.show = True
-            # Required should be False to support
-            # loading the API key from environment variables
-            field.required = False
-            field.advanced = False
-
-        if field.name == "task":
-            field.required = True
-            field.show = True
-            field.is_list = True
-            field.options = ["text-generation", "text2text-generation"]
-            field.advanced = True
-
-        if display_name := display_names_dict.get(field.name):
-            field.display_name = display_name
-        if field.name == "model_kwargs":
-            field.field_type = "code"
-            field.advanced = True
-            field.show = True
-        elif field.name in ["model_name", "temperature"]:
-            field.advanced = False
-            field.show = True
-
-
-class EmbeddingFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        FrontendNode.format_field(field, name)
-        if field.name == "headers":
-            field.show = False
-
-
-class VectorStoreFrontendNode(FrontendNode):
-    @staticmethod
-    def format_field(field: TemplateField, name: Optional[str] = None) -> None:
-        FrontendNode.format_field(field, name)
-        # Define common field attributes
-        basic_fields = ["work_dir", "collection_name", "api_key", "location"]
-        advanced_fields = [
-            "n_dim",
-            "key",
-            "prefix",
-            "distance_func",
-            "content_payload_key",
-            "metadata_payload_key",
-            "timeout",
-            "host",
-            "path",
-            "url",
-            "port",
-            "https",
-            "prefer_grpc",
-            "grpc_port",
-        ]
-
-        # Check and set field attributes
-        if field.name == "texts":
-            field.name = "documents"
-            field.field_type = "TextSplitter"
-            field.display_name = "Text Splitter"
-            field.required = True
-            field.show = True
-            field.advanced = False
-
-        elif "embedding" in field.name:
-            # for backwards compatibility
-            field.name = "embedding"
-            field.required = True
-            field.show = True
-            field.advanced = False
-            field.display_name = "Embedding"
-            field.field_type = "Embeddings"
-
-        elif field.name in basic_fields:
-            field.show = True
-            field.advanced = False
-            if field.name == "api_key":
-                field.display_name = "API Key"
-                field.password = True
-            elif field.name == "location":
-                field.value = ":memory:"
-                field.placeholder = ":memory:"
-
-        elif field.name in advanced_fields:
-            field.show = True
-            field.advanced = True
-            if "key" in field.name:
-                field.password = False
-
-        # TODO: Weaviate requires weaviate_url to be passed as it is not part of
-        # the class or from_texts method. We need the add_extra_fields to fix this

src/backend/langflow/template/template/base.py

@@ -0,0 +1,25 @@
+from typing import Callable, Optional, Union
+
+from pydantic import BaseModel
+
+from langflow.template.field.base import TemplateField
+
+
+class Template(BaseModel):
+    type_name: str
+    fields: list[TemplateField]
+
+    def process_fields(
+        self,
+        name: Optional[str] = None,
+        format_field_func: Union[Callable, None] = None,
+    ):
+        if format_field_func:
+            for field in self.fields:
+                format_field_func(field, name)
+
+    def to_dict(self, format_field_func=None):
+        self.process_fields(self.type_name, format_field_func)
+        result = {field.name: field.to_dict() for field in self.fields}
+        result["_type"] = self.type_name  # type: ignore
+        return result

src/backend/langflow/utils/util.py

@@ -10,49 +10,6 @@ from langflow.template.constants import FORCE_SHOW_FIELDS
 from langflow.utils import constants
 
 
-def build_template_from_parameters(
-    name: str, type_to_loader_dict: Dict, add_function: bool = False
-):
-    # Retrieve the function that matches the provided name
-    func = None
-    for _, v in type_to_loader_dict.items():
-        if v.__name__ == name:
-            func = v
-            break
-
-    if func is None:
-        raise ValueError(f"{name} not found")
-
-    # Process parameters
-    parameters = func.__annotations__
-    variables = {}
-    for param_name, param_type in parameters.items():
-        if param_name in ["return", "kwargs"]:
-            continue
-
-        variables[param_name] = {
-            "type": param_type.__name__,
-            "default": parameters[param_name].__repr_args__()[0][1],
-            # Op
-            "placeholder": "",
-        }
-
-    # Get the base classes of the return type
-    return_type = parameters.get("return")
-    base_classes = get_base_classes(return_type) if return_type else []
-    if add_function:
-        base_classes.append("function")
-
-    # Get the function's docstring
-    docs = inspect.getdoc(func) or ""
-
-    return {
-        "template": format_dict(variables, name),
-        "description": docs["Description"],  # type: ignore
-        "base_classes": base_classes,
-    }
-
-
 def build_template_from_function(
     name: str, type_to_loader_dict: Dict, add_function: bool = False
 ):

src/frontend/src/CustomNodes/GenericNode/index.tsx

@@ -1,13 +1,17 @@
 import {
   BugAntIcon,
-  CheckCircleIcon,
   Cog6ToothIcon,
-  EllipsisHorizontalCircleIcon,
-  ExclamationCircleIcon,
   InformationCircleIcon,
   TrashIcon,
 } from "@heroicons/react/24/outline";
-import { classNames, nodeColors, nodeIcons, toNormalCase } from "../../utils";
+
+import {
+  CheckCircleIcon,
+  EllipsisHorizontalCircleIcon,
+  ExclamationCircleIcon,
+} from "@heroicons/react/24/solid";
+
+import { classNames, nodeColors, nodeIcons, toNormalCase, toTitleCase } from "../../utils";
 import ParameterComponent from "./components/parameterComponent";
 import { typesContext } from "../../contexts/typesContext";
 import { useContext, useState, useEffect, useRef, Fragment } from "react";
@@ -102,7 +106,9 @@ export default function GenericNode({
               color: nodeColors[types[data.type]] ?? nodeColors.unknown,
             }}
           />
-          <div className="ml-2 truncate">{data.type}</div>
+          <Tooltip title={data.type} placement="top">
+              <div className="ml-2 truncate">{data.type}</div>
+          </Tooltip>
           <div>
             <Tooltip
               title={
@@ -226,8 +232,8 @@ export default function GenericNode({
                       data.node.template[t].display_name
                         ? data.node.template[t].display_name
                         : data.node.template[t].name
-                        ? toNormalCase(data.node.template[t].name)
-                        : toNormalCase(t)
+                        ? toTitleCase(data.node.template[t].name)
+                        : toTitleCase(t)
                     }
                     name={t}
                     tooltipTitle={

src/frontend/src/components/chatComponent/chatTrigger/index.tsx

@@ -23,14 +23,12 @@ export default function ChatTrigger({ open, setOpen }) {
     >
       <div className="absolute bottom-4 right-3">
         <div
-          // style={{ backgroundColor: nodeColors["chat"] }}
-          className="border flex justify-center align-center py-1 px-3 w-12 h-12 rounded-full bg-gradient-to-r from-blue-500 via-blue-600 to-blue-700 dark:border-gray-600"
+          className="border flex justify-center align-center py-1 px-3 w-12 h-12 rounded-full bg-gradient-to-r from-blue-500 via-blue-600 to-blue-700 dark:border-gray-600 cursor-pointer"
+          onClick={() => {
+            setOpen(true);
+          }}
         >
-          <button
-            onClick={() => {
-              setOpen(true);
-            }}
-          >
+          <button>
             <div className="flex gap-3  items-center">
               <ChatBubbleBottomCenterTextIcon
                 className="h-6 w-6 mt-1"

src/frontend/src/components/inputComponent/index.tsx

@@ -32,7 +32,7 @@ export default function InputComponent({
           disabled ? " bg-gray-200 dark:bg-gray-700" : "",
           password && !pwdVisible && myValue !== "" ? "password" : ""
         )}
-        placeholder="Type a text"
+        placeholder="Type something..."
         onChange={(e) => {
           setMyValue(e.target.value);
           onChange(e.target.value);

src/frontend/src/components/inputListComponent/index.tsx

@@ -33,7 +33,7 @@ export default function InputListComponent({
               "block w-full form-input rounded-md border-gray-300 shadow-sm focus:border-indigo-500 focus:ring-indigo-500 sm:text-sm" +
               (disabled ? " bg-gray-200" : "")
             }
-            placeholder="Type a text"
+            placeholder="Type something..."
             onChange={(e) => {
               setInputList((old) => {
                 let newInputList = _.cloneDeep(old);

src/frontend/src/components/promptComponent/index.tsx

@@ -4,7 +4,8 @@ import { PopUpContext } from "../../contexts/popUpContext";
 import CodeAreaModal from "../../modals/codeAreaModal";
 import TextAreaModal from "../../modals/textAreaModal";
 import { TextAreaComponentType } from "../../types/components";
-import PromptAreaModal from "../../modals/promptModal";
+import GenericModal from "../../modals/genericModal";
+import { TypeModal } from "../../utils";
 
 export default function PromptAreaComponent({
   value,
@@ -29,8 +30,11 @@ export default function PromptAreaComponent({
         <span
           onClick={() => {
             openPopUp(
-              <PromptAreaModal
+              <GenericModal
+                type={TypeModal.PROMPT}
                 value={myValue}
+                buttonText="Check & Save"
+                modalTitle="Edit Prompt"
                 setValue={(t: string) => {
                   setMyValue(t);
                   onChange(t);
@@ -48,8 +52,11 @@ export default function PromptAreaComponent({
         <button
           onClick={() => {
             openPopUp(
-              <PromptAreaModal
+              <GenericModal
+                type={TypeModal.PROMPT}
                 value={myValue}
+                buttonText="Check & Save"
+                modalTitle="Edit Prompt"
                 setValue={(t: string) => {
                   setMyValue(t);
                   onChange(t);

src/frontend/src/components/textAreaComponent/index.tsx

@@ -1,8 +1,9 @@
 import { ArrowTopRightOnSquareIcon } from "@heroicons/react/24/outline";
 import { useContext, useEffect, useState } from "react";
 import { PopUpContext } from "../../contexts/popUpContext";
-import TextAreaModal from "../../modals/textAreaModal";
 import { TextAreaComponentType } from "../../types/components";
+import GenericModal from "../../modals/genericModal";
+import { TypeModal } from "../../utils";
 
 export default function TextAreaComponent({
   value,
@@ -23,7 +24,10 @@ export default function TextAreaComponent({
         <span
           onClick={() => {
             openPopUp(
-              <TextAreaModal
+              <GenericModal
+                type={TypeModal.TEXT}
+                buttonText="Finishing Editing"
+                modalTitle="Edit Text"
                 value={myValue}
                 setValue={(t: string) => {
                   setMyValue(t);
@@ -42,7 +46,10 @@ export default function TextAreaComponent({
         <button
           onClick={() => {
             openPopUp(
-              <TextAreaModal
+              <GenericModal
+                type={TypeModal.TEXT}
+                buttonText="Finishing Editing"
+                modalTitle="Edit Text"
                 value={myValue}
                 setValue={(t: string) => {
                   setMyValue(t);

src/frontend/src/contexts/tabsContext.tsx

@@ -63,7 +63,8 @@ export function TabsProvider({ children }: { children: ReactNode }) {
               console.log(node.data.node.template[key].type);
               if (node.data.node.template[key].type === "file") {
                 console.log(node.data.node.template[key]);
-                node.data.node.template[key].content = "";
+                // ! Commenting this out for now, as it is causing issues with the file upload
+                // node.data.node.template[key].content = "";
               }
             });
           });

src/frontend/src/modals/NodeModal/index.tsx

@@ -3,7 +3,7 @@ import { XMarkIcon } from "@heroicons/react/24/outline";
 import { Fragment, useContext, useRef, useState } from "react";
 import { PopUpContext } from "../../contexts/popUpContext";
 import { NodeDataType } from "../../types/flow";
-import { nodeColors, nodeIcons, toNormalCase } from "../../utils";
+import { nodeColors, nodeIcons, toNormalCase, toTitleCase } from "../../utils";
 import { typesContext } from "../../contexts/typesContext";
 import ModalField from "./components/ModalField";
 
@@ -103,8 +103,8 @@ export default function NodeModal({ data }: { data: NodeDataType }) {
                                     data.node.template[t].display_name
                                       ? data.node.template[t].display_name
                                       : data.node.template[t].name
-                                      ? toNormalCase(data.node.template[t].name)
-                                      : toNormalCase(t)
+                                      ? toTitleCase(data.node.template[t].name)
+                                      : toTitleCase(t)
                                   }
                                   required={data.node.template[t].required}
                                   id={

src/frontend/src/modals/genericModal/index.tsx

@@ -0,0 +1,174 @@
+import { Dialog, Transition } from "@headlessui/react";
+import { XMarkIcon, DocumentTextIcon } from "@heroicons/react/24/outline";
+import { Fragment, useContext, useRef, useState } from "react";
+import { PopUpContext } from "../../contexts/popUpContext";
+import { darkContext } from "../../contexts/darkContext";
+import { checkPrompt } from "../../controllers/API";
+import { alertContext } from "../../contexts/alertContext";
+import { TypeModal } from "../../utils";
+export default function PromptAreaModal({
+  value,
+  setValue,
+  buttonText,
+  modalTitle,
+  type
+}: {
+  setValue: (value: string) => void;
+  value: string;
+  buttonText: string;
+  modalTitle: string;
+  type: number;
+}) {
+  const [myButtonText] = useState(buttonText);
+  const [myModalTitle] = useState(modalTitle);
+  const [myModalType] = useState(type);
+  const [open, setOpen] = useState(true);
+  const [myValue, setMyValue] = useState(value);
+  const { dark } = useContext(darkContext);
+  const { setErrorData, setSuccessData } = useContext(alertContext);
+  const { closePopUp } = useContext(PopUpContext);
+  const ref = useRef();
+  function setModalOpen(x: boolean) {
+    setOpen(x);
+    if (x === false) {
+      setTimeout(() => {
+        closePopUp();
+      }, 300);
+    }
+  }
+
+  return (
+    <Transition.Root show={open} appear={true} as={Fragment}>
+      <Dialog
+        as="div"
+        className="relative z-10"
+        onClose={setModalOpen}
+        initialFocus={ref}
+      >
+        <Transition.Child
+          as={Fragment}
+          enter="ease-out duration-300"
+          enterFrom="opacity-0"
+          enterTo="opacity-100"
+          leave="ease-in duration-200"
+          leaveFrom="opacity-100"
+          leaveTo="opacity-0"
+        >
+          <div className="fixed inset-0 bg-gray-500 dark:bg-gray-600 dark:bg-opacity-75 bg-opacity-75 transition-opacity" />
+        </Transition.Child>
+
+        <div className="fixed inset-0 z-10 overflow-y-auto">
+          <div className="flex h-full items-end justify-center p-4 text-center sm:items-center sm:p-0">
+            <Transition.Child
+              as={Fragment}
+              enter="ease-out duration-300"
+              enterFrom="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
+              enterTo="opacity-100 translate-y-0 sm:scale-100"
+              leave="ease-in duration-200"
+              leaveFrom="opacity-100 translate-y-0 sm:scale-100"
+              leaveTo="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
+            >
+              <Dialog.Panel className="relative flex flex-col justify-between transform h-[600px] overflow-hidden rounded-lg bg-white dark:bg-gray-800 text-left shadow-xl transition-all sm:my-8 w-[700px]">
+                <div className=" z-50 absolute top-0 right-0 hidden pt-4 pr-4 sm:block">
+                  <button
+                    type="button"
+                    className="rounded-md text-gray-400 hover:text-gray-500"
+                    onClick={() => {
+                      setModalOpen(false);
+                    }}
+                  >
+                    <span className="sr-only">Close</span>
+                    <XMarkIcon className="h-6 w-6" aria-hidden="true" />
+                  </button>
+                </div>
+                <div className="h-full w-full flex flex-col justify-center items-center">
+                  <div className="flex w-full pb-4 z-10 justify-center shadow-sm">
+                    <div className="mx-auto mt-4 flex h-12 w-12 flex-shrink-0 items-center justify-center rounded-full bg-blue-100 dark:bg-gray-900 sm:mx-0 sm:h-10 sm:w-10">
+                      <DocumentTextIcon
+                        className="h-6 w-6 text-blue-600"
+                        aria-hidden="true"
+                      />
+                    </div>
+                    <div className="mt-4 text-center sm:ml-4 sm:text-left">
+                      <Dialog.Title
+                        as="h3"
+                        className="text-lg font-medium dark:text-white leading-10 text-gray-900"
+                      >
+                        {myModalTitle}
+                      </Dialog.Title>
+                    </div>
+                  </div>
+                  <div className="h-full w-full bg-gray-200 overflow-auto dark:bg-gray-900 p-4 gap-4 flex flex-row justify-center items-center">
+                    <div className="flex h-full w-full">
+                      <div className="overflow-hidden px-4 py-5 sm:p-6 w-full h-full rounded-lg bg-white dark:bg-gray-800 shadow">
+                        <textarea
+                          ref={ref}
+                          className="form-input h-full w-full rounded-lg border-gray-300 dark:border-gray-700 dark:bg-gray-900 dark:text-white"
+                          value={myValue}
+                          onChange={(e) => {
+                            setMyValue(e.target.value);
+                            setValue(e.target.value);
+                          }}
+                        />
+                      </div>
+                    </div>
+                  </div>
+                  <div className="bg-gray-200 dark:bg-gray-900 w-full pb-3 flex flex-row-reverse px-4">
+                    <button
+                      type="button"
+                      className="inline-flex w-full justify-center rounded-md border border-transparent bg-indigo-600 px-4 py-2 text-base font-medium text-white shadow-sm hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:ring-offset-2 sm:ml-3 sm:w-auto sm:text-sm"
+                      onClick={() => {
+                        switch (myModalType) {
+                          case 1:
+                            setModalOpen(false);
+                          break;
+                          case 2:
+                            checkPrompt(myValue)
+                            .then((apiReturn) => {
+                              if (apiReturn.data) {
+                                let inputVariables =
+                                  apiReturn.data.input_variables;
+                                if (inputVariables.length === 0) {
+                                  setErrorData({
+                                    title:
+                                      "The template you are attempting to use does not contain any variables for data entry.",
+                                  });
+                                } else {
+                                  setSuccessData({
+                                    title: "Prompt is ready",
+                                  });
+                                  setModalOpen(false);
+                                  setValue(myValue);
+                                }
+                              } else {
+                                setErrorData({
+                                  title: "Something went wrong, please try again",
+                                });
+                              }
+                            })
+                            .catch((error) => {
+                              return setErrorData({
+                                title:
+                                  "There is something wrong with this prompt, please review it",
+                                list: [error.response.data.detail],
+                              });
+                            });
+                          break;
+                        
+                          default:
+                            break;
+                        }
+                      }}
+                    >
+                      {myButtonText}
+                    </button>
+                  </div>
+                </div>
+              </Dialog.Panel>
+            </Transition.Child>
+          </div>
+        </div>
+      </Dialog>
+    </Transition.Root>
+  );
+}

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

@@ -4,6 +4,7 @@ import { nodeColors, nodeIcons, nodeNames } from "../../../../utils";
 import { useContext, useEffect, useState } from "react";
 import { typesContext } from "../../../../contexts/typesContext";
 import { APIClassType, APIObjectType } from "../../../../types/api";
+import Tooltip from "../../../../components/TooltipComponent";
 
 export default function ExtraSidebar() {
   const { data } = useContext(typesContext);
@@ -33,28 +34,30 @@ export default function ExtraSidebar() {
               {Object.keys(data[d])
                 .sort()
                 .map((t: string, k) => (
-                  <div key={k}>
-                    <div
-                      draggable
-                      className={" cursor-grab border-l-8 rounded-l-md"}
-                      style={{
-                        borderLeftColor: nodeColors[d] ?? nodeColors.unknown,
-                      }}
-                      onDragStart={(event) =>
-                        onDragStart(event, {
-                          type: t,
-                          node: data[d][t],
-                        })
-                      }
-                    >
-                      <div className="flex w-full justify-between text-sm px-3 py-1 items-center border-dashed border-gray-400 dark:border-gray-600 border-l-0 rounded-md rounded-l-none border">
-                        <span className="text-black dark:text-white w-36 pr-1 truncate text-xs">
-                          {t}
-                        </span>
-                        <Bars2Icon className="w-4 h-6  text-gray-400 dark:text-gray-600" />
+                  <Tooltip title={t.length > 21 ? t : ''} placement="right">
+                    <div key={k}>
+                      <div
+                        draggable
+                        className={" cursor-grab border-l-8 rounded-l-md"}
+                        style={{
+                          borderLeftColor: nodeColors[d] ?? nodeColors.unknown,
+                        }}
+                        onDragStart={(event) =>
+                          onDragStart(event, {
+                            type: t,
+                            node: data[d][t],
+                          })
+                        }
+                      >
+                        <div className="flex w-full justify-between text-sm px-3 py-1 items-center border-dashed border-gray-400 dark:border-gray-600 border-l-0 rounded-md rounded-l-none border">
+                          <span className="text-black dark:text-white w-36 pr-1 truncate text-xs">
+                            {t}
+                          </span>
+                          <Bars2Icon className="w-4 h-6  text-gray-400 dark:text-gray-600" />
+                        </div>
                       </div>
                     </div>
-                  </div>
+                  </Tooltip>
                 ))}
               {Object.keys(data[d]).length === 0 && (
                 <div className="text-gray-400 text-center">Coming soon</div>

src/frontend/src/utils.ts

@@ -26,6 +26,11 @@ export function classNames(...classes: Array<string>) {
   return classes.filter(Boolean).join(" ");
 }
 
+export enum TypeModal {
+  TEXT = 1,
+  PROMPT = 2 
+}
+
 export const textColors = {
   white: "text-white",
   red: "text-red-700",
@@ -494,3 +499,35 @@ export const programmingLanguages: languageMap = {
   css: ".css",
   // add more file extensions here, make sure the key is same as language prop in CodeBlock.tsx component
 };
+
+export function toTitleCase(str: string) {
+	let result = str
+		.split("_")
+		.map((word, index) => {
+			if (index === 0) {
+
+				return checkUpperWords(word[0].toUpperCase() + word.slice(1).toLowerCase());
+			}
+			return checkUpperWords(word.toLowerCase());
+		})
+		.join(" ");
+
+	return result
+		.split("-")
+		.map((word, index) => {
+			if (index === 0) {
+				return checkUpperWords(word[0].toUpperCase() + word.slice(1).toLowerCase());
+			}
+			return checkUpperWords(word.toLowerCase());
+		})
+		.join(" ");
+}
+
+export const upperCaseWords: string[] = ["llm", "uri"];
+export function checkUpperWords(str: string) {
+  const words = str.split(' ').map((word) => {
+    return upperCaseWords.includes(word.toLowerCase()) ? word.toUpperCase() : word[0].toUpperCase() + word.slice(1).toLowerCase();
+  });
+
+  return words.join(' ');
+}

src/frontend/tailwind.config.js

@@ -17,6 +17,7 @@ module.exports = {
 
       animation: {
         "pulse-green": "pulseGreen 1s linear",
+        'spin-once': 'spin 1s linear 0.7'
       },
       keyframes: {
         pulseGreen: {