Format py

src/backend/langflow/api/v1/base.py

@@ -86,9 +86,7 @@ def validate_prompt(template: str):
     # Check if there are invalid characters in the input_variables
     input_variables = check_input_variables(input_variables)
     if any(var in INVALID_NAMES for var in input_variables):
-        raise ValueError(
-            f"Invalid input variables. None of the variables can be named {', '.join(input_variables)}. "
-        )
+        raise ValueError(f"Invalid input variables. None of the variables can be named {', '.join(input_variables)}. ")
 
     try:
         PromptTemplate(template=template, input_variables=input_variables)
@@ -123,9 +121,7 @@ def fix_variable(var, invalid_chars, wrong_variables):
     # Handle variables starting with a number
     if var[0].isdigit():
         invalid_chars.append(var[0])
-        new_var, invalid_chars, wrong_variables = fix_variable(
-            var[1:], invalid_chars, wrong_variables
-        )
+        new_var, invalid_chars, wrong_variables = fix_variable(var[1:], invalid_chars, wrong_variables)
 
     # Temporarily replace {{ and }} to avoid treating them as invalid
     new_var = new_var.replace("{{", "ᴛᴇᴍᴘᴏᴘᴇɴ").replace("}}", "ᴛᴇᴍᴘᴄʟᴏsᴇ")
@@ -152,9 +148,7 @@ def check_variable(var, invalid_chars, wrong_variables, empty_variables):
     return wrong_variables, empty_variables
 
 
