Add custom components for message history and text to record conversion

src/backend/langflow/components/helpers/CustomComponent.py

@@ -3,6 +3,8 @@ from langflow.field_typing import Data
 
 
 class Component(CustomComponent):
+    display_name = "Custom Component"
+    description = "Use as a template to create your own component."
     documentation: str = "http://docs.langflow.org/components/custom"
     icon = "custom_components"
 

src/backend/langflow/components/helpers/MessageHistory.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+
+from langflow import CustomComponent
+from langflow.memory import get_messages
+from langflow.schema import Record
+
+
+class MessageHistoryComponent(CustomComponent):
+    display_name = "Message History"
+    description = "Used to retrieve stored messages."
+    beta: bool = True
+
+    def build_config(self):
+        return {
+            "sender": {
+                "options": ["Machine", "User", "Machine and User"],
+                "display_name": "Sender Type",
+            },
+            "sender_name": {"display_name": "Sender Name"},
+            "n_messages": {
+                "display_name": "Number of Messages",
+                "info": "Number of messages to retrieve.",
+            },
+            "session_id": {
+                "display_name": "Session ID",
+                "info": "Session ID of the chat history.",
+                "input_types": ["Text"],
+            },
+        }
+
+    def build(
+        self,
+        sender: Optional[str] = None,
+        sender_name: Optional[str] = None,
+        session_id: Optional[str] = None,
+        n_messages: int = 5,
+    ) -> List[Record]:
+        if sender == "Machine and User":
+            sender = None
+        messages = get_messages(
+            sender=sender,
+            sender_name=sender_name,
+            session_id=session_id,
+            limit=n_messages,
+        )
+        self.status = messages
+        return messages

src/backend/langflow/components/helpers/TextToRecord.py

@@ -0,0 +1,98 @@
+from typing import Any, Optional
+
+from langflow import CustomComponent
+from langflow.schema import Record
+from langflow.template.field.base import TemplateField
+
+
+class TextToRecordComponent(CustomComponent):
+    display_name = "Text to Record"
+    description = "A component to create a record from key-value pairs."
+    field_order = ["mode", "keys", "n_keys"]
+    beta: bool = True
+
+    def set_key_template(self, build_config, field_value):
+        keys_template = TemplateField(
+            name="n_keys" if field_value == "Number" else "keys",
+            field_type="dict" if field_value == "Number" else "str",
+            is_list=False if field_value == "Number" else True,
+            display_name="Keys",
+            info=(
+                "The Number of keys to use for the record."
+                if field_value == "Number"
+                else "The keys to use for the record."
+            ),
+            input_types=["Text"],
+        )
+        build_config["keys"] = keys_template.to_dict()
+
+    def set_n_keys(self, build_config, field_name, field_value):
+        if int(field_value) == 0:
+            keep = ["n_keys", "code"]
+            for key in build_config.copy():
+                if key in keep:
+                    continue
+                del build_config[key]
+        build_config[field_name]["value"] = int(field_value)
+
+        # Add new fields depending on the field value
+        for i in range(int(field_value)):
+            field = TemplateField(
+                name=f"Key and Value {i}",
+                field_type="dict",
+                display_name="",
+                info="The key for the record.",
+                input_types=["Text"],
+            )
+            build_config[field.name] = field.to_dict()
+
+    def set_keys_template(self, build_config, field_value):
+        for key in build_config.copy():
+            if key == "keys":
+                continue
+            del build_config[key]
+        for i in range(int(field_value)):
+            field = TemplateField(
+                name=f"Key and Value {i}",
+                field_type="dict",
+                display_name="",
+                info="The key for the record.",
+                input_types=["Text"],
+            )
+            build_config[field.name] = field.to_dict()
+
+    def update_build_config(
+        self,
+        build_config: dict,
+        field_value: Any,
+        field_name: Optional[str] = None,
+    ):
+        if field_name == "mode":
+            build_config["mode"]["value"] = field_value
+            self.set_key_template(build_config, field_value)
+        if field_value is None:
+            return
+        if field_name == "n_keys":
+            self.set_n_keys(build_config, field_name, field_value)
+        elif field_name == "keys":
+            self.set_keys_template(build_config, field_value)
+        return build_config
+
+    def build_config(self):
+        return {
+            "mode": {
+                "display_name": "Mode",
+                "options": ["Text", "Number"],
+                "info": "The mode to use for creating the record.",
+                "real_time_refresh": True,
+                "input_types": [],
+            },
+        }
+
+    def build(self, mode: str, **kwargs) -> Record:
+        if mode == "Text":
+            data = kwargs
+        else:
+            data = {k: v for key, d in kwargs.items() for k, v in d.items() if key not in ["mode", "n_keys", "keys"]}
+        record = Record(data=data)
+        return record

src/backend/langflow/components/models/HuggingFaceModel.py

@@ -8,7 +8,7 @@ from langflow.field_typing import Text
 
 
 class HuggingFaceEndpointsComponent(LCModelComponent):
-    display_name: str = "Hugging Face Inference API"
+    display_name: str = "Hugging Face API"
     description: str = "Generate text using LLM model from Hugging Face Inference API."
     icon = "HuggingFace"