feat: truncate parsed uploads to prevent database and frontend blocking caused by excessively large files

src/backend/base/langflow/__main__.py

@@ -138,6 +138,11 @@ def run(
         help="Defines the number of retries for the health check.",
         envvar="LANGFLOW_HEALTH_CHECK_MAX_RETRIES",
     ),
+    max_file_size_upload: int = typer.Option(
+        100,
+        help="Defines the maximum file size for the upload in MB.",
+        envvar="LANGFLOW_MAX_FILE_SIZE_UPLOAD",
+    ),
 ):
     """
     Run Langflow.
@@ -158,6 +163,7 @@ def run(
         auto_saving=auto_saving,
         auto_saving_interval=auto_saving_interval,
         health_check_max_retries=health_check_max_retries,
+        max_file_size_upload=max_file_size_upload,
     )
     # create path object if path is provided
     static_files_dir: Path | None = Path(path) if path else None

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

@@ -43,6 +43,12 @@ async def upload_file(
     storage_service: StorageService = Depends(get_storage_service),
 ):
     try:
+        max_file_size_upload = get_storage_service().settings_service.settings.max_file_size_upload
+        if file.size > max_file_size_upload * 1024 * 1024:
+            raise HTTPException(
+                status_code=413, detail=f"File size is larger than the maximum file size {max_file_size_upload}MB."
+            )
+
         flow_id_str = str(flow_id)
         file_content = await file.read()
         timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")

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

@@ -16,6 +16,7 @@
 from langflow.services.database.models.flow import FlowCreate, FlowRead
 from langflow.services.database.models.user import UserRead
 from langflow.services.tracing.schema import Log
+from langflow.utils.util_strings import truncate_long_strings
 
 
 class BuildStatus(Enum):
@@ -281,6 +282,12 @@ class VertexBuildResponse(BaseModel):
     timestamp: datetime | None = Field(default_factory=lambda: datetime.now(timezone.utc))
     """Timestamp of the build."""
 
+    @field_serializer("data")
+    def serialize_data(self, data: ResultDataResponse) -> dict:
+        data_dict = data.model_dump() if isinstance(data, BaseModel) else data
+        truncated_data = truncate_long_strings(data_dict)
+        return truncated_data
+
 
 class VerticesBuiltResponse(BaseModel):
     vertices: list[VertexBuildResponse]
@@ -341,3 +348,4 @@ class ConfigResponse(BaseModel):
     auto_saving: bool
     auto_saving_interval: int
     health_check_max_retries: int
+    max_file_size_upload: int

src/backend/base/langflow/services/database/models/transactions/model.py

@@ -2,12 +2,14 @@
 from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
 
-from pydantic import field_validator
+from pydantic import field_serializer, field_validator
 from sqlmodel import JSON, Column, Field, Relationship, SQLModel
 
 if TYPE_CHECKING:
     from langflow.services.database.models.flow.model import Flow
 
+from langflow.utils.util_strings import truncate_long_strings
+
 
 class TransactionBase(SQLModel):
     timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
@@ -32,6 +34,11 @@ def validate_flow_id(cls, value):
             value = UUID(value)
         return value
 
+    @field_serializer("outputs")
+    def serialize_outputs(self, data) -> dict:
+        truncated_data = truncate_long_strings(data)
+        return truncated_data
+
 
 class TransactionTable(TransactionBase, table=True):  # type: ignore
     __tablename__ = "transaction"

src/backend/base/langflow/services/database/models/vertex_builds/model.py

@@ -8,6 +8,8 @@
 if TYPE_CHECKING:
     from langflow.services.database.models.flow.model import Flow
 
+from langflow.utils.util_strings import truncate_long_strings
+
 
 class VertexBuildBase(SQLModel):
     timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
@@ -38,6 +40,16 @@ def serialize_timestamp(cls, value):
             value = value.replace(tzinfo=timezone.utc)
         return value
 
+    @field_serializer("data")
+    def serialize_data(self, data: dict) -> dict:
+        truncated_data = truncate_long_strings(data)
+        return truncated_data
+
+    @field_serializer("artifacts")
+    def serialize_artifacts(self, data) -> dict:
+        truncated_data = truncate_long_strings(data)
+        return truncated_data
+
 
 class VertexBuildTable(VertexBuildBase, table=True):  # type: ignore
     __tablename__ = "vertex_build"

src/backend/base/langflow/services/settings/base.py

@@ -153,6 +153,8 @@ class Settings(BaseSettings):
     """The interval in ms at which Langflow will auto save flows."""
     health_check_max_retries: int = 5
     """The maximum number of retries for the health check."""
+    max_file_size_upload: int = 100
+    """The maximum file size for the upload in MB."""
 
     @field_validator("dev")
     @classmethod

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

@@ -183,3 +183,5 @@ def python_function(text: str) -> str:
 MESSAGE_SENDER_USER = "User"
 MESSAGE_SENDER_NAME_AI = "AI"
 MESSAGE_SENDER_NAME_USER = "User"
+
+MAX_TEXT_LENGTH = 99999

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

@@ -431,6 +431,7 @@ def update_settings(
     auto_saving: bool = True,
     auto_saving_interval: int = 1000,
     health_check_max_retries: int = 5,
+    max_file_size_upload: int = 100,
 ):
     """Update the settings from a config file."""
     from langflow.services.utils import initialize_settings_service
@@ -463,6 +464,9 @@ def update_settings(
     if health_check_max_retries is not None:
         logger.debug(f"Setting health_check_max_retries to {health_check_max_retries}")
         settings_service.settings.update_settings(health_check_max_retries=health_check_max_retries)
+    if max_file_size_upload is not None:
+        logger.debug(f"Setting max_file_size_upload to {max_file_size_upload}")
+        settings_service.settings.update_settings(max_file_size_upload=max_file_size_upload)
 
 
 def is_class_method(func, cls):

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

@@ -0,0 +1,28 @@
+from langflow.utils import constants
+
+
+def truncate_long_strings(data, max_length=None):
+    """
+    Recursively traverse the dictionary or list and truncate strings longer than max_length.
+    """
+
+    if max_length is None:
+        max_length = constants.MAX_TEXT_LENGTH
+
+    if max_length < 0 or not isinstance(data, dict | list):
+        return data
+
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if isinstance(value, str) and len(value) > max_length:
+                data[key] = value[:max_length] + "..."
+            elif isinstance(value, (dict | list)):
+                truncate_long_strings(value, max_length)
+    elif isinstance(data, list):
+        for index, item in enumerate(data):
+            if isinstance(item, str) and len(item) > max_length:
+                data[index] = item[:max_length] + "..."
+            elif isinstance(item, (dict | list)):
+                truncate_long_strings(item, max_length)
+
+    return data

src/backend/tests/unit/utils/test_truncate_long_strings_on_objects.py

@@ -0,0 +1,98 @@
+from langflow.utils.util_strings import truncate_long_strings
+from langflow.utils.constants import MAX_TEXT_LENGTH
+import pytest
+
+
+@pytest.mark.parametrize(
+    "input_data, max_length, expected",
+    [
+        # Test case 1: Simple string truncation
+        ({"key": "a" * 100}, 10, {"key": "a" * 10 + "..."}),
+        # Test case 2: Nested dictionary
+        ({"outer": {"inner": "b" * 100}}, 5, {"outer": {"inner": "b" * 5 + "..."}}),
+        # Test case 3: List of strings
+        (["short", "a" * 100, "also short"], 7, ["short", "a" * 7 + "...", "also sh" + "..."]),
+        # Test case 4: Mixed nested structure
+        (
+            {"key1": ["a" * 100, {"nested": "b" * 100}], "key2": "c" * 100},
+            8,
+            {"key1": ["a" * 8 + "...", {"nested": "b" * 8 + "..."}], "key2": "c" * 8 + "..."},
+        ),
+        # Test case 5: Empty structures
+        ({}, 10, {}),
+        ([], 10, []),
+        # Test case 6: Strings at exact max_length
+        ({"exact": "a" * 10}, 10, {"exact": "a" * 10}),
+        # Test case 7: Non-string values
+        ({"num": 12345, "bool": True, "none": None}, 5, {"num": 12345, "bool": True, "none": None}),
+        # Test case 8: Unicode characters
+        ({"unicode": "こんにちは世界"}, 3, {"unicode": "こんに..."}),
+        # Test case 9: Very large structure
+        (
+            {"key" + str(i): "value" * i for i in range(1000)},
+            10,
+            {"key" + str(i): ("value" * i)[:10] + "..." if len("value" * i) > 10 else "value" * i for i in range(1000)},
+        ),
+    ],
+)
+def test_truncate_long_strings(input_data, max_length, expected):
+    result = truncate_long_strings(input_data, max_length)
+    assert result == expected
+
+
+def test_truncate_long_strings_default_max_length():
+    long_string = "a" * (MAX_TEXT_LENGTH + 1)
+    input_data = {"key": long_string}
+    result = truncate_long_strings(input_data)
+    assert len(result["key"]) == MAX_TEXT_LENGTH + 3  # +3 for the "..."
+
+
+def test_truncate_long_strings_no_modification():
+    input_data = {"short": "short string", "nested": {"also_short": "another short string"}}
+    result = truncate_long_strings(input_data, 100)
+    assert result == input_data
+
+
+# Test for type preservation
+def test_truncate_long_strings_type_preservation():
+    input_data = {"str": "a" * 100, "list": ["b" * 100], "dict": {"nested": "c" * 100}}
+    result = truncate_long_strings(input_data, 10)
+    assert isinstance(result, dict)
+    assert isinstance(result["str"], str)
+    assert isinstance(result["list"], list)
+    assert isinstance(result["dict"], dict)
+
+
+# Test for in-place modification
+def test_truncate_long_strings_in_place_modification():
+    input_data = {"key": "a" * 100}
+    result = truncate_long_strings(input_data, 10)
+    assert result is input_data  # Check if the same object is returned
+
+
+# Test for invalid input
+def test_truncate_long_strings_invalid_input():
+    input_string = "not a dict or list"
+    result = truncate_long_strings(input_string, 10)
+    assert result == input_string  # The function should return the input unchanged
+
+
+# Updated test for negative max_length
+def test_truncate_long_strings_negative_max_length():
+    input_data = {"key": "value"}
+    result = truncate_long_strings(input_data, -1)
+    assert result == input_data  # Assuming the function ignores negative max_length
+
+
+# Additional test for zero max_length
+def test_truncate_long_strings_zero_max_length():
+    input_data = {"key": "value"}
+    result = truncate_long_strings(input_data, 0)
+    assert result == {"key": "..."}  # Assuming the function truncates to just "..."
+
+
+# Test for very small positive max_length
+def test_truncate_long_strings_small_max_length():
+    input_data = {"key": "value"}
+    result = truncate_long_strings(input_data, 1)
+    assert result == {"key": "v..."}  # Assuming the function keeps at least one character

src/frontend/src/CustomNodes/GenericNode/components/outputModal/components/switchOutputView/index.tsx

@@ -1,4 +1,6 @@
+import { MAX_TEXT_LENGTH } from "@/constants/constants";
 import { LogsLogType, OutputLogType } from "@/types/api";
+import { useMemo } from "react";
 import DataOutputComponent from "../../../../../../components/dataOutputComponent";
 import ForwardedIconComponent from "../../../../../../components/genericIconComponent";
 import {
@@ -16,6 +18,7 @@ interface SwitchOutputViewProps {
   outputName: string;
   type: "Outputs" | "Logs";
 }
+
 const SwitchOutputView: React.FC<SwitchOutputViewProps> = ({
   nodeId,
   outputName,
@@ -35,30 +38,59 @@ const SwitchOutputView: React.FC<SwitchOutputViewProps> = ({
   if (resultMessage?.raw) {
     resultMessage = resultMessage.raw;
   }
+
+  const resultMessageMemoized = useMemo(() => {
+    if (
+      typeof resultMessage === "string" &&
+      resultMessage.length > MAX_TEXT_LENGTH
+    ) {
+      resultMessage = `${resultMessage.substring(0, MAX_TEXT_LENGTH)}...`;
+    }
+
+    if (Array.isArray(resultMessage)) {
+      resultMessage = resultMessage.map((item) => {
+        if (item && typeof item.data === "object") {
+          const truncatedData = Object.fromEntries(
+            Object.entries(item.data).map(([key, value]) => {
+              if (typeof value === "string" && value.length > MAX_TEXT_LENGTH) {
+                return [key, `${value.substring(0, MAX_TEXT_LENGTH)}...`];
+              }
+              return [key, value];
+            }),
+          );
+          return { ...item, data: truncatedData };
+        }
+        return item;
+      });
+    }
+
+    return resultMessage;
+  }, [resultMessage]);
+
   return type === "Outputs" ? (
     <>
       <Case condition={!resultType || resultType === "unknown"}>
         <div>NO OUTPUT</div>
       </Case>
       <Case condition={resultType === "error" || resultType === "ValueError"}>
         <ErrorOutput
-          value={`${resultMessage.errorMessage}\n\n${resultMessage.stackTrace}`}
+          value={`${resultMessageMemoized.errorMessage}\n\n${resultMessageMemoized.stackTrace}`}
         ></ErrorOutput>
       </Case>
 
       <Case condition={resultType === "text"}>
-        <TextOutputView left={false} value={resultMessage} />
+        <TextOutputView left={false} value={resultMessageMemoized} />
       </Case>
 
       <Case condition={RECORD_TYPES.includes(resultType)}>
         <DataOutputComponent
           rows={
-            Array.isArray(resultMessage)
-              ? (resultMessage as Array<any>).every((item) => item.data)
-                ? (resultMessage as Array<any>).map((item) => item.data)
-                : resultMessage
-              : Object.keys(resultMessage).length > 0
-                ? [resultMessage]
+            Array.isArray(resultMessageMemoized)
+              ? (resultMessageMemoized as Array<any>).every((item) => item.data)
+                ? (resultMessageMemoized as Array<any>).map((item) => item.data)
+                : resultMessageMemoized
+              : Object.keys(resultMessageMemoized).length > 0
+                ? [resultMessageMemoized]
                 : []
           }
           pagination={true}

src/frontend/src/components/inputFileComponent/index.tsx

@@ -1,6 +1,6 @@
-import { maxSizeFilesInBytes } from "@/constants/constants";
 import { usePostUploadFile } from "@/controllers/API/queries/files/use-post-upload-file";
 import { createFileUpload } from "@/helpers/create-file-upload";
+import { useUtilityStore } from "@/stores/utilityStore";
 import { useEffect } from "react";
 import {
   CONSOLE_ERROR_MSG,
@@ -23,7 +23,7 @@ export default function InputFileComponent({
 }: FileComponentType): JSX.Element {
   const currentFlowId = useFlowsManagerStore((state) => state.currentFlowId);
   const setErrorData = useAlertStore((state) => state.setErrorData);
-
+  const maxFileSizeUpload = useUtilityStore((state) => state.maxFileSizeUpload);
   // Clear component state
   useEffect(() => {
     if (disabled && value !== "") {
@@ -47,9 +47,9 @@ export default function InputFileComponent({
     createFileUpload({ multiple: false, accept: fileTypes?.join(",") }).then(
       (files) => {
         const file = files[0];
-        if (file.size > maxSizeFilesInBytes) {
+        if (file.size > maxFileSizeUpload) {
           setErrorData({
-            title: INVALID_FILE_SIZE_ALERT(10),
+            title: INVALID_FILE_SIZE_ALERT(maxFileSizeUpload / 1024 / 1024),
           });
           return;
         }
@@ -68,8 +68,12 @@ export default function InputFileComponent({
                   // sets the value to the user
                   handleOnNewValue({ value: file.name, file_path });
                 },
-                onError: () => {
+                onError: (error) => {
                   console.error(CONSOLE_ERROR_MSG);
+                  setErrorData({
+                    title: "Error uploading file",
+                    list: [error.response?.data?.detail],
+                  });
                 },
               },
             );