-def check_for_errors(
-    input_variables, fixed_variables, wrong_variables, empty_variables
-):
+def check_for_errors(input_variables, fixed_variables, wrong_variables, empty_variables):
     if any(var for var in input_variables if var not in fixed_variables):
         error_message = (
             f"Error: Input variables contain invalid characters or formats. \n"
@@ -179,17 +173,11 @@ def check_input_variables(input_variables):
         if is_json_like(var):
             continue
 
-        new_var, wrong_variables, empty_variables = fix_variable(
-            var, invalid_chars, wrong_variables
-        )
-        wrong_variables, empty_variables = check_variable(
-            var, INVALID_CHARACTERS, wrong_variables, empty_variables
-        )
+        new_var, wrong_variables, empty_variables = fix_variable(var, invalid_chars, wrong_variables)
+        wrong_variables, empty_variables = check_variable(var, INVALID_CHARACTERS, wrong_variables, empty_variables)
         fixed_variables.append(new_var)
         variables_to_check.append(var)
 
-    check_for_errors(
-        variables_to_check, fixed_variables, wrong_variables, empty_variables
-    )
+    check_for_errors(variables_to_check, fixed_variables, wrong_variables, empty_variables)
 
     return fixed_variables

src/backend/langflow/api/v1/callback.py

@@ -33,9 +33,7 @@ class AsyncStreamingLLMCallbackHandleSIO(AsyncCallbackHandler):
         resp = ChatResponse(message=token, type="stream", intermediate_steps="")
         await self.socketio_service.emit_token(to=self.sid, data=resp.model_dump())
 
-    async def on_tool_start(
-        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
-    ) -> Any:
+    async def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs: Any) -> Any:
         """Run when tool starts running."""
         resp = ChatResponse(
             message="",
@@ -73,9 +71,7 @@ class AsyncStreamingLLMCallbackHandleSIO(AsyncCallbackHandler):
         try:
             # This is to emulate the stream of tokens
             for resp in resps:
-                await self.socketio_service.emit_token(
-                    to=self.sid, data=resp.model_dump()
-                )
+                await self.socketio_service.emit_token(to=self.sid, data=resp.model_dump())
         except Exception as exc:
             logger.error(f"Error sending response: {exc}")
 
@@ -101,9 +97,7 @@ class AsyncStreamingLLMCallbackHandleSIO(AsyncCallbackHandler):
             resp = PromptResponse(
                 prompt=text,
             )
-            await self.socketio_service.emit_message(
-                to=self.sid, data=resp.model_dump()
-            )
+            await self.socketio_service.emit_message(to=self.sid, data=resp.model_dump())
 
     async def on_agent_action(self, action: AgentAction, **kwargs: Any):
         log = f"Thought: {action.log}"
@@ -113,9 +107,7 @@ class AsyncStreamingLLMCallbackHandleSIO(AsyncCallbackHandler):
             logs = log.split("\n")
             for log in logs:
                 resp = ChatResponse(message="", type="stream", intermediate_steps=log)
-                await self.socketio_service.emit_token(
-                    to=self.sid, data=resp.model_dump()
-                )
+                await self.socketio_service.emit_token(to=self.sid, data=resp.model_dump())
         else:
             resp = ChatResponse(message="", type="stream", intermediate_steps=log)
             await self.socketio_service.emit_token(to=self.sid, data=resp.model_dump())

src/backend/langflow/api/v1/chat.py

@@ -101,12 +101,8 @@ async def build_vertex(
         cache = chat_service.get_cache(flow_id)
         if not cache:
             # If there's no cache
-            logger.warning(
-                f"No cache found for {flow_id}. Building graph starting at {vertex_id}"
-            )
-            graph = build_and_cache_graph(
-                flow_id=flow_id, session=next(get_session()), chat_service=chat_service
-            )
+            logger.warning(f"No cache found for {flow_id}. Building graph starting at {vertex_id}")
+            graph = build_and_cache_graph(flow_id=flow_id, session=next(get_session()), chat_service=chat_service)
         else:
             graph = cache.get("result")
         result_data_response = ResultDataResponse(results={})
@@ -126,9 +122,7 @@ async def build_vertex(
             else:
                 raise ValueError(f"No result found for vertex {vertex_id}")
             next_vertices_ids = vertex.successors_ids
-            next_vertices_ids = [
-                v for v in next_vertices_ids if graph.should_run_vertex(v)
-            ]
+            next_vertices_ids = [v for v in next_vertices_ids if graph.should_run_vertex(v)]
 
             result_data_response = ResultDataResponse(**result_dict.model_dump())
 
@@ -211,9 +205,7 @@ async def build_vertex_stream(
                     else:
                         graph = cache.get("result")
                 else:
-                    session_data = await session_service.load_session(
-                        session_id, flow_id=flow_id
-                    )
+                    session_data = await session_service.load_session(session_id, flow_id=flow_id)
                     graph, artifacts = session_data if session_data else (None, None)
                     if not graph:
                         raise ValueError(f"No graph found for {flow_id}.")

src/backend/langflow/api/v1/endpoints.py

@@ -52,9 +52,7 @@ def get_all(
         raise HTTPException(status_code=500, detail=str(exc)) from exc
 
 
-@router.post(
-    "/run/{flow_id}", response_model=RunResponse, response_model_exclude_none=True
-)
+@router.post("/run/{flow_id}", response_model=RunResponse, response_model_exclude_none=True)
 async def run_flow_with_caching(
     session: Annotated[Session, Depends(get_session)],
     flow_id: str,
@@ -113,9 +111,7 @@ async def run_flow_with_caching(
             outputs = []
 
         if session_id:
-            session_data = await session_service.load_session(
-                session_id, flow_id=flow_id
-            )
+            session_data = await session_service.load_session(session_id, flow_id=flow_id)
             graph, artifacts = session_data if session_data else (None, None)
             task_result: Any = None
             if not graph:
@@ -134,11 +130,7 @@ async def run_flow_with_caching(
         else:
             # Get the flow that matches the flow_id and belongs to the user
             # flow = session.query(Flow).filter(Flow.id == flow_id).filter(Flow.user_id == api_key_user.id).first()
-            flow = session.exec(
-                select(Flow)
-                .where(Flow.id == flow_id)
-                .where(Flow.user_id == api_key_user.id)
-            ).first()
+            flow = session.exec(select(Flow).where(Flow.id == flow_id).where(Flow.user_id == api_key_user.id)).first()
             if flow is None:
                 raise ValueError(f"Flow {flow_id} not found")
 
@@ -162,18 +154,12 @@ async def run_flow_with_caching(
         # StatementError('(builtins.ValueError) badly formed hexadecimal UUID string')
         if "badly formed hexadecimal UUID string" in str(exc):
             # This means the Flow ID is not a valid UUID which means it can't find the flow
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)
-            ) from exc
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
     except ValueError as exc:
         if f"Flow {flow_id} not found" in str(exc):
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)
-            ) from exc
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
         else:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc)
-            ) from exc
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc)) from exc
 
 
 @router.post(
@@ -202,8 +188,7 @@ async def process(
     """
     # Raise a depreciation warning
     logger.warning(
-        "The /process endpoint is deprecated and will be removed in a future version. "
-        "Please use /run instead."
+        "The /process endpoint is deprecated and will be removed in a future version. " "Please use /run instead."
     )
     raise HTTPException(
         status_code=status.HTTP_400_BAD_REQUEST,
@@ -275,16 +260,12 @@ async def custom_component(
 
     built_frontend_node = build_custom_component_template(component, user_id=user.id)
 
-    built_frontend_node = update_frontend_node_with_template_values(
-        built_frontend_node, raw_code.frontend_node
-    )
+    built_frontend_node = update_frontend_node_with_template_values(built_frontend_node, raw_code.frontend_node)
     return built_frontend_node
 
 
 @router.post("/custom_component/reload", status_code=HTTPStatus.OK)
-async def reload_custom_component(
-    path: str, user: User = Depends(get_current_active_user)
-):
+async def reload_custom_component(path: str, user: User = Depends(get_current_active_user)):
     from langflow.interface.custom.utils import build_custom_component_template
 
     try:

src/backend/langflow/api/v1/flows.py

@@ -57,11 +57,7 @@ def read_flows(
     try:
         auth_settings = settings_service.auth_settings
         if auth_settings.AUTO_LOGIN:
-            flows = session.exec(
-                select(Flow).where(
-                    Flow.user_id == None | Flow.user_id == current_user.id
-                )
-            ).all()  # noqa
+            flows = session.exec(select(Flow).where(Flow.user_id == None | Flow.user_id == current_user.id)).all()  # noqa
         else:
             flows = current_user.flows
 
@@ -71,7 +67,8 @@ def read_flows(
         try:
             example_flows = session.exec(
                 select(Flow).where(
-                    Flow.user_id == None, Flow.folder == STARTER_FOLDER_NAME  # noqa
+                    Flow.user_id == None,
+                    Flow.folder == STARTER_FOLDER_NAME,  # noqa
                 )
             ).all()  # noqa
             for example_flow in example_flows:
@@ -98,7 +95,9 @@ def read_flow(
     if auth_settings.AUTO_LOGIN:
         # If auto login is enable user_id can be current_user.id or None
         # so write an OR
-        stmt = stmt.where((Flow.user_id == current_user.id) | (Flow.user_id == None))
+        stmt = stmt.where(
+            (Flow.user_id == current_user.id) | (Flow.user_id == None)  # noqa
+        )  # noqa
     if user_flow := session.exec(stmt).first():
         return user_flow
     else:

src/backend/langflow/api/v1/schemas.py

@@ -158,9 +158,7 @@ class StreamData(BaseModel):
     data: dict
 
     def __str__(self) -> str:
-        return (
-            f"event: {self.event}\ndata: {orjson_dumps(self.data, indent_2=False)}\n\n"
-        )
+        return f"event: {self.event}\ndata: {orjson_dumps(self.data, indent_2=False)}\n\n"
 
 
 class CustomComponentCode(BaseModel):

src/backend/langflow/api/v1/validate.py

@@ -41,9 +41,7 @@ def post_validate_prompt(prompt_request: ValidatePromptRequest):
 
         add_new_variables_to_template(input_variables, prompt_request)
 
-        remove_old_variables_from_template(
-            old_custom_fields, input_variables, prompt_request
-        )
+        remove_old_variables_from_template(old_custom_fields, input_variables, prompt_request)
 
         update_input_variables_field(input_variables, prompt_request)
 
@@ -58,19 +56,12 @@ def post_validate_prompt(prompt_request: ValidatePromptRequest):
 
 def get_old_custom_fields(prompt_request):
     try:
-        if (
-            len(prompt_request.frontend_node.custom_fields) == 1
-            and prompt_request.name == ""
-        ):
+        if len(prompt_request.frontend_node.custom_fields) == 1 and prompt_request.name == "":
             # If there is only one custom field and the name is empty string
             # then we are dealing with the first prompt request after the node was created
-            prompt_request.name = list(
-                prompt_request.frontend_node.custom_fields.keys()
-            )[0]
+            prompt_request.name = list(prompt_request.frontend_node.custom_fields.keys())[0]
 
-        old_custom_fields = prompt_request.frontend_node.custom_fields[
-            prompt_request.name
-        ]
+        old_custom_fields = prompt_request.frontend_node.custom_fields[prompt_request.name]
         if old_custom_fields is None:
             old_custom_fields = []
 
@@ -87,40 +78,26 @@ def add_new_variables_to_template(input_variables, prompt_request):
             template_field = DefaultPromptField(name=variable, display_name=variable)
             if variable in prompt_request.frontend_node.template:
                 # Set the new field with the old value
-                template_field.value = prompt_request.frontend_node.template[variable][
-                    "value"
-                ]
+                template_field.value = prompt_request.frontend_node.template[variable]["value"]
 
             prompt_request.frontend_node.template[variable] = template_field.to_dict()
 
             # Check if variable is not already in the list before appending
-            if (
-                variable
-                not in prompt_request.frontend_node.custom_fields[prompt_request.name]
-            ):
-                prompt_request.frontend_node.custom_fields[prompt_request.name].append(
-                    variable
-                )
+            if variable not in prompt_request.frontend_node.custom_fields[prompt_request.name]:
+                prompt_request.frontend_node.custom_fields[prompt_request.name].append(variable)
 
         except Exception as exc:
             logger.exception(exc)
             raise HTTPException(status_code=500, detail=str(exc)) from exc
 
 
-def remove_old_variables_from_template(
-    old_custom_fields, input_variables, prompt_request
-):
+def remove_old_variables_from_template(old_custom_fields, input_variables, prompt_request):
     for variable in old_custom_fields:
         if variable not in input_variables:
             try:
                 # Remove the variable from custom_fields associated with the given name
-                if (
-                    variable
-                    in prompt_request.frontend_node.custom_fields[prompt_request.name]
-                ):
-                    prompt_request.frontend_node.custom_fields[
-                        prompt_request.name
-                    ].remove(variable)
+                if variable in prompt_request.frontend_node.custom_fields[prompt_request.name]:
+                    prompt_request.frontend_node.custom_fields[prompt_request.name].remove(variable)
 
                 # Remove the variable from the template
                 prompt_request.frontend_node.template.pop(variable, None)
@@ -132,6 +109,4 @@ def remove_old_variables_from_template(
 
 def update_input_variables_field(input_variables, prompt_request):
     if "input_variables" in prompt_request.frontend_node.template:
-        prompt_request.frontend_node.template["input_variables"][
-            "value"
-        ] = input_variables
+        prompt_request.frontend_node.template["input_variables"]["value"] = input_variables

src/backend/langflow/base/data/utils.py

@@ -35,9 +35,7 @@ def retrieve_file_paths(
 
     glob = "**/*" if recursive else "*"
     paths = walk_level(path_obj, depth) if depth else path_obj.glob(glob)
-    file_paths = [
-        Text(p) for p in paths if p.is_file() and match_types(p) and is_not_hidden(p)
-    ]
+    file_paths = [Text(p) for p in paths if p.is_file() and match_types(p) and is_not_hidden(p)]
 
     return file_paths
 
@@ -70,16 +68,12 @@ def get_elements(
     if use_multithreading:
         records = parallel_load_records(file_paths, silent_errors, max_concurrency)
     else:
-        records = [
-            parse_file_to_record(file_path, silent_errors) for file_path in file_paths
-        ]
+        records = [parse_file_to_record(file_path, silent_errors) for file_path in file_paths]
     records = list(filter(None, records))
     return records
 
 
-def parallel_load_records(
-    file_paths: List[str], silent_errors: bool, max_concurrency: int
-) -> List[Optional[Record]]:
+def parallel_load_records(file_paths: List[str], silent_errors: bool, max_concurrency: int) -> List[Optional[Record]]:
     with futures.ThreadPoolExecutor(max_workers=max_concurrency) as executor:
         loaded_files = executor.map(
             lambda file_path: parse_file_to_record(file_path, silent_errors),

src/backend/langflow/base/io/chat.py

@@ -45,9 +45,7 @@ class ChatComponent(CustomComponent):
             return []
 
         if not session_id or not sender or not sender_name:
-            raise ValueError(
-                "All of session_id, sender, and sender_name must be provided."
-            )
+            raise ValueError("All of session_id, sender, and sender_name must be provided.")
         if isinstance(message, Record):
             record = message
             record.data.update(

src/backend/langflow/components/data/APIRequest.py

@@ -27,12 +27,12 @@ class APIRequest(CustomComponent):
         "headers": {
             "display_name": "Headers",
             "info": "The headers to send with the request.",
-            "input_types": ["dict"]
+            "input_types": ["dict"],
         },
         "body": {
             "display_name": "Body",
             "info": "The body to send with the request (for POST, PATCH, PUT).",
-            "input_types": ["dict"]
+            "input_types": ["dict"],
         },
         "timeout": {
             "display_name": "Timeout",
@@ -58,9 +58,7 @@ class APIRequest(CustomComponent):
         data = body if body else None
         data = json.dumps(data)
         try:
-            response = await client.request(
-                method, url, headers=headers, content=data, timeout=timeout
-            )
+            response = await client.request(method, url, headers=headers, content=data, timeout=timeout)
             try:
                 response_json = response.json()
                 result = orjson_dumps(response_json, indent_2=False)
@@ -96,16 +94,9 @@ class APIRequest(CustomComponent):
         if headers is None:
             headers = {}
         urls = url if isinstance(url, list) else [url]
-        bodies = (
-            body
-            if isinstance(body, list)
-            else [body] if body else [None] * len(urls)
-        )
+        bodies = body if isinstance(body, list) else [body] if body else [None] * len(urls)
         async with httpx.AsyncClient() as client:
             results = await asyncio.gather(
-                *[
-                    self.make_request(client, method, u, headers, rec, timeout)
-                    for u, rec in zip(urls, bodies)
-                ]
+                *[self.make_request(client, method, u, headers, rec, timeout) for u, rec in zip(urls, bodies)]
             )
         return results

src/backend/langflow/components/data/Directory.py

@@ -57,20 +57,13 @@ class DirectoryComponent(CustomComponent):
         if types is None:
             types = []
         resolved_path = self.resolve_path(path)
-        file_paths = retrieve_file_paths(
-            resolved_path, types, load_hidden, recursive, depth
-        )
+        file_paths = retrieve_file_paths(resolved_path, types, load_hidden, recursive, depth)
         loaded_records = []
 
         if use_multithreading:
-            loaded_records = parallel_load_records(
-                file_paths, silent_errors, max_concurrency
-            )
+            loaded_records = parallel_load_records(file_paths, silent_errors, max_concurrency)
         else:
-            loaded_records = [
-                parse_file_to_record(file_path, silent_errors)
-                for file_path in file_paths
-            ]
+            loaded_records = [parse_file_to_record(file_path, silent_errors) for file_path in file_paths]
         loaded_records = list(filter(None, loaded_records))
         self.status = loaded_records
         return loaded_records

src/backend/langflow/components/data/FileLoader.py

@@ -11,9 +11,7 @@ class FileLoaderComponent(CustomComponent):
     beta = True
 
     def build_config(self):
-        loader_options = ["Automatic"] + [
-            loader_info["name"] for loader_info in LOADERS_INFO
-        ]
+        loader_options = ["Automatic"] + [loader_info["name"] for loader_info in LOADERS_INFO]
 
         file_types = []
         suffixes = []
@@ -105,9 +103,7 @@ class FileLoaderComponent(CustomComponent):
         if isinstance(selected_loader_info, dict):
             loader_import: str = selected_loader_info["import"]
         else:
-            raise ValueError(
-                f"Loader info for {loader} is not a dict\nLoader info:\n{selected_loader_info}"
-            )
+            raise ValueError(f"Loader info for {loader} is not a dict\nLoader info:\n{selected_loader_info}")
         module_name, class_name = loader_import.rsplit(".", 1)
 
         try:
@@ -115,9 +111,7 @@ class FileLoaderComponent(CustomComponent):
             loader_module = __import__(module_name, fromlist=[class_name])
             loader_instance = getattr(loader_module, class_name)
         except ImportError as e:
-            raise ValueError(
-                f"Loader {loader} could not be imported\nLoader info:\n{selected_loader_info}"
-            ) from e
+            raise ValueError(f"Loader {loader} could not be imported\nLoader info:\n{selected_loader_info}") from e
 
         result = loader_instance(file_path=file_path)
         docs = result.load()

src/backend/langflow/components/data/URL.py

@@ -19,7 +19,6 @@ class URLComponent(CustomComponent):
         self,
         urls: list[str],
     ) -> Record:
-
         loader = WebBaseLoader(web_paths=urls)
         docs = loader.load()
         records = self.to_records(docs)

src/backend/langflow/components/experimental/Notify.py

@@ -18,9 +18,7 @@ class NotifyComponent(CustomComponent):
             },
         }
 
-    def build(
-        self, name: str, record: Optional[Record] = None, append: bool = False
-    ) -> Record:
+    def build(self, name: str, record: Optional[Record] = None, append: bool = False) -> Record:
         if record and not isinstance(record, Record):
             if isinstance(record, str):
                 record = Record(text=record)

src/backend/langflow/components/experimental/RunFlow.py

@@ -39,10 +39,7 @@ class RunFlowComponent(CustomComponent):
             records.append(record)
         return records
 
-    async def build(
-        self, input_value: Text, flow_name: str, tweaks: NestedDict
-    ) -> Record:
-
+    async def build(self, input_value: Text, flow_name: str, tweaks: NestedDict) -> Record:
         results: List[Optional[ResultData]] = await self.run_flow(
             input_value=input_value, flow_name=flow_name, tweaks=tweaks
         )

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

@@ -11,7 +11,6 @@ class ExtractKeyFromRecordComponent(CustomComponent):
     }
 
     def build(self, record: Record, key: str, silent_error: bool = True) -> dict:
-
         data = getattr(record, key)
         self.status = data
         return data

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

@@ -9,9 +9,7 @@ class UUIDGeneratorComponent(CustomComponent):
     display_name = "Unique ID Generator"
     description = "Generates a unique ID."
 
-    def update_build_config(
-        self, build_config: dict, field_name: Text, field_value: Any
-    ):
+    def update_build_config(self, build_config: dict, field_name: Text, field_value: Any):
         if field_name == "unique_id":
             build_config[field_name]["value"] = str(uuid.uuid4())
         return build_config

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

@@ -0,0 +1,47 @@
+from typing import Any
+
+from langflow import CustomComponent
+from langflow.schema import Record
+from langflow.template.field.base import TemplateField
+
+
+class RecordComponent(CustomComponent):
+    display_name = "Record Numbers"
+    description = "A component to create a record from key-value pairs."
+    field_order = ["n_keys"]
+
+    def update_build_config(self, build_config: dict, field_name: str, field_value: Any):
+        if field_value is None:
+            return
+        elif 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 build_config(self):
+        return {
+            "n_keys": {
+                "display_name": "Number of Fields",
+                "refresh": True,
+                "info": "The number of keys to create in the record.",
+            },
+        }
+
+    def build(self, n_keys: int, **kwargs) -> Record:
+        data = {k: v for d in kwargs.values() for k, v in d.items()}
+        record = Record(data=data)
+        return record

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

@@ -0,0 +1,51 @@
+from typing import Any, List
+
+from langflow import CustomComponent
+from langflow.schema import Record
+from langflow.template.field.base import TemplateField
+
+
+class RecordComponent2(CustomComponent):
+    display_name = "Record Text"
+    description = "A component to create a record from key-value pairs."
+    field_order = ["keys"]
+
+    def update_build_config(self, build_config: dict, field_name: str, field_value: Any):
+        if field_value is None:
+            field_value = []
+        if field_name is None:
+            return build_config
+        elif len(field_value) == 0:
+            keep = ["keys", "code"]
+            for key in build_config.copy():
+                if key in keep:
+                    continue
+                del build_config[key]
+        build_config[field_name]["value"] = field_value
+
+        # Add new fields depending on the field value
+        for val in field_value:
+            if not isinstance(val, str) or val == "":
+                continue
+            field = TemplateField(
+                name=val,
+                field_type="str",
+                display_name="",
+                info="The key for the record.",
+            )
+            build_config[field.name] = field.to_dict()
+
+    def build_config(self):
+        return {
+            "keys": {
+                "display_name": "Keys",
+                "refresh": True,
+                "info": "The number of keys to create in the record.",
+                "input_types": [],
+            },
+        }
+
+    def build(self, keys: List[str], **kwargs) -> Record:
+        record = Record(data=kwargs)
+        self.status = record
+        return record

src/backend/langflow/components/textsplitters/LanguageRecursiveTextSplitter.py

@@ -9,9 +9,7 @@ from langflow.schema.schema import Record
 class LanguageRecursiveTextSplitterComponent(CustomComponent):
     display_name: str = "Language Recursive Text Splitter"
     description: str = "Split text into chunks of a specified length based on language."
-    documentation: str = (
-        "https://docs.langflow.org/components/text-splitters#languagerecursivetextsplitter"
-    )
+    documentation: str = "https://docs.langflow.org/components/text-splitters#languagerecursivetextsplitter"
 
     def build_config(self):
         options = [x.value for x in Language